diff --git a/src/grammar/postgresql/PostgreSqlParser.g4 b/src/grammar/postgresql/PostgreSqlParser.g4 index dd35d16c..63d6f9ae 100644 --- a/src/grammar/postgresql/PostgreSqlParser.g4 +++ b/src/grammar/postgresql/PostgreSqlParser.g4 @@ -53,10 +53,6 @@ program : singleStmt* EOF ; -plsqlroot - : pl_function - ; - singleStmt : stmt SEMI? ; @@ -178,11 +174,7 @@ stmt | variablesetstmt | variableshowstmt | viewstmt - | plsqlconsolecommand - ; - -plsqlconsolecommand - : MetaCommand EndMetaCommand? + | MetaCommand EndMetaCommand? ; callstmt @@ -190,65 +182,53 @@ callstmt ; createrolestmt - : KW_CREATE KW_ROLE roleid opt_with? optrolelist - ; - -opt_with - : KW_WITH - ; //| WITH_LA - -optrolelist - : createoptroleelem* - ; - -alteroptrolelist - : alteroptroleelem* + : KW_CREATE KW_ROLE rolespec KW_WITH? createoptroleelem* ; alteroptroleelem : KW_PASSWORD (sconst | KW_NULL) | (KW_ENCRYPTED | KW_UNENCRYPTED) KW_PASSWORD sconst - | (KW_INHERIT | KW_NOINHERIT) - | (KW_CREATEUSER | KW_NOCREATEUSER) - | (KW_CREATEROLE | KW_NOCREATEROLE) - | (KW_CREATEDB | KW_NOCREATEDB) - | (KW_SUPERUSER | KW_NOSUPERUSER) - | (KW_LOGIN | KW_NOLOGIN) - | (KW_REPLICATION | KW_NOREPLICATION) - | (KW_BYPASSRLS | KW_NOBYPASSRLS) + | KW_INHERIT + | KW_NOINHERIT + | KW_CREATEUSER + | KW_NOCREATEUSER + | KW_CREATEROLE + | KW_NOCREATEROLE + | KW_CREATEDB + | KW_NOCREATEDB + | KW_SUPERUSER + | KW_NOSUPERUSER + | KW_LOGIN + | KW_NOLOGIN + | KW_REPLICATION + | KW_NOREPLICATION + | KW_BYPASSRLS + | KW_NOBYPASSRLS | KW_CONNECTION KW_LIMIT signediconst | KW_VALID KW_UNTIL sconst - | KW_IN KW_ROLE name_list - | KW_IN KW_GROUP name_list - | KW_ROLE role_list + | KW_IN (KW_ROLE | KW_GROUP) name_list + | (KW_ROLE | KW_USER) role_list | KW_ADMIN name_list - | KW_USER role_list | identifier ; createoptroleelem : alteroptroleelem - | KW_SYSID iconst - | KW_ADMIN role_list - | KW_ROLE role_list + | KW_SYSID Integral + | (KW_ADMIN | KW_ROLE) role_list | KW_IN (KW_ROLE | KW_GROUP) role_list ; createuserstmt - : KW_CREATE KW_USER roleid opt_with? optrolelist + : KW_CREATE KW_USER rolespec KW_WITH? createoptroleelem* ; alterrolestmt - : KW_ALTER (KW_ROLE | KW_USER) rolespec opt_with? alteroptrolelist - ; - -opt_in_database - : - | KW_IN KW_DATABASE database_name + : KW_ALTER (KW_ROLE | KW_USER) rolespec KW_WITH? alteroptroleelem* ; alterrolesetstmt - : KW_ALTER (KW_ROLE | KW_USER) (KW_ALL | rolespec) opt_in_database setresetclause + : KW_ALTER (KW_ROLE | KW_USER) (KW_ALL | rolespec) KW_IN KW_DATABASE database_name setresetclause ; alterroutinestmt @@ -256,15 +236,11 @@ alterroutinestmt ; alter_routine_cluase - : routine_action_list KW_RESTRICT? + : routine_action (routine_action)* KW_RESTRICT? | KW_RENAME KW_TO routine_name_create | KW_OWNER KW_TO rolespec | KW_SET KW_SCHEMA schema_name_create - | KW_NO? KW_DEPENDS KW_ON KW_EXTENSION name - ; - -routine_action_list - : routine_action (routine_action)* + | KW_NO? KW_DEPENDS KW_ON KW_EXTENSION colid ; routine_action @@ -274,40 +250,30 @@ routine_action | KW_NOT? KW_LEAKPROOF | (KW_EXTERNAL? KW_SECURITY KW_INVOKER | KW_EXTERNAL? KW_SECURITY KW_DEFINER) | KW_PARALLEL (KW_UNSAFE | KW_RESTRICTED | KW_SAFE) - | KW_COST attr_name - | KW_ROWS name - | KW_SET name (KW_TO | EQUAL) (name | KW_DEFAULT) - | KW_SET name KW_FROM KW_CURRENT - | KW_RESET name - | KW_RESET KW_ALL + | KW_COST collabel + | KW_ROWS colid + | KW_SET colid (KW_TO | EQUAL) (colid | KW_DEFAULT) + | KW_SET colid KW_FROM KW_CURRENT + | KW_RESET (colid | KW_ALL) ; creategroupstmt - : KW_CREATE KW_GROUP groupname opt_with? optrolelist + : KW_CREATE KW_GROUP rolespec KW_WITH? createoptroleelem* ; altergroupstmt - : KW_ALTER KW_GROUP rolespec add_drop KW_USER role_list - ; - -add_drop - : KW_ADD - | KW_DROP + : KW_ALTER KW_GROUP rolespec (KW_ADD | KW_DROP) KW_USER role_list ; createschemastmt : KW_CREATE KW_SCHEMA opt_if_not_exists? ( schema_name_create? KW_AUTHORIZATION rolespec | schema_name_create - ) optschemaeltlist + ) schema_stmt* ; schema_name_create - : colid attrs? # schemaNameCreate - ; - -optschemaeltlist - : schema_stmt* + : any_name # schemaNameCreate ; schema_stmt @@ -337,7 +303,7 @@ set_rest_more : KW_TIME KW_ZONE zone_value | KW_CATALOG sconst | KW_SCHEMA schema_name - | KW_NAMES opt_encoding? + | KW_NAMES (sconst | KW_DEFAULT)? | KW_ROLE nonreservedword_or_sconst | KW_SESSION KW_AUTHORIZATION nonreservedword_or_sconst | KW_XML KW_OPTION document_or_content @@ -369,7 +335,9 @@ opt_boolean_or_string_column : KW_TRUE | KW_FALSE | KW_ON - | nonreservedword_or_sconst_column + | column_name + | type_func_name_keyword + | sconst ; opt_boolean_or_string @@ -381,24 +349,14 @@ opt_boolean_or_string zone_value : sconst + | KW_DEFAULT | identifier - | constinterval sconst opt_interval? - | constinterval OPEN_PAREN iconst CLOSE_PAREN sconst + | KW_INTERVAL sconst opt_interval? + | KW_INTERVAL opt_float sconst | numericonly - | KW_DEFAULT | KW_LOCAL ; -opt_encoding - : sconst - | KW_DEFAULT - ; - -nonreservedword_or_sconst_column - : nonreservedword_column - | sconst - ; - nonreservedword_or_sconst : nonreservedword | sconst @@ -412,11 +370,7 @@ reset_rest : KW_TIME KW_ZONE | KW_TRANSACTION KW_ISOLATION KW_LEVEL | KW_SESSION KW_AUTHORIZATION - | generic_reset - ; - -generic_reset - : KW_ALL + | KW_ALL | var_name ; @@ -441,17 +395,7 @@ variableshowstmt ; constraintssetstmt - : KW_SET KW_CONSTRAINTS constraints_set_list constraints_set_mode - ; - -constraints_set_list - : KW_ALL - | qualified_name_list - ; - -constraints_set_mode - : KW_DEFERRED - | KW_IMMEDIATE + : KW_SET KW_CONSTRAINTS (KW_ALL | qualified_name_list) (KW_DEFERRED | KW_IMMEDIATE) ; checkpointstmt @@ -464,8 +408,8 @@ discardstmt altertablestmt : KW_ALTER KW_TABLE opt_if_exists? relation_expr (alter_table_cmds | partition_cmd) - | KW_ALTER KW_TABLE KW_ALL KW_IN KW_TABLESPACE tablespace_name (KW_OWNED KW_BY role_list)? KW_SET KW_TABLESPACE tablespace_name_create opt_nowait? - | KW_ALTER KW_TABLE opt_if_exists? table_name KW_ATTACH KW_PARTITION qualified_name ( + | KW_ALTER KW_TABLE KW_ALL KW_IN opttablespace (KW_OWNED KW_BY role_list)? KW_SET KW_TABLESPACE tablespace_name_create KW_NOWAIT? + | KW_ALTER KW_TABLE opt_if_exists? table_name index_partition_cmd ( KW_FOR KW_VALUES partition_bound_spec | KW_DEFAULT ) @@ -474,13 +418,10 @@ altertablestmt | KW_FINALIZE )? | KW_ALTER KW_INDEX opt_if_exists? qualified_name (alter_table_cmds | index_partition_cmd) - | KW_ALTER KW_INDEX KW_ALL KW_IN KW_TABLESPACE tablespace_name (KW_OWNED KW_BY role_list)? KW_SET KW_TABLESPACE tablespace_name opt_nowait? + | KW_ALTER KW_INDEX KW_ALL KW_IN opttablespace (KW_OWNED KW_BY role_list)? KW_SET opttablespace KW_NOWAIT? | KW_ALTER KW_SEQUENCE opt_if_exists? qualified_name alter_table_cmds - | KW_ALTER KW_VIEW opt_if_exists? view_name alter_table_cmds - | KW_ALTER KW_MATERIALIZED KW_VIEW opt_if_exists? view_name alter_table_cmds - | KW_ALTER KW_MATERIALIZED KW_VIEW KW_ALL KW_IN KW_TABLESPACE tablespace_name ( - KW_OWNED KW_BY role_list - )? KW_SET KW_TABLESPACE tablespace_name_create opt_nowait? + | KW_ALTER KW_MATERIALIZED? KW_VIEW opt_if_exists? view_name alter_table_cmds + | KW_ALTER KW_MATERIALIZED KW_VIEW KW_ALL KW_IN opttablespace (KW_OWNED KW_BY role_list)? KW_SET KW_TABLESPACE tablespace_name_create KW_NOWAIT? | KW_ALTER KW_FOREIGN KW_TABLE opt_if_exists? relation_expr alter_table_cmds ; @@ -489,7 +430,7 @@ alter_table_cmds ; partition_bound_spec - : KW_IN opt_type_modifiers + : KW_IN execute_param_clause | KW_FROM partition_bound_cluase KW_TO partition_bound_cluase | KW_WITH partition_with_cluase ; @@ -499,7 +440,7 @@ partition_bound_cluase ; partition_bound_choose - : opt_type_modifiers + : execute_param_clause | KW_MINVALUE | KW_MAXVALUE ; @@ -509,7 +450,7 @@ partition_with_cluase ; partition_cmd - : KW_ATTACH KW_PARTITION qualified_name partitionboundspec + : index_partition_cmd partitionboundspec | KW_DETACH KW_PARTITION qualified_name ; @@ -518,48 +459,48 @@ index_partition_cmd ; alter_table_cmd - : KW_ADD (KW_CONSTRAINT name)? constraintelem - | KW_ALTER KW_CONSTRAINT name constraintattributespec - | KW_VALIDATE KW_CONSTRAINT name - | KW_DROP KW_CONSTRAINT opt_if_exists? name opt_drop_behavior? - | KW_SET KW_WITHOUT KW_OIDS - | KW_CLUSTER KW_ON name - | KW_SET KW_WITHOUT KW_CLUSTER + : KW_ADD (KW_CONSTRAINT colid)? constraintelem + | KW_ALTER KW_CONSTRAINT colid constraintattributeElem* + | KW_VALIDATE KW_CONSTRAINT colid + | KW_DROP KW_CONSTRAINT opt_if_exists? colid opt_drop_behavior? + | KW_SET KW_WITHOUT (KW_OIDS | KW_CLUSTER) + | KW_CLUSTER KW_ON colid | KW_SET (KW_LOGGED | KW_UNLOGGED) | KW_ENABLE (KW_REPLICA | KW_ALWAYS)? KW_TRIGGER - | KW_DISABLE KW_TRIGGER (KW_ALL | KW_USER | name) - | KW_ENABLE (KW_ALWAYS | KW_REPLICA) KW_RULE name - | KW_DISABLE KW_RULE name + | KW_DISABLE KW_TRIGGER (KW_ALL | KW_USER | colid) + | KW_ENABLE (KW_ALWAYS | KW_REPLICA) KW_RULE colid + | KW_DISABLE KW_RULE colid | KW_NO? KW_INHERIT qualified_name | KW_OF any_name | KW_NOT KW_OF | KW_OWNER KW_TO rolespec | KW_SET KW_TABLESPACE tablespace_name_create - | KW_SET reloptions - | KW_RESET reloptions - | KW_REPLICA KW_IDENTITY replica_identity - | KW_ENABLE KW_ROW KW_LEVEL KW_SECURITY - | KW_DISABLE KW_ROW KW_LEVEL KW_SECURITY - | KW_FORCE KW_ROW KW_LEVEL KW_SECURITY - | KW_NO KW_FORCE KW_ROW KW_LEVEL KW_SECURITY + | KW_REPLICA KW_IDENTITY (KW_NOTHING | KW_FULL | KW_DEFAULT | existingindex) + | (KW_ENABLE | KW_DISABLE | (KW_NO? KW_FORCE)) KW_ROW KW_LEVEL KW_SECURITY | KW_DROP KW_COLUMN? opt_if_exists? column_name opt_drop_behavior? | KW_ADD KW_COLUMN? opt_if_not_exists? column_def - | KW_ALTER KW_COLUMN? column_name alter_column_default + | KW_ALTER KW_COLUMN? column_name (alter_column_default | alter_generic_options) | KW_ALTER KW_COLUMN? column_name (KW_DROP | KW_SET) KW_NOT KW_NULL | KW_ALTER KW_COLUMN? column_name KW_DROP KW_EXPRESSION opt_if_exists? | KW_ALTER KW_COLUMN? column_name KW_SET KW_STATISTICS signediconst - | KW_ALTER KW_COLUMN? column_name (KW_SET | KW_RESET) reloptions + | (KW_ALTER KW_COLUMN? column_name)? (KW_SET | KW_RESET) reloptions | KW_ALTER KW_COLUMN? column_name KW_SET KW_STORAGE colid - | KW_ALTER KW_COLUMN? column_name KW_ADD KW_GENERATED generated_when KW_AS KW_IDENTITY optparenthesizedseqoptlist? - | KW_ALTER KW_COLUMN? column_name alter_identity_column_option_list + | KW_ALTER KW_COLUMN? column_name KW_ADD KW_GENERATED generated_when KW_AS KW_IDENTITY ( + OPEN_PAREN seqoptelem+ CLOSE_PAREN + )? + | KW_ALTER KW_COLUMN? column_name ( + KW_RESTART (KW_WITH? numericonly)? + | KW_SET (seqoptelem | KW_GENERATED generated_when) + )+ | KW_ALTER KW_COLUMN? column_name KW_DROP KW_IDENTITY opt_if_exists? - | KW_ALTER KW_COLUMN? column_name opt_set_data? KW_TYPE typename opt_collate_clause? alter_using? - | KW_ALTER KW_COLUMN? column_name alter_generic_options + | KW_ALTER KW_COLUMN? column_name (KW_SET KW_DATA)? KW_TYPE typename opt_collate_clause? ( + KW_USING expression + )? | alter_generic_options ; alter_column_default - : KW_SET KW_DEFAULT a_expr + : KW_SET KW_DEFAULT expression | KW_DROP KW_DEFAULT ; @@ -572,160 +513,82 @@ opt_collate_clause : KW_COLLATE any_name ; -alter_using - : KW_USING a_expr - ; - -replica_identity - : KW_NOTHING - | KW_FULL - | KW_DEFAULT - | KW_USING KW_INDEX name - ; - reloptions - : OPEN_PAREN reloption_list CLOSE_PAREN + : OPEN_PAREN reloption_elem (COMMA reloption_elem)* CLOSE_PAREN ; opt_reloptions : KW_WITH reloptions ; -reloption_list - : reloption_elem (COMMA reloption_elem)* - ; - reloption_elem - : collabel (EQUAL def_arg | DOT collabel (EQUAL def_arg)?)? - ; - -alter_identity_column_option_list - : alter_identity_column_option+ - ; - -alter_identity_column_option - : KW_RESTART (opt_with? numericonly)? - | KW_SET (seqoptelem | KW_GENERATED generated_when) + : collabel (EQUAL def_arg | DOT def_elem)? ; partitionboundspec - : KW_FOR KW_VALUES KW_WITH OPEN_PAREN hash_partbound CLOSE_PAREN - | KW_FOR KW_VALUES KW_IN OPEN_PAREN expr_list CLOSE_PAREN - | KW_FOR KW_VALUES KW_FROM OPEN_PAREN expr_list CLOSE_PAREN KW_TO OPEN_PAREN expr_list CLOSE_PAREN + : KW_FOR KW_VALUES KW_WITH OPEN_PAREN nonreservedword Integral ( + COMMA (nonreservedword Integral) + )* CLOSE_PAREN + | KW_FOR KW_VALUES KW_IN execute_param_clause + | KW_FOR KW_VALUES KW_FROM execute_param_clause KW_TO execute_param_clause | KW_DEFAULT ; -hash_partbound_elem - : nonreservedword iconst - ; - -hash_partbound - : hash_partbound_elem (COMMA hash_partbound_elem)* - ; - altercompositetypestmt - : KW_ALTER KW_TYPE any_name alter_type_cmds - ; - -alter_type_cmds - : alter_type_cmd (COMMA alter_type_cmd)* + : KW_ALTER KW_TYPE any_name alter_type_cmd (COMMA alter_type_cmd)* ; alter_type_cmd : KW_ADD KW_ATTRIBUTE tablefuncelement opt_drop_behavior? | KW_DROP KW_ATTRIBUTE opt_if_exists? colid opt_drop_behavior? - | KW_ALTER KW_ATTRIBUTE colid opt_set_data? KW_TYPE typename opt_collate_clause? opt_drop_behavior? + | KW_ALTER KW_ATTRIBUTE colid (KW_SET KW_DATA)? KW_TYPE typename opt_collate_clause? opt_drop_behavior? ; closeportalstmt - : KW_CLOSE (cursor_name | KW_ALL) + : KW_CLOSE (colid | KW_ALL) ; copystmt - : KW_COPY opt_binary? table_name opt_column_list? copy_from opt_program? copy_file_name copy_delimiter? opt_with? copy_options where_clause? - | KW_COPY OPEN_PAREN preparablestmt CLOSE_PAREN KW_TO opt_program? copy_file_name opt_with? copy_options - ; - -copy_from - : KW_FROM - | KW_TO - ; - -opt_program - : KW_PROGRAM - ; - -copy_file_name - : sconst - | KW_STDIN - | KW_STDOUT + : KW_COPY KW_BINARY? table_name opt_column_list? (KW_FROM | KW_TO) KW_PROGRAM? ( + sconst + | KW_STDIN + | KW_STDOUT + ) (KW_USING? KW_DELIMITERS sconst)? KW_WITH? copy_options where_clause? + | KW_COPY OPEN_PAREN preparablestmt CLOSE_PAREN KW_TO KW_PROGRAM? ( + sconst + | KW_STDIN + | KW_STDOUT + ) KW_WITH? copy_options ; copy_options - : copy_opt_list - | OPEN_PAREN copy_generic_opt_list CLOSE_PAREN - ; - -copy_opt_list - : copy_opt_item* - ; - -copy_opt_item - : KW_BINARY - | KW_FREEZE - | KW_DELIMITER opt_as? sconst - | KW_NULL opt_as? sconst - | KW_CSV - | KW_HEADER - | KW_QUOTE opt_as? sconst - | KW_ESCAPE opt_as? sconst - | KW_FORCE KW_QUOTE column_list - | KW_FORCE KW_QUOTE STAR - | KW_FORCE KW_NOT KW_NULL column_list - | KW_FORCE KW_NULL column_list - | KW_ENCODING sconst - ; - -opt_binary - : KW_BINARY - ; - -copy_delimiter - : opt_using? KW_DELIMITERS sconst - ; - -opt_using - : KW_USING - ; - -copy_generic_opt_list - : copy_generic_opt_elem (COMMA copy_generic_opt_elem)* + : ( + KW_BINARY + | KW_FREEZE + | (KW_NULL | KW_DELIMITER | KW_ESCAPE | KW_QUOTE) KW_AS? sconst + | KW_CSV + | KW_HEADER + | KW_FORCE KW_QUOTE (column_list | STAR) + | KW_FORCE KW_NOT? KW_NULL column_list + | KW_ENCODING sconst + )* + | OPEN_PAREN copy_generic_opt_elem (COMMA copy_generic_opt_elem)* CLOSE_PAREN ; copy_generic_opt_elem - : collabel copy_generic_opt_arg? - ; - -copy_generic_opt_arg - : opt_boolean_or_string - | numericonly - | STAR - | OPEN_PAREN copy_generic_opt_arg_list CLOSE_PAREN - ; - -copy_generic_opt_arg_list - : copy_generic_opt_arg_list_item (COMMA copy_generic_opt_arg_list_item)* - ; - -copy_generic_opt_arg_list_item - : opt_boolean_or_string_column + : collabel ( + opt_boolean_or_string + | numericonly + | STAR + | OPEN_PAREN opt_boolean_or_string_column (COMMA opt_boolean_or_string_column)* CLOSE_PAREN + )? ; createstmt : KW_CREATE opttemp? KW_TABLE opt_if_not_exists? table_name_create ( - OPEN_PAREN table_column_list? CLOSE_PAREN optinherit? optpartitionspec? table_access_method_clause? optwith? oncommitoption? opttablespace? - | KW_OF any_name opttypedtableelementlist? optpartitionspec? table_access_method_clause? optwith? oncommitoption? opttablespace? - | KW_PARTITION KW_OF qualified_name opttypedtableelementlist? partitionboundspec optpartitionspec? table_access_method_clause? optwith? + OPEN_PAREN tableelementlist? CLOSE_PAREN optinherit? partitionspec? table_access_method_clause? optwith? oncommitoption? opttablespace? + | KW_OF any_name opttypedtableelementlist? partitionspec? table_access_method_clause? optwith? oncommitoption? opttablespace? + | KW_PARTITION KW_OF qualified_name opttypedtableelementlist? partitionboundspec partitionspec? table_access_method_clause? optwith? oncommitoption? opttablespace? ) # columnCreateTable ; @@ -733,87 +596,56 @@ createstmt opttemp : KW_TEMPORARY | KW_TEMP - | KW_LOCAL (KW_TEMPORARY | KW_TEMP) - | KW_GLOBAL (KW_TEMPORARY | KW_TEMP) + | (KW_LOCAL | KW_GLOBAL) (KW_TEMPORARY | KW_TEMP) | KW_UNLOGGED ; -table_column_list - : tableelementlist - ; - -opttableelementlist - : tableelementlist - ; - opttypedtableelementlist - : OPEN_PAREN typedtableelementlist CLOSE_PAREN + : OPEN_PAREN typedtableelement (COMMA typedtableelement)* CLOSE_PAREN ; tableelementlist : tableelement (COMMA tableelement)* ; -typedtableelementlist - : typedtableelement (COMMA typedtableelement)* - ; - tableelement : column_def - | tablelikeclause - | tableconstraint + | KW_LIKE qualified_name ((KW_INCLUDING | KW_EXCLUDING) tablelikeoption)* + | (KW_CONSTRAINT colid)? constraintelem ; typedtableelement - : columnOptions - | tableconstraint + : column_name_create (KW_WITH KW_OPTIONS)? colconstraint* + | (KW_CONSTRAINT colid)? constraintelem ; column_def - : column_name_create typename create_generic_options? storageCluase? compressionCluase? ( - KW_COLLATE any_name - )? (KW_WITH KW_OPTIONS)? colquallist - ; - -compressionCluase - : KW_COMPRESSION colid - ; - -storageCluase - : KW_STORAGE (KW_PLAIN | KW_EXTERNAL | KW_EXTENDED | KW_MAIN | KW_DEFAULT | colid) - ; - -columnOptions - : column_name_create (KW_WITH KW_OPTIONS)? colquallist - ; - -colquallist - : colconstraint* + : column_name_create typename create_generic_options? ( + KW_STORAGE (KW_PLAIN | KW_EXTERNAL | KW_EXTENDED | KW_MAIN | KW_DEFAULT | colid) + )? (KW_COMPRESSION colid)? (opt_collate_clause)? (KW_WITH KW_OPTIONS)? colconstraint* ; colconstraint - : (KW_CONSTRAINT name)? colconstraintelem deferrable_trigger? initially_trigger? - | colconstraintelem deferrable_trigger? initially_trigger? + : (KW_CONSTRAINT colid)? colconstraintelem (KW_NOT? KW_DEFERRABLE)? ( + KW_INITIALLY (KW_DEFERRED | KW_IMMEDIATE) + )? ; colconstraintelem - : KW_NOT KW_NULL - | KW_NULL + : KW_NOT? KW_NULL | KW_UNIQUE opt_definition? optconstablespace? - | KW_UNIQUE nulls_distinct? index_paramenters_create + | KW_UNIQUE (KW_NULLS KW_NOT? KW_DISTINCT)? ( + (KW_INCLUDE index_params)? with_clause? optconstablespace? + ) | KW_PRIMARY KW_KEY opt_definition? optconstablespace? - | KW_CHECK OPEN_PAREN a_expr CLOSE_PAREN opt_no_inherit? - | KW_DEFAULT b_expr + | KW_CHECK OPEN_PAREN expression CLOSE_PAREN (KW_NO KW_INHERIT)? + | KW_DEFAULT primaryExpression | KW_GENERATED generated_when KW_AS ( - KW_IDENTITY optparenthesizedseqoptlist? - | OPEN_PAREN a_expr CLOSE_PAREN KW_STORED + KW_IDENTITY (OPEN_PAREN seqoptelem+ CLOSE_PAREN)? + | OPEN_PAREN expression CLOSE_PAREN KW_STORED ) | KW_REFERENCES qualified_name opt_column_list? key_match? key_actions? - | opt_collate - ; - -nulls_distinct - : KW_NULLS KW_NOT? KW_DISTINCT + | opt_collate_clause ; generated_when @@ -821,23 +653,6 @@ generated_when | KW_BY KW_DEFAULT ; -deferrable_trigger - : KW_DEFERRABLE - | KW_NOT KW_DEFERRABLE - ; - -initially_trigger - : KW_INITIALLY (KW_DEFERRED | KW_IMMEDIATE) - ; - -tablelikeclause - : KW_LIKE qualified_name tablelikeoptionlist - ; - -tablelikeoptionlist - : ((KW_INCLUDING | KW_EXCLUDING) tablelikeoption)* - ; - tablelikeoption : KW_COMMENTS | KW_CONSTRAINTS @@ -850,29 +665,18 @@ tablelikeoption | KW_ALL ; -tableconstraint - : KW_CONSTRAINT name constraintelem - | constraintelem - ; - constraintelem - : KW_CHECK OPEN_PAREN a_expr CLOSE_PAREN constraintattributespec - | KW_UNIQUE ( - OPEN_PAREN column_list CLOSE_PAREN opt_c_include? opt_definition? optconstablespace? constraintattributespec - | existingindex constraintattributespec - ) - | KW_PRIMARY KW_KEY ( - OPEN_PAREN column_list CLOSE_PAREN opt_c_include? opt_definition? optconstablespace? constraintattributespec - | existingindex constraintattributespec + : KW_CHECK OPEN_PAREN expression CLOSE_PAREN constraintattributeElem* + | (KW_UNIQUE | ( KW_PRIMARY KW_KEY)) ( + opt_column_list opt_c_include? opt_definition? optconstablespace? constraintattributeElem* + | existingindex constraintattributeElem* ) - | KW_EXCLUDE access_method_clause? OPEN_PAREN exclusionconstraintlist CLOSE_PAREN opt_c_include? opt_definition? optconstablespace? - exclusionwhereclause? constraintattributespec - | KW_FOREIGN KW_KEY OPEN_PAREN column_list CLOSE_PAREN KW_REFERENCES qualified_name opt_column_list? key_match? key_actions? - constraintattributespec - ; - -opt_no_inherit - : KW_NO KW_INHERIT + | KW_EXCLUDE table_access_method_clause? OPEN_PAREN exclusionconstraintelem ( + COMMA exclusionconstraintelem + )* CLOSE_PAREN opt_c_include? opt_definition? optconstablespace? ( + KW_WHERE OPEN_PAREN expression CLOSE_PAREN + )? constraintattributeElem* + | KW_FOREIGN KW_KEY opt_column_list KW_REFERENCES qualified_name opt_column_list? key_match? key_actions? constraintattributeElem* ; opt_column_list @@ -880,42 +684,28 @@ opt_column_list ; opt_column_list_create - : OPEN_PAREN column_list_create CLOSE_PAREN + : OPEN_PAREN column_name_create (COMMA column_name_create)* CLOSE_PAREN ; column_list : column_name (COMMA column_name)* ; -column_list_create - : column_name_create (COMMA column_name_create)* - ; - opt_c_include - : KW_INCLUDE OPEN_PAREN column_list CLOSE_PAREN + : KW_INCLUDE opt_column_list ; key_match : KW_MATCH (KW_FULL | KW_PARTIAL | KW_SIMPLE) ; -exclusionconstraintlist - : exclusionconstraintelem (COMMA exclusionconstraintelem)* - ; - exclusionconstraintelem : index_elem KW_WITH (any_operator | KW_OPERATOR OPEN_PAREN any_operator CLOSE_PAREN) ; -exclusionwhereclause - : KW_WHERE OPEN_PAREN a_expr CLOSE_PAREN - ; - key_actions - : key_update - | key_delete - | key_update key_delete - | key_delete key_update + : key_update key_delete? + | key_delete key_update? ; key_update @@ -937,32 +727,21 @@ optinherit : KW_INHERITS OPEN_PAREN qualified_name_list CLOSE_PAREN ; -optpartitionspec - : partitionspec - ; - partitionspec - : KW_PARTITION KW_BY colid OPEN_PAREN part_params CLOSE_PAREN - ; - -part_params - : part_elem (COMMA part_elem)* + : KW_PARTITION KW_BY colid OPEN_PAREN part_elem (COMMA part_elem)* CLOSE_PAREN ; part_elem - : column_name opt_collate? opt_class? - | func_expr_windowless opt_collate? opt_class? - | OPEN_PAREN a_expr CLOSE_PAREN opt_collate? opt_class? + : (column_name | func_expr_windowless | (OPEN_PAREN expression CLOSE_PAREN)) opt_collate_clause? any_name? ; table_access_method_clause - : KW_USING name + : KW_USING colid ; optwith : KW_WITH reloptions - | KW_WITHOUT KW_OIDS - | KW_WITH KW_OIDS + | (KW_WITHOUT | KW_WITH) KW_OIDS ; oncommitoption @@ -973,23 +752,19 @@ opttablespace : KW_TABLESPACE tablespace_name ; -index_paramenters_create - : opt_include? with_clause? optconstablespace? - ; - optconstablespace - : KW_USING KW_INDEX KW_TABLESPACE tablespace_name + : KW_USING KW_INDEX opttablespace ; existingindex - : KW_USING KW_INDEX name + : KW_USING KW_INDEX colid ; createstatsstmt - : KW_CREATE KW_STATISTICS (opt_if_not_exists? any_name)? opt_name_list? KW_ON ( - column_expr_list + : KW_CREATE KW_STATISTICS (opt_if_not_exists? any_name)? opt_column_list? KW_ON ( + column_expr (COMMA column_expr)* | expr_list - ) KW_FROM from_list + ) from_clause ; alterstatsstmt @@ -1009,342 +784,193 @@ opt_with_data ; creatematviewstmt - : KW_CREATE optnolog? KW_MATERIALIZED KW_VIEW opt_if_not_exists? create_mv_target KW_AS selectstmt opt_with_data? # createMaterializedView - ; - -create_mv_target - : view_name_create opt_column_list_create? table_access_method_clause? opt_reloptions? opttablespace? - ; - -optnolog - : KW_UNLOGGED + : KW_CREATE KW_UNLOGGED? KW_MATERIALIZED KW_VIEW opt_if_not_exists? view_name_create opt_column_list_create? table_access_method_clause? + opt_reloptions? opttablespace? KW_AS selectstmt opt_with_data? # createMaterializedView ; refreshmatviewstmt - : KW_REFRESH KW_MATERIALIZED KW_VIEW opt_concurrently? view_name opt_with_data? + : KW_REFRESH KW_MATERIALIZED KW_VIEW KW_CONCURRENTLY? view_name opt_with_data? ; createseqstmt - : KW_CREATE opttemp? KW_SEQUENCE opt_if_not_exists? qualified_name optseqoptlist? + : KW_CREATE opttemp? KW_SEQUENCE opt_if_not_exists? qualified_name (seqoptelem+)? ; alterseqstmt - : KW_ALTER KW_SEQUENCE opt_if_exists? qualified_name seqoptlist - ; - -optseqoptlist - : seqoptlist - ; - -optparenthesizedseqoptlist - : OPEN_PAREN seqoptlist CLOSE_PAREN - ; - -seqoptlist - : seqoptelem+ + : KW_ALTER KW_SEQUENCE opt_if_exists? qualified_name seqoptelem+ ; seqoptelem : KW_AS simpletypename - | KW_CACHE numericonly - | KW_CYCLE - | KW_INCREMENT opt_by? numericonly - | KW_MAXVALUE numericonly - | KW_MINVALUE numericonly + | KW_CACHE numericonly? + | KW_INCREMENT KW_BY? numericonly + | (KW_MAXVALUE | KW_MINVALUE) numericonly | KW_NO (KW_MAXVALUE | KW_MINVALUE | KW_CYCLE) | KW_OWNED KW_BY column_name | KW_SEQUENCE KW_NAME any_name - | KW_START opt_with? numericonly - | KW_RESTART opt_with? numericonly? - ; - -opt_by - : KW_BY + | KW_START KW_WITH? numericonly + | KW_RESTART KW_WITH? numericonly? ; numericonly - : fconst - | PLUS fconst - | MINUS fconst + : (PLUS | MINUS)? Numeric | signediconst ; -numericonly_list - : numericonly (COMMA numericonly)* - ; - createplangstmt - : KW_CREATE opt_or_replace? opt_trusted? opt_procedural? KW_LANGUAGE name ( - KW_HANDLER handler_name opt_inline_handler? opt_validator? + : KW_CREATE opt_or_replace? KW_TRUSTED? KW_PROCEDURAL? KW_LANGUAGE colid ( + KW_HANDLER any_name (KW_INLINE any_name)? (KW_VALIDATOR any_name | KW_NO KW_VALIDATOR)? )? ; -opt_trusted - : KW_TRUSTED - ; - -handler_name - : name attrs? - ; - -opt_inline_handler - : KW_INLINE handler_name - ; - -validator_clause - : KW_VALIDATOR handler_name - | KW_NO KW_VALIDATOR - ; - -opt_validator - : validator_clause - ; - -opt_procedural - : KW_PROCEDURAL - ; - createtablespacestmt - : KW_CREATE KW_TABLESPACE tablespace_name opttablespaceowner? KW_LOCATION sconst opt_reloptions? - ; - -opttablespaceowner - : KW_OWNER rolespec + : KW_CREATE opttablespace (KW_OWNER rolespec)? KW_LOCATION sconst opt_reloptions? ; createextensionstmt - : KW_CREATE KW_EXTENSION opt_if_not_exists? name opt_with? create_extension_opt_list - ; - -create_extension_opt_list - : create_extension_opt_item* - ; - -create_extension_opt_item - : KW_SCHEMA schema_name - | KW_VERSION nonreservedword_or_sconst - | KW_FROM nonreservedword_or_sconst - | KW_CASCADE + : KW_CREATE KW_EXTENSION opt_if_not_exists? colid KW_WITH? ( + KW_SCHEMA schema_name + | (KW_VERSION | KW_FROM) nonreservedword_or_sconst + | KW_CASCADE + )* ; alterextensionstmt - : KW_ALTER KW_EXTENSION name KW_UPDATE alter_extension_opt_list - ; - -alter_extension_opt_list - : alter_extension_opt_item* - ; - -alter_extension_opt_item - : KW_TO nonreservedword_or_sconst + : KW_ALTER KW_EXTENSION colid KW_UPDATE (KW_TO nonreservedword_or_sconst)* ; alterextensioncontentsstmt - : KW_ALTER KW_EXTENSION name add_drop object_type_name - | KW_ALTER KW_EXTENSION name add_drop object_type_any_name - | KW_ALTER KW_EXTENSION name add_drop KW_AGGREGATE aggregate_with_argtypes - | KW_ALTER KW_EXTENSION name add_drop KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN - | KW_ALTER KW_EXTENSION name add_drop KW_DOMAIN typename - | KW_ALTER KW_EXTENSION name add_drop KW_FUNCTION function_with_argtypes - | KW_ALTER KW_EXTENSION name add_drop KW_OPERATOR operator_with_argtypes - | KW_ALTER KW_EXTENSION name add_drop KW_OPERATOR KW_CLASS any_name KW_USING name - | KW_ALTER KW_EXTENSION name add_drop KW_OPERATOR KW_FAMILY any_name KW_USING name - | KW_ALTER KW_EXTENSION name add_drop KW_PROCEDURE procedure_with_argtypes - | KW_ALTER KW_EXTENSION name add_drop KW_ROUTINE routine_with_argtypes - | KW_ALTER KW_EXTENSION name add_drop KW_TRANSFORM KW_FOR typename KW_LANGUAGE name - | KW_ALTER KW_EXTENSION name add_drop KW_TYPE typename + : KW_ALTER KW_EXTENSION colid (KW_ADD | KW_DROP) ( + KW_TRANSFORM KW_FOR typename KW_LANGUAGE colid + | KW_ROUTINE routine_with_argtypes + | KW_PROCEDURE procedure_with_argtypes + | KW_OPERATOR (KW_CLASS | KW_FAMILY) any_name table_access_method_clause + | KW_OPERATOR operator_with_argtypes + | KW_FUNCTION function_with_argtypes + | (KW_DOMAIN | KW_TYPE) typename + | KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN + | KW_AGGREGATE aggregate_with_argtypes + | object_type_name + | object_type_any_name + ) ; createfdwstmt - : KW_CREATE KW_FOREIGN KW_DATA KW_WRAPPER name opt_fdw_options? create_generic_options? + : KW_CREATE KW_FOREIGN KW_DATA KW_WRAPPER colid (fdw_option+)? create_generic_options? ; fdw_option - : KW_HANDLER handler_name - | KW_NO KW_HANDLER - | KW_VALIDATOR handler_name - | KW_NO KW_VALIDATOR - ; - -fdw_options - : fdw_option+ - ; - -opt_fdw_options - : fdw_options + : (KW_HANDLER | KW_VALIDATOR) any_name? + | KW_NO (KW_HANDLER | KW_VALIDATOR) ; alterfdwstmt - : KW_ALTER KW_FOREIGN KW_DATA KW_WRAPPER name opt_fdw_options? alter_generic_options - | KW_ALTER KW_FOREIGN KW_DATA KW_WRAPPER name fdw_options + : KW_ALTER KW_FOREIGN KW_DATA KW_WRAPPER colid ( + (fdw_option+)? alter_generic_options + | fdw_option+ + ) ; create_generic_options - : KW_OPTIONS OPEN_PAREN generic_option_list CLOSE_PAREN - ; - -generic_option_list - : generic_option_elem (COMMA generic_option_elem)* + : KW_OPTIONS OPEN_PAREN generic_option_elem (COMMA generic_option_elem)* CLOSE_PAREN ; alter_generic_options - : KW_OPTIONS OPEN_PAREN alter_generic_option_list CLOSE_PAREN - ; - -alter_generic_option_list - : alter_generic_option_elem (COMMA alter_generic_option_elem)* + : KW_OPTIONS OPEN_PAREN alter_generic_option_elem (COMMA alter_generic_option_elem)* CLOSE_PAREN ; alter_generic_option_elem - : generic_option_elem - | KW_SET generic_option_elem - | KW_ADD generic_option_elem - | KW_DROP generic_option_elem + : (KW_SET | KW_ADD | KW_DROP) generic_option_elem ; generic_option_elem - : generic_option_name generic_option_arg - ; - -generic_option_name - : collabel - ; - -generic_option_arg - : sconst + : collabel sconst ; createforeignserverstmt - : KW_CREATE KW_SERVER opt_if_not_exists? name opt_type? opt_foreign_server_version? KW_FOREIGN KW_DATA KW_WRAPPER name create_generic_options? - ; - -opt_type - : KW_TYPE sconst + : KW_CREATE KW_SERVER opt_if_not_exists? colid (KW_TYPE sconst)? foreign_server_version? KW_FOREIGN KW_DATA KW_WRAPPER colid + create_generic_options? ; foreign_server_version : KW_VERSION (sconst | KW_NULL) ; -opt_foreign_server_version - : foreign_server_version - ; - alterforeignserverstmt - : KW_ALTER KW_SERVER name ( + : KW_ALTER KW_SERVER colid ( alter_generic_options | foreign_server_version alter_generic_options? ) ; createforeigntablestmt - : KW_CREATE KW_FOREIGN KW_TABLE opt_if_not_exists? table_name_create OPEN_PAREN opttableelementlist? CLOSE_PAREN optinherit? KW_SERVER name + : KW_CREATE KW_FOREIGN KW_TABLE opt_if_not_exists? table_name_create OPEN_PAREN tableelementlist? CLOSE_PAREN optinherit? KW_SERVER colid create_generic_options? # createForeignTable | KW_CREATE KW_FOREIGN KW_TABLE opt_if_not_exists? table_name_create KW_PARTITION KW_OF table_name opttypedtableelementlist? partitionboundspec - KW_SERVER name create_generic_options? # createPartitionForeignTable + KW_SERVER colid create_generic_options? # createPartitionForeignTable ; importforeignschemastmt - : KW_IMPORT KW_FOREIGN KW_SCHEMA schema_name import_qualification? KW_FROM KW_SERVER name KW_INTO name create_generic_options? - ; - -import_qualification_type - : KW_LIMIT KW_TO - | KW_EXCEPT - ; - -import_qualification - : import_qualification_type OPEN_PAREN relation_expr_list CLOSE_PAREN + : KW_IMPORT KW_FOREIGN KW_SCHEMA schema_name ( + (KW_LIMIT KW_TO | KW_EXCEPT) OPEN_PAREN relation_expr_list CLOSE_PAREN + )? KW_FROM KW_SERVER colid KW_INTO colid create_generic_options? ; createusermappingstmt - : KW_CREATE KW_USER KW_MAPPING opt_if_not_exists? KW_FOR auth_ident KW_SERVER name create_generic_options? - ; - -auth_ident - : rolespec - | KW_USER + : KW_CREATE KW_USER KW_MAPPING opt_if_not_exists? KW_FOR (rolespec | KW_USER) KW_SERVER colid create_generic_options? ; alterusermappingstmt - : KW_ALTER KW_USER KW_MAPPING KW_FOR auth_ident KW_SERVER name alter_generic_options + : KW_ALTER KW_USER KW_MAPPING KW_FOR (rolespec | KW_USER) KW_SERVER colid alter_generic_options ; createpolicystmt - : KW_CREATE KW_POLICY name KW_ON qualified_name rowsecuritydefaultpermissive? rowsecuritydefaultforcmd? rowsecuritydefaulttorole? - rowsecurityoptionalexpr? rowsecurityoptionalwithcheck? + : KW_CREATE KW_POLICY colid KW_ON qualified_name ( + KW_AS (KW_PERMISSIVE | KW_RESTRICTIVE | identifier) + )? (KW_FOR (KW_ALL | KW_SELECT | KW_INSERT | KW_UPDATE | KW_DELETE))? (KW_TO role_list)? rowsecurityoptionalexpr? rowsecurityoptionalwithcheck? ; alterpolicystmt - : KW_ALTER KW_POLICY name KW_ON qualified_name rowsecurityoptionaltorole? rowsecurityoptionalexpr? rowsecurityoptionalwithcheck? + : KW_ALTER KW_POLICY colid KW_ON qualified_name (KW_TO role_list)? rowsecurityoptionalexpr? rowsecurityoptionalwithcheck? ; alterprocedurestmt - : KW_ALTER KW_PROCEDURE procedure_name func_args? procedure_cluase - ; - -procedure_cluase - : procedure_action (procedure_action)* KW_RESTRICT? - | KW_RENAME KW_TO procedure_name_create - | KW_OWNER KW_TO rolespec - | KW_SET KW_SCHEMA schema_name_create - | KW_NO? KW_DEPENDS KW_ON KW_EXTENSION name + : KW_ALTER KW_PROCEDURE procedure_name func_args? ( + procedure_action (procedure_action)* KW_RESTRICT? + | KW_RENAME KW_TO procedure_name_create + | KW_OWNER KW_TO rolespec + | KW_SET KW_SCHEMA schema_name_create + | KW_NO? KW_DEPENDS KW_ON KW_EXTENSION colid + ) ; procedure_action : (KW_EXTERNAL? KW_SECURITY KW_INVOKER | KW_EXTERNAL? KW_SECURITY KW_DEFINER) - | KW_SET name (KW_TO | STAR) (name | KW_DEFAULT) - | KW_SET name KW_FROM KW_CURRENT - | KW_RESET name - | KW_RESET KW_ALL + | KW_SET colid (KW_TO | STAR) (colid | KW_DEFAULT) + | KW_SET colid KW_FROM KW_CURRENT + | KW_RESET (colid | KW_ALL) ; rowsecurityoptionalexpr - : KW_USING OPEN_PAREN a_expr CLOSE_PAREN + : KW_USING OPEN_PAREN expression CLOSE_PAREN ; rowsecurityoptionalwithcheck - : KW_WITH KW_CHECK OPEN_PAREN a_expr CLOSE_PAREN - ; - -rowsecuritydefaulttorole - : KW_TO role_list - ; - -rowsecurityoptionaltorole - : KW_TO role_list - ; - -rowsecuritydefaultpermissive - : KW_AS (KW_PERMISSIVE | KW_RESTRICTIVE | identifier) - ; - -rowsecuritydefaultforcmd - : KW_FOR row_security_cmd - ; - -row_security_cmd - : KW_ALL - | KW_SELECT - | KW_INSERT - | KW_UPDATE - | KW_DELETE + : KW_WITH KW_CHECK OPEN_PAREN expression CLOSE_PAREN ; createamstmt - : KW_CREATE KW_ACCESS KW_METHOD name KW_TYPE am_type KW_HANDLER handler_name - ; - -am_type - : KW_INDEX - | KW_TABLE + : KW_CREATE KW_ACCESS KW_METHOD colid KW_TYPE (KW_INDEX | KW_TABLE) KW_HANDLER any_name ; createtrigstmt - : KW_CREATE opt_or_replace? KW_TRIGGER name triggeractiontime triggerevents KW_ON table_name triggerreferencing? triggerforspec? triggerwhen? - KW_EXECUTE function_or_procedure OPEN_PAREN triggerfuncargs CLOSE_PAREN - | KW_CREATE opt_or_replace? KW_CONSTRAINT? KW_TRIGGER name triggeractiontime triggerevents KW_ON table_name optconstrfromtable? - constraintattributespec foreachrow? triggerwhen? KW_EXECUTE function_or_procedure OPEN_PAREN triggerfuncargs CLOSE_PAREN + : KW_CREATE opt_or_replace? KW_TRIGGER colid triggeractiontime triggerevents KW_ON table_name ( + KW_REFERENCING ((KW_NEW | KW_OLD) (KW_TABLE | KW_ROW) KW_AS? colid)+ + )? (KW_FOR KW_EACH? (KW_ROW | KW_STATEMENT))? triggerwhen? KW_EXECUTE function_or_procedure OPEN_PAREN triggerfuncargs CLOSE_PAREN + | KW_CREATE opt_or_replace? KW_CONSTRAINT? KW_TRIGGER colid triggeractiontime triggerevents KW_ON table_name ( + KW_FROM qualified_name + )? constraintattributeElem* (KW_FOR KW_EACH? (KW_ROW | KW_STATEMENT))? triggerwhen? KW_EXECUTE function_or_procedure OPEN_PAREN triggerfuncargs + CLOSE_PAREN ; triggeractiontime @@ -1353,15 +979,6 @@ triggeractiontime | KW_INSTEAD KW_OF ; -foreachrow - : KW_FOR KW_EACH? roworstatment - ; - -roworstatment - : KW_ROW - | KW_STATEMENT - ; - triggerevents : triggeroneevent (KW_OR triggeroneevent)* ; @@ -1369,140 +986,72 @@ triggerevents triggeroneevent : KW_INSERT | KW_DELETE - | KW_UPDATE - | KW_UPDATE KW_OF column_list + | KW_UPDATE (KW_OF column_list)? | KW_TRUNCATE ; -triggerreferencing - : KW_REFERENCING triggertransitions +triggerwhen + : KW_WHEN OPEN_PAREN expression CLOSE_PAREN ; -triggertransitions - : triggertransition+ +function_or_procedure + : KW_FUNCTION function_name + | KW_PROCEDURE procedure_name ; -triggertransition - : transitionoldornew transitionrowortable opt_as? transitionrelname +triggerfuncargs + : (triggerfuncarg |) (COMMA triggerfuncarg)* ; -transitionoldornew - : KW_NEW - | KW_OLD +triggerfuncarg + : Integral + | Numeric + | sconst + | collabel ; -transitionrowortable - : KW_TABLE - | KW_ROW +constraintattributeElem + : KW_NOT? KW_DEFERRABLE + | KW_INITIALLY (KW_IMMEDIATE | KW_DEFERRED) + | KW_NOT KW_VALID + | KW_NO KW_INHERIT ; -transitionrelname - : colid - ; - -triggerforspec - : KW_FOR triggerforopteach? triggerfortype - ; - -triggerforopteach - : KW_EACH - ; - -triggerfortype - : KW_ROW - | KW_STATEMENT - ; - -triggerwhen - : KW_WHEN OPEN_PAREN a_expr CLOSE_PAREN - ; - -function_or_procedure - : KW_FUNCTION function_name - | KW_PROCEDURE procedure_name - ; - -triggerfuncargs - : (triggerfuncarg |) (COMMA triggerfuncarg)* - ; - -triggerfuncarg - : iconst - | fconst - | sconst - | collabel - ; - -optconstrfromtable - : KW_FROM qualified_name - ; - -constraintattributespec - : constraintattributeElem* - ; - -constraintattributeElem - : KW_NOT KW_DEFERRABLE - | KW_DEFERRABLE - | KW_INITIALLY KW_IMMEDIATE - | KW_INITIALLY KW_DEFERRED - | KW_NOT KW_VALID - | KW_NO KW_INHERIT - ; - -createeventtrigstmt - : KW_CREATE KW_EVENT KW_TRIGGER name KW_ON collabel KW_EXECUTE function_or_procedure OPEN_PAREN CLOSE_PAREN - | KW_CREATE KW_EVENT KW_TRIGGER name KW_ON collabel KW_WHEN event_trigger_when_list KW_EXECUTE function_or_procedure OPEN_PAREN CLOSE_PAREN - ; - -event_trigger_when_list - : event_trigger_when_item (KW_AND event_trigger_when_item)* +createeventtrigstmt + : KW_CREATE KW_EVENT KW_TRIGGER colid KW_ON collabel ( + KW_WHEN event_trigger_when_item (KW_AND event_trigger_when_item)* + )? KW_EXECUTE function_or_procedure OPEN_PAREN CLOSE_PAREN ; event_trigger_when_item - : colid KW_IN OPEN_PAREN event_trigger_value_list CLOSE_PAREN - ; - -event_trigger_value_list - : sconst (COMMA sconst)* + : colid KW_IN OPEN_PAREN sconst (notify_payload)* CLOSE_PAREN ; altereventtrigstmt - : KW_ALTER KW_EVENT KW_TRIGGER name enable_trigger - ; - -enable_trigger - : KW_ENABLE (KW_REPLICA | KW_ALWAYS)? - | KW_DISABLE + : KW_ALTER KW_EVENT KW_TRIGGER colid (KW_ENABLE (KW_REPLICA | KW_ALWAYS)? | KW_DISABLE) ; createassertionstmt - : KW_CREATE KW_ASSERTION any_name KW_CHECK OPEN_PAREN a_expr CLOSE_PAREN constraintattributespec + : KW_CREATE KW_ASSERTION any_name KW_CHECK OPEN_PAREN expression CLOSE_PAREN constraintattributeElem* ; definestmt - : KW_CREATE opt_or_replace? KW_AGGREGATE function_name aggr_args definition - | KW_CREATE opt_or_replace? KW_AGGREGATE function_name old_aggr_definition + : KW_CREATE opt_or_replace? KW_AGGREGATE function_name ( + (aggr_args definition) + | OPEN_PAREN old_aggr_elem (COMMA old_aggr_elem)* CLOSE_PAREN + ) | KW_CREATE KW_OPERATOR any_operator definition - | KW_CREATE KW_TYPE any_name definition - | KW_CREATE KW_TYPE any_name - | KW_CREATE KW_TYPE any_name KW_AS OPEN_PAREN opttablefuncelementlist? CLOSE_PAREN - | KW_CREATE KW_TYPE any_name KW_AS KW_ENUM OPEN_PAREN opt_enum_val_list? CLOSE_PAREN - | KW_CREATE KW_TYPE any_name KW_AS KW_RANGE definition - | KW_CREATE KW_TEXT KW_SEARCH KW_PARSER any_name definition - | KW_CREATE KW_TEXT KW_SEARCH KW_DICTIONARY any_name definition - | KW_CREATE KW_TEXT KW_SEARCH KW_TEMPLATE any_name definition - | KW_CREATE KW_TEXT KW_SEARCH KW_CONFIGURATION any_name definition - | KW_CREATE KW_COLLATION opt_if_not_exists? any_name definition - | KW_CREATE KW_COLLATION opt_if_not_exists? any_name KW_FROM any_name + | KW_CREATE KW_TYPE any_name KW_AS ( + OPEN_PAREN tablefuncelementlist? CLOSE_PAREN + | KW_ENUM OPEN_PAREN (sconst (notify_payload)*)? CLOSE_PAREN + ) + | KW_CREATE KW_TYPE any_name ((KW_AS KW_RANGE)? definition)? + | KW_CREATE KW_TEXT KW_SEARCH (KW_PARSER | KW_DICTIONARY | KW_TEMPLATE | KW_CONFIGURATION) any_name definition + | KW_CREATE KW_COLLATION opt_if_not_exists? any_name (definition | (KW_FROM any_name)) ; definition - : OPEN_PAREN def_list CLOSE_PAREN - ; - -def_list - : def_elem (COMMA def_elem)* + : OPEN_PAREN def_elem (COMMA def_elem)* CLOSE_PAREN ; def_elem @@ -1518,26 +1067,10 @@ def_arg | KW_NONE ; -old_aggr_definition - : OPEN_PAREN old_aggr_list CLOSE_PAREN - ; - -old_aggr_list - : old_aggr_elem (COMMA old_aggr_elem)* - ; - old_aggr_elem : identifier EQUAL def_arg ; -opt_enum_val_list - : enum_val_list - ; - -enum_val_list - : sconst (COMMA sconst)* - ; - alterenumstmt : KW_ALTER KW_TYPE any_name KW_ADD KW_VALUE opt_if_not_exists? sconst ( (KW_BEFORE | KW_AFTER) sconst @@ -1550,54 +1083,32 @@ opt_if_not_exists ; createopclassstmt - : KW_CREATE KW_OPERATOR KW_CLASS any_name opt_default? KW_FOR KW_TYPE typename KW_USING name opt_opfamily? KW_AS opclass_item_list - ; - -opclass_item_list - : opclass_item (COMMA opclass_item)* + : KW_CREATE KW_OPERATOR KW_CLASS any_name KW_DEFAULT? KW_FOR KW_TYPE typename table_access_method_clause ( + KW_FAMILY any_name + )? KW_AS opclass_item (COMMA opclass_item)* ; opclass_item - : KW_OPERATOR iconst any_operator opclass_purpose? opt_recheck? - | KW_OPERATOR iconst operator_with_argtypes opclass_purpose? opt_recheck? - | KW_FUNCTION iconst function_with_argtypes - | KW_FUNCTION iconst OPEN_PAREN type_list CLOSE_PAREN function_with_argtypes + : KW_OPERATOR Integral any_operator oper_argtypes? ( + KW_FOR (KW_SEARCH | (KW_ORDER KW_BY any_name)) + )? KW_RECHECK? + | KW_FUNCTION Integral prep_type_clause? function_with_argtypes | KW_STORAGE typename ; -opt_default - : KW_DEFAULT - ; - -opt_opfamily - : KW_FAMILY any_name - ; - -opclass_purpose - : KW_FOR KW_SEARCH - | KW_FOR KW_ORDER KW_BY any_name - ; - -opt_recheck - : KW_RECHECK - ; - createopfamilystmt - : KW_CREATE KW_OPERATOR KW_FAMILY any_name KW_USING name + : KW_CREATE KW_OPERATOR KW_FAMILY any_name table_access_method_clause ; alteropfamilystmt - : KW_ALTER KW_OPERATOR KW_FAMILY any_name KW_USING name KW_ADD opclass_item_list - | KW_ALTER KW_OPERATOR KW_FAMILY any_name KW_USING name KW_DROP opclass_drop_list - ; - -opclass_drop_list - : opclass_drop (COMMA opclass_drop)* + : KW_ALTER KW_OPERATOR KW_FAMILY any_name table_access_method_clause ( + KW_ADD opclass_item (COMMA opclass_item)* + | KW_DROP opclass_drop (COMMA opclass_drop)* + ) ; opclass_drop - : KW_OPERATOR iconst OPEN_PAREN type_list CLOSE_PAREN - | KW_FUNCTION iconst OPEN_PAREN type_list CLOSE_PAREN + : (KW_OPERATOR | KW_FUNCTION) Integral prep_type_clause ; reassignownedstmt @@ -1605,106 +1116,74 @@ reassignownedstmt ; dropstmt - : KW_DROP KW_TABLE opt_if_exists? table_name_list opt_drop_behavior? - | KW_DROP KW_SEQUENCE opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_VIEW opt_if_exists? view_nameList opt_drop_behavior? - | KW_DROP KW_MATERIALIZED KW_VIEW opt_if_exists? view_nameList opt_drop_behavior? - | KW_DROP KW_INDEX opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_FOREIGN KW_TABLE opt_if_exists? table_name_list opt_drop_behavior? - | KW_DROP KW_COLLATION opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_CONVERSION opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_STATISTICS opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_TEXT KW_SEARCH KW_PARSER opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_TEXT KW_SEARCH KW_DICTIONARY opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_TEXT KW_SEARCH KW_TEMPLATE opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_TEXT KW_SEARCH KW_CONFIGURATION opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_ACCESS KW_METHOD opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_EVENT KW_TRIGGER opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_EXTENSION opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_FOREIGN KW_DATA KW_WRAPPER opt_if_exists? name_list opt_drop_behavior? - | KW_DROP opt_procedural? KW_LANGUAGE opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_PUBLICATION opt_if_exists? name_list opt_drop_behavior? - | KW_DROP KW_SERVER opt_if_exists? name_list opt_drop_behavior? + : KW_DROP ( + KW_SEQUENCE + | KW_INDEX + | KW_COLLATION + | KW_CONVERSION + | KW_STATISTICS + | KW_PUBLICATION + | KW_SERVER + | KW_ACCESS KW_METHOD + | KW_EVENT KW_TRIGGER + | KW_EXTENSION + | KW_PROCEDURAL? KW_LANGUAGE + | KW_FOREIGN KW_DATA KW_WRAPPER + | KW_TEXT KW_SEARCH (KW_PARSER | KW_DICTIONARY | KW_TEMPLATE | KW_CONFIGURATION) + ) opt_if_exists? name_list opt_drop_behavior? + | KW_DROP KW_MATERIALIZED? KW_VIEW opt_if_exists? view_name (COMMA view_name)* opt_drop_behavior? + | KW_DROP KW_FOREIGN? KW_TABLE opt_if_exists? table_name_list opt_drop_behavior? | KW_DROP KW_SCHEMA opt_if_exists? schema_name_list opt_drop_behavior? - | KW_DROP KW_POLICY opt_if_exists? name KW_ON any_name opt_drop_behavior? - | KW_DROP KW_RULE opt_if_exists? name KW_ON any_name opt_drop_behavior? - | KW_DROP KW_TRIGGER opt_if_exists? name KW_ON any_name opt_drop_behavior? - | KW_DROP KW_TYPE opt_if_exists? type_name_list opt_drop_behavior? - | KW_DROP KW_DOMAIN opt_if_exists? type_name_list opt_drop_behavior? + | KW_DROP (KW_POLICY | KW_RULE | KW_TRIGGER) opt_if_exists? colid KW_ON any_name opt_drop_behavior? + | KW_DROP (KW_TYPE | KW_DOMAIN) opt_if_exists? typename (COMMA typename)* opt_drop_behavior? | KW_DROP KW_INDEX KW_CONCURRENTLY opt_if_exists? any_name_list opt_drop_behavior? | KW_DROP KW_CAST opt_if_exists? OPEN_PAREN typename KW_AS typename CLOSE_PAREN opt_drop_behavior? - | KW_DROP KW_OPERATOR KW_CLASS opt_if_exists? any_name KW_USING name opt_drop_behavior? - | KW_DROP KW_OPERATOR KW_FAMILY opt_if_exists? any_name KW_USING name opt_drop_behavior? + | KW_DROP KW_OPERATOR (KW_CLASS | KW_FAMILY) opt_if_exists? any_name table_access_method_clause opt_drop_behavior? | KW_DROP KW_OWNED KW_BY role_list opt_drop_behavior? - | KW_DROP KW_VIEW opt_if_exists? view_nameList opt_drop_behavior? - | KW_DROP KW_SUBSCRIPTION opt_if_exists? name opt_drop_behavior? + | KW_DROP KW_SUBSCRIPTION opt_if_exists? colid opt_drop_behavior? | KW_DROP KW_TABLESPACE opt_if_exists? tablespace_name - | KW_DROP KW_TRANSFORM opt_if_exists? KW_FOR typename KW_LANGUAGE name opt_drop_behavior? + | KW_DROP KW_TRANSFORM opt_if_exists? KW_FOR typename KW_LANGUAGE colid opt_drop_behavior? | KW_DROP (KW_ROLE | KW_USER | KW_GROUP) opt_if_exists? role_list - | KW_DROP KW_USER KW_MAPPING opt_if_exists? KW_FOR auth_ident KW_SERVER name + | KW_DROP KW_USER KW_MAPPING opt_if_exists? KW_FOR (rolespec | KW_USER) KW_SERVER colid | KW_DROP KW_DATABASE opt_if_exists? database_name ( - opt_with? OPEN_PAREN drop_option_list CLOSE_PAREN + KW_WITH? (OPEN_PAREN KW_FORCE (COMMA KW_FORCE)* CLOSE_PAREN) )? ; -view_nameList - : view_name (COMMA view_name)* - ; - object_type_any_name : KW_FOREIGN? KW_TABLE table_name | KW_MATERIALIZED? KW_VIEW view_name - | KW_INDEX any_name - | KW_COLLATION any_name - | KW_CONVERSION any_name - | KW_STATISTICS any_name - | KW_SEQUENCE any_name + | (KW_INDEX | KW_COLLATION | KW_CONVERSION | KW_STATISTICS | KW_SEQUENCE) any_name | KW_TEXT KW_SEARCH (KW_PARSER | KW_DICTIONARY | KW_TEMPLATE | KW_CONFIGURATION) any_name ; object_type_name - : (KW_ACCESS KW_METHOD name) - | (KW_EVENT KW_TRIGGER name) - | (KW_EXTENSION name) - | (KW_FOREIGN KW_DATA KW_WRAPPER name) - | (opt_procedural? KW_LANGUAGE name) - | (KW_PUBLICATION name) - | (KW_SCHEMA schema_name) - | (KW_SERVER name) - | (KW_DATABASE database_name) - | (KW_ROLE name) - | (KW_SUBSCRIPTION name) - | (KW_TABLESPACE tablespace_name) - ; - -object_type_name_on_any_name - : KW_POLICY - | KW_RULE - | KW_TRIGGER + : ( + KW_EVENT KW_TRIGGER + | KW_ACCESS KW_METHOD + | KW_EXTENSION + | KW_PUBLICATION + | KW_SERVER + | KW_ROLE + | KW_SUBSCRIPTION + | KW_FOREIGN KW_DATA KW_WRAPPER + | KW_PROCEDURAL? KW_LANGUAGE + ) colid + | KW_SCHEMA schema_name + | KW_DATABASE database_name + | opttablespace ; any_name_list : any_name (COMMA any_name)* ; -relation_column_name - : relation_name DOT column_name - ; - -relation_name - : colid attrs? - ; - any_name : colid attrs? ; attrs - : (DOT attr_name)+ - ; - -type_name_list - : typename (COMMA typename)* + : (DOT collabel)+ ; truncatestmt @@ -1718,77 +1197,49 @@ truncate_table ; commentstmt - : KW_COMMENT KW_ON object_type_any_name KW_IS comment_text - | KW_COMMENT KW_ON KW_COLUMN relation_column_name KW_IS comment_text - | KW_COMMENT KW_ON object_type_name KW_IS comment_text - | KW_COMMENT KW_ON KW_TYPE typename KW_IS comment_text - | KW_COMMENT KW_ON KW_DOMAIN typename KW_IS comment_text - | KW_COMMENT KW_ON KW_AGGREGATE aggregate_with_argtypes KW_IS comment_text - | KW_COMMENT KW_ON KW_FUNCTION function_with_argtypes KW_IS comment_text - | KW_COMMENT KW_ON KW_OPERATOR operator_with_argtypes KW_IS comment_text - | KW_COMMENT KW_ON KW_CONSTRAINT name KW_ON table_name KW_IS comment_text - | KW_COMMENT KW_ON KW_CONSTRAINT name KW_ON KW_DOMAIN? any_name KW_IS comment_text - | KW_COMMENT KW_ON KW_POLICY name KW_ON any_name KW_IS comment_text - | KW_COMMENT KW_ON KW_RULE name KW_ON any_name KW_IS comment_text - | KW_COMMENT KW_ON KW_TRIGGER name KW_ON any_name KW_IS comment_text - | KW_COMMENT KW_ON KW_PROCEDURE procedure_with_argtypes KW_IS comment_text - | KW_COMMENT KW_ON KW_ROUTINE routine_with_argtypes KW_IS comment_text - | KW_COMMENT KW_ON KW_TRANSFORM KW_FOR typename KW_LANGUAGE name KW_IS comment_text - | KW_COMMENT KW_ON KW_OPERATOR KW_CLASS any_name KW_USING name KW_IS comment_text - | KW_COMMENT KW_ON KW_OPERATOR KW_FAMILY any_name KW_USING name KW_IS comment_text - | KW_COMMENT KW_ON KW_LARGE KW_OBJECT numericonly KW_IS comment_text - | KW_COMMENT KW_ON KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN KW_IS comment_text - ; - -comment_text - : sconst - | KW_NULL + : KW_COMMENT KW_ON ( + object_type_any_name + | object_type_name + | KW_COLUMN (colid attrs?) DOT column_name + | (KW_TYPE | KW_DOMAIN) typename + | KW_AGGREGATE aggregate_with_argtypes + | KW_FUNCTION function_with_argtypes + | KW_OPERATOR operator_with_argtypes + | KW_CONSTRAINT colid KW_ON (table_name | (KW_DOMAIN? any_name)) + | (KW_POLICY | KW_RULE | KW_TRIGGER) colid KW_ON any_name + | KW_PROCEDURE procedure_with_argtypes + | KW_ROUTINE routine_with_argtypes + | KW_TRANSFORM KW_FOR typename KW_LANGUAGE colid + | KW_OPERATOR (KW_CLASS | KW_FAMILY) any_name table_access_method_clause + | KW_LARGE KW_OBJECT numericonly + | KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN + ) KW_IS (sconst | KW_NULL) ; seclabelstmt - : KW_SECURITY KW_LABEL opt_provider? KW_ON KW_COLUMN column_name KW_IS security_label - | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_TYPE typename KW_IS security_label - | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_DOMAIN typename KW_IS security_label - | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_AGGREGATE aggregate_with_argtypes KW_IS security_label - | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_FUNCTION function_with_argtypes KW_IS security_label - | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_LARGE KW_OBJECT numericonly KW_IS security_label - | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_PROCEDURE procedure_with_argtypes KW_IS security_label - | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_ROUTINE routine_with_argtypes KW_IS security_label - | KW_SECURITY KW_LABEL opt_provider? KW_ON object_type_any_name KW_IS security_label - | KW_SECURITY KW_LABEL opt_provider? KW_ON object_type_name KW_IS security_label - ; - -opt_provider - : KW_FOR nonreservedword_or_sconst - ; - -security_label - : sconst - | KW_NULL + : KW_SECURITY KW_LABEL (KW_FOR nonreservedword_or_sconst)? KW_ON ( + (KW_TYPE | KW_DOMAIN) typename + | KW_AGGREGATE aggregate_with_argtypes + | KW_COLUMN column_name + | KW_FUNCTION function_with_argtypes + | KW_LARGE KW_OBJECT numericonly + | KW_PROCEDURE procedure_with_argtypes + | KW_ROUTINE routine_with_argtypes + | object_type_any_name + | object_type_name + ) KW_IS (sconst | KW_NULL) ; fetchstmt - : KW_FETCH fetch_args - | KW_MOVE fetch_args + : (KW_FETCH | KW_MOVE) fetch_args ; fetch_args - : cursor_name - | from_in cursor_name - | KW_NEXT opt_from_in? cursor_name - | KW_PRIOR opt_from_in? cursor_name - | KW_FIRST opt_from_in? cursor_name - | KW_LAST opt_from_in? cursor_name - | KW_ABSOLUTE signediconst opt_from_in? cursor_name - | KW_RELATIVE signediconst opt_from_in? cursor_name - | signediconst opt_from_in? cursor_name - | KW_ALL opt_from_in? cursor_name - | KW_FORWARD opt_from_in? cursor_name - | KW_FORWARD signediconst opt_from_in? cursor_name - | KW_FORWARD KW_ALL opt_from_in? cursor_name - | KW_BACKWARD opt_from_in? cursor_name - | KW_BACKWARD signediconst opt_from_in? cursor_name - | KW_BACKWARD KW_ALL opt_from_in? cursor_name + : (KW_NEXT | KW_PRIOR | KW_FIRST | KW_LAST)? from_in? colid + | (KW_ABSOLUTE | KW_RELATIVE)? signediconst from_in? colid + | KW_FORWARD signediconst? from_in? colid + | KW_FORWARD? KW_ALL from_in? colid + | KW_BACKWARD (KW_ALL? | signediconst) from_in? colid ; from_in @@ -1796,30 +1247,18 @@ from_in | KW_IN ; -opt_from_in - : from_in - ; - grantstmt - : KW_GRANT privileges KW_ON privilege_target KW_TO grantee_list opt_grant_grant_option? + : KW_GRANT privileges KW_ON privilege_target KW_TO grantee_list (KW_WITH KW_GRANT KW_OPTION)? ; revokestmt - : KW_REVOKE privileges KW_ON privilege_target KW_FROM grantee_list opt_drop_behavior? - | KW_REVOKE KW_GRANT KW_OPTION KW_FOR privileges KW_ON privilege_target KW_FROM grantee_list opt_drop_behavior? + : KW_REVOKE (KW_GRANT KW_OPTION KW_FOR)? privileges KW_ON privilege_target KW_FROM grantee_list opt_drop_behavior? ; privileges - : privilege_list - | KW_ALL - | KW_ALL KW_PRIVILEGES - | KW_ALL OPEN_PAREN column_list CLOSE_PAREN - | KW_ALL KW_PRIVILEGES OPEN_PAREN column_list CLOSE_PAREN - | beforeprivilegeselectlist - ; - -beforeprivilegeselectlist - : beforeprivilegeselect (COMMA beforeprivilegeselect)* + : privilege (COMMA privilege)* + | KW_ALL KW_PRIVILEGES? (opt_column_list)? + | beforeprivilegeselect (COMMA beforeprivilegeselect)* ; beforeprivilegeselect @@ -1838,88 +1277,53 @@ beforeprivilegeselect | KW_EXECUTE ; -privilege_list - : privilege (COMMA privilege)* - ; - privilege - : KW_SELECT opt_column_list? - | KW_REFERENCES opt_column_list? - | KW_CREATE opt_column_list? - | colid opt_column_list? + : (KW_SELECT | KW_REFERENCES | KW_CREATE | colid) opt_column_list? ; privilege_target - : qualified_name_list - | KW_TABLE table_name_list - | KW_SEQUENCE qualified_name_list - | KW_FOREIGN KW_DATA KW_WRAPPER name_list - | KW_FOREIGN KW_SERVER name_list + : KW_TABLE table_name_list + | KW_SEQUENCE? qualified_name_list + | (KW_FOREIGN (KW_DATA KW_WRAPPER | KW_SERVER) | KW_LANGUAGE) name_list | KW_FUNCTION function_with_argtypes_list | KW_PROCEDURE procedure_with_argtypes_list | KW_ROUTINE routine_with_argtypes_list | KW_DATABASE database_nameList - | KW_DOMAIN any_name_list - | KW_LANGUAGE name_list - | KW_LARGE KW_OBJECT numericonly_list + | (KW_DOMAIN | KW_TYPE) any_name_list + | KW_LARGE KW_OBJECT numericonly (COMMA numericonly)* | KW_SCHEMA schema_name_list | KW_TABLESPACE tablespace_name_list - | KW_TYPE any_name_list - | KW_ALL KW_TABLES KW_IN KW_SCHEMA schema_name_list - | KW_ALL KW_SEQUENCES KW_IN KW_SCHEMA schema_name_list - | KW_ALL KW_FUNCTIONS KW_IN KW_SCHEMA schema_name_list - | KW_ALL KW_PROCEDURES KW_IN KW_SCHEMA schema_name_list - | KW_ALL KW_ROUTINES KW_IN KW_SCHEMA schema_name_list + | KW_ALL (KW_TABLES | KW_SEQUENCES | KW_FUNCTIONS | KW_PROCEDURES | KW_ROUTINES) KW_IN KW_SCHEMA schema_name_list ; grantee_list - : grantee (COMMA grantee)* - ; - -grantee - : rolespec - | KW_GROUP rolespec - ; - -opt_grant_grant_option - : KW_WITH KW_GRANT KW_OPTION + : (KW_GROUP? rolespec) (COMMA (KW_GROUP? rolespec))* ; grantrolestmt - : KW_GRANT privilege_list KW_TO role_list opt_grant_admin_option? opt_granted_by? + : KW_GRANT privilege (COMMA privilege)* KW_TO role_list (KW_WITH KW_ADMIN KW_OPTION)? ( + KW_GRANTED KW_BY rolespec + )? ; revokerolestmt - : KW_REVOKE privilege_list KW_FROM role_list opt_granted_by? opt_drop_behavior? - | KW_REVOKE KW_ADMIN KW_OPTION KW_FOR privilege_list KW_FROM role_list opt_granted_by? opt_drop_behavior? - ; - -opt_grant_admin_option - : KW_WITH KW_ADMIN KW_OPTION - ; - -opt_granted_by - : KW_GRANTED KW_BY rolespec + : KW_REVOKE (KW_ADMIN KW_OPTION KW_FOR)? privilege (COMMA privilege)* KW_FROM role_list ( + KW_GRANTED KW_BY rolespec + )? opt_drop_behavior? ; alterdefaultprivilegesstmt - : KW_ALTER KW_DEFAULT KW_PRIVILEGES defacloptionlist defaclaction - ; - -defacloptionlist - : defacloption* - ; - -defacloption - : KW_IN KW_SCHEMA schema_name_list - | KW_FOR KW_ROLE role_list - | KW_FOR KW_USER role_list + : KW_ALTER KW_DEFAULT KW_PRIVILEGES ( + KW_IN KW_SCHEMA schema_name_list + | KW_FOR (KW_ROLE | KW_USER) role_list + )* defaclaction ; defaclaction - : KW_GRANT privileges KW_ON defacl_privilege_target KW_TO grantee_list opt_grant_grant_option? - | KW_REVOKE privileges KW_ON defacl_privilege_target KW_FROM grantee_list opt_drop_behavior? - | KW_REVOKE KW_GRANT KW_OPTION KW_FOR privileges KW_ON defacl_privilege_target KW_FROM grantee_list opt_drop_behavior? + : KW_GRANT privileges KW_ON defacl_privilege_target KW_TO grantee_list ( + KW_WITH KW_GRANT KW_OPTION + )? + | KW_REVOKE (KW_GRANT KW_OPTION KW_FOR)? privileges KW_ON defacl_privilege_target KW_FROM grantee_list opt_drop_behavior? ; defacl_privilege_target @@ -1934,78 +1338,32 @@ defacl_privilege_target //create index indexstmt - : KW_CREATE opt_unique? KW_INDEX opt_concurrently? opt_if_not_exists? opt_index_name? KW_ON relation_expr access_method_clause? OPEN_PAREN - index_params CLOSE_PAREN opt_include? nulls_distinct? opt_reloptions? opttablespace? where_clause? - ; - -opt_unique - : KW_UNIQUE - ; - -opt_concurrently - : KW_CONCURRENTLY - ; - -opt_index_name - : name - ; - -access_method_clause - : KW_USING name + : KW_CREATE KW_UNIQUE? KW_INDEX KW_CONCURRENTLY? opt_if_not_exists? colid? KW_ON relation_expr table_access_method_clause? index_params ( + KW_INCLUDE index_params + )? (KW_NULLS KW_NOT? KW_DISTINCT)? opt_reloptions? opttablespace? where_clause? ; index_params - : index_elem (COMMA index_elem)* - ; - -index_elem_options - : opt_collate? opt_class? opt_asc_desc? opt_nulls_order? - | opt_collate? any_name reloptions opt_asc_desc? opt_nulls_order? + : OPEN_PAREN index_elem (COMMA index_elem)* CLOSE_PAREN ; index_elem - : column_name index_elem_options - | func_expr_windowless index_elem_options - | OPEN_PAREN a_expr CLOSE_PAREN index_elem_options - ; - -opt_include - : KW_INCLUDE OPEN_PAREN index_including_params CLOSE_PAREN - ; - -index_including_params - : index_elem (COMMA index_elem)* - ; - -opt_collate - : KW_COLLATE any_name - ; - -opt_class - : any_name - ; - -opt_asc_desc - : KW_ASC - | KW_DESC - ; - -opt_nulls_order - : KW_NULLS KW_FIRST - | KW_NULLS KW_LAST + : (column_name | func_expr_windowless | OPEN_PAREN expression CLOSE_PAREN) opt_collate_clause? ( + any_name? + | any_name reloptions + ) (KW_ASC | KW_DESC)? (KW_NULLS (KW_FIRST | KW_LAST))? ; createfunctionstmt : KW_CREATE opt_or_replace? ( KW_FUNCTION function_name_create | KW_PROCEDURE procedure_name_create - ) func_args_with_defaults ( - KW_RETURNS (func_return | KW_TABLE OPEN_PAREN table_func_column_list CLOSE_PAREN) - )? createfunc_opt_list (KW_WITH attrilist)? - ; - -attrilist - : OPEN_PAREN colid (COMMA colid)* CLOSE_PAREN + ) (OPEN_PAREN (func_arg_with_default (COMMA func_arg_with_default)*)? CLOSE_PAREN) ( + KW_RETURNS ( + func_type + | KW_TABLE (OPEN_PAREN table_func_column (COMMA table_func_column)* CLOSE_PAREN) + ) + )? createfunc_opt_item+ (KW_WITH OPEN_PAREN name_list CLOSE_PAREN)? ; opt_or_replace @@ -2027,7 +1385,7 @@ routine_with_argtypes_list routine_with_argtypes : routine_name func_args | type_func_name_keyword - | colid indirection? + | qualified_name ; procedure_with_argtypes_list @@ -2037,7 +1395,7 @@ procedure_with_argtypes_list procedure_with_argtypes : procedure_name func_args | type_func_name_keyword - | colid indirection? + | qualified_name ; function_with_argtypes_list @@ -2047,21 +1405,11 @@ function_with_argtypes_list function_with_argtypes : function_name func_args | type_func_name_keyword - | colid indirection? - ; - -func_args_with_defaults - : OPEN_PAREN func_args_with_defaults_list? CLOSE_PAREN - ; - -func_args_with_defaults_list - : func_arg_with_default (COMMA func_arg_with_default)* + | qualified_name ; func_arg - : arg_class param_name? func_type - | param_name arg_class? func_type - | func_type + : (arg_class type_function_name? | type_function_name arg_class?)? func_type ; arg_class @@ -2071,77 +1419,43 @@ arg_class | KW_VARIADIC ; -param_name - : type_function_name - ; - -func_return - : func_type - ; - func_type : typename - | type_function_name attrs PERCENT KW_TYPE - | KW_SETOF type_function_name attrs PERCENT KW_TYPE + | KW_SETOF? type_function_name attrs PERCENT KW_TYPE ; func_arg_with_default - : func_arg ((KW_DEFAULT | EQUAL) a_expr)? - ; - -aggr_arg - : func_arg + : func_arg ((KW_DEFAULT | EQUAL) expression)? ; aggr_args - : OPEN_PAREN ( - STAR - | aggr_args_list - | KW_ORDER KW_BY aggr_args_list - | aggr_args_list KW_ORDER KW_BY aggr_args_list - ) CLOSE_PAREN - ; - -aggr_args_list - : aggr_arg (COMMA aggr_arg)* + : OPEN_PAREN (STAR | func_args_list? (KW_ORDER KW_BY func_args_list)?) CLOSE_PAREN ; aggregate_with_argtypes : function_name aggr_args ; -aggregate_with_argtypes_list - : aggregate_with_argtypes (COMMA aggregate_with_argtypes)* - ; - -createfunc_opt_list - : createfunc_opt_item+ - ; - common_func_opt_item - : KW_CALLED KW_ON KW_NULL KW_INPUT - | KW_RETURNS KW_NULL KW_ON KW_NULL KW_INPUT + : (KW_RETURNS KW_NULL | KW_CALLED) KW_ON KW_NULL KW_INPUT | KW_STRICT | KW_IMMUTABLE | KW_STABLE | KW_VOLATILE - | KW_EXTERNAL KW_SECURITY KW_DEFINER - | KW_EXTERNAL KW_SECURITY KW_INVOKER - | KW_SECURITY KW_DEFINER - | KW_SECURITY KW_INVOKER + | KW_EXTERNAL? KW_SECURITY (KW_DEFINER | KW_INVOKER) | KW_LEAKPROOF | KW_NOT KW_LEAKPROOF - | KW_COST numericonly - | KW_ROWS numericonly + | (KW_COST | KW_ROWS) numericonly | KW_SUPPORT any_name - | functionsetresetclause + | KW_SET set_rest_more + | variableresetstmt | KW_PARALLEL colid ; createfunc_opt_item - : KW_AS sconst COMMA sconst + : KW_AS sconst notify_payload | KW_LANGUAGE nonreservedword_or_sconst - | KW_TRANSFORM transform_type_list + | KW_TRANSFORM KW_FOR KW_TYPE typename (COMMA KW_FOR KW_TYPE typename)* | KW_WINDOW | KW_SET colid (KW_TO colid | EQUAL colid | KW_FROM KW_CURRENT) | KW_AS colid @@ -2156,10 +1470,6 @@ createfunc_opt_item // | KW_AS 'obj_file', 'link_symbol' -transform_type_list - : KW_FOR KW_TYPE typename (COMMA KW_FOR KW_TYPE typename)* - ; - opt_definition : KW_WITH definition ; @@ -2168,83 +1478,57 @@ table_func_column : column_name func_type ; -table_func_column_list - : table_func_column (COMMA table_func_column)* - ; - alterfunctionstmt - : KW_ALTER alterFunctionTypeClause alterfunc_opt_list opt_restrict? - ; - -alterFunctionTypeClause - : KW_FUNCTION function_with_argtypes - | KW_PROCEDURE procedure_with_argtypes - | KW_ROUTINE routine_with_argtypes - ; - -alterfunc_opt_list - : common_func_opt_item+ - ; - -opt_restrict - : KW_RESTRICT + : KW_ALTER ( + KW_FUNCTION function_with_argtypes + | KW_PROCEDURE procedure_with_argtypes + | KW_ROUTINE routine_with_argtypes + ) common_func_opt_item+ KW_RESTRICT? ; removefuncstmt - : KW_DROP KW_FUNCTION opt_if_exists? function_with_argtypes_list opt_drop_behavior? - | KW_DROP KW_PROCEDURE opt_if_exists? procedure_with_argtypes_list opt_drop_behavior? - | KW_DROP KW_ROUTINE opt_if_exists? routine_with_argtypes_list opt_drop_behavior? + : KW_DROP ( + KW_FUNCTION opt_if_exists? function_with_argtypes_list + | KW_PROCEDURE opt_if_exists? procedure_with_argtypes_list + | KW_ROUTINE opt_if_exists? routine_with_argtypes_list + ) opt_drop_behavior? ; removeaggrstmt - : KW_DROP KW_AGGREGATE opt_if_exists? aggregate_with_argtypes_list opt_drop_behavior? + : KW_DROP KW_AGGREGATE opt_if_exists? ( + aggregate_with_argtypes (COMMA aggregate_with_argtypes)* + ) opt_drop_behavior? ; removeoperstmt - : KW_DROP KW_OPERATOR opt_if_exists? operator_with_argtypes_list opt_drop_behavior? + : KW_DROP KW_OPERATOR opt_if_exists? (operator_with_argtypes (COMMA operator_with_argtypes)*) opt_drop_behavior? ; oper_argtypes - : OPEN_PAREN typename CLOSE_PAREN - | OPEN_PAREN typename COMMA typename CLOSE_PAREN - | OPEN_PAREN KW_NONE COMMA typename CLOSE_PAREN - | OPEN_PAREN typename COMMA KW_NONE CLOSE_PAREN + : OPEN_PAREN (typename (COMMA typename)? | KW_NONE COMMA typename | typename COMMA KW_NONE) CLOSE_PAREN ; any_operator : (colid DOT)* all_op ; -operator_with_argtypes_list - : operator_with_argtypes (COMMA operator_with_argtypes)* - ; - operator_with_argtypes : any_operator oper_argtypes ; dostmt - : KW_DO dostmt_opt_list - ; - -dostmt_opt_list - : dostmt_opt_item+ - ; - -dostmt_opt_item - : sconst - | KW_LANGUAGE nonreservedword_or_sconst + : KW_DO (sconst | KW_LANGUAGE nonreservedword_or_sconst)+ ; createcaststmt - : KW_CREATE KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN KW_WITH KW_FUNCTION function_with_argtypes cast_context? - | KW_CREATE KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN KW_WITHOUT KW_FUNCTION cast_context? - | KW_CREATE KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN KW_WITH KW_INOUT cast_context? - ; - -cast_context - : KW_AS KW_IMPLICIT - | KW_AS KW_ASSIGNMENT + : KW_CREATE KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN ( + (KW_WITHOUT KW_FUNCTION (KW_AS (KW_ASSIGNMENT | KW_IMPLICIT))?) + | ( + KW_WITH (KW_FUNCTION function_with_argtypes | KW_INOUT) ( + KW_AS (KW_ASSIGNMENT | KW_IMPLICIT) + )? + ) + ) ; opt_if_exists @@ -2252,247 +1536,187 @@ opt_if_exists ; createtransformstmt - : KW_CREATE opt_or_replace? KW_TRANSFORM KW_FOR typename KW_LANGUAGE name OPEN_PAREN transform_element_list CLOSE_PAREN + : KW_CREATE opt_or_replace? KW_TRANSFORM KW_FOR typename KW_LANGUAGE colid OPEN_PAREN ( + KW_FROM sql_with_function (COMMA KW_TO sql_with_function)? + | KW_TO sql_with_function (COMMA KW_FROM sql_with_function)? + ) CLOSE_PAREN ; -transform_element_list - : KW_FROM KW_SQL KW_WITH KW_FUNCTION function_with_argtypes COMMA KW_TO KW_SQL KW_WITH KW_FUNCTION function_with_argtypes - | KW_TO KW_SQL KW_WITH KW_FUNCTION function_with_argtypes COMMA KW_FROM KW_SQL KW_WITH KW_FUNCTION function_with_argtypes - | KW_FROM KW_SQL KW_WITH KW_FUNCTION function_with_argtypes - | KW_TO KW_SQL KW_WITH KW_FUNCTION function_with_argtypes +sql_with_function + : KW_SQL KW_WITH KW_FUNCTION function_with_argtypes ; reindexstmt - : KW_REINDEX reindex_target_type - | KW_REINDEX reindex_target_multitable - | KW_REINDEX OPEN_PAREN reindex_option_list CLOSE_PAREN reindex_target_type - | KW_REINDEX OPEN_PAREN reindex_option_list CLOSE_PAREN reindex_target_multitable - ; - -reindex_target_type - : (KW_INDEX opt_concurrently? qualified_name) - | (KW_TABLE opt_concurrently? table_name) - ; - -reindex_target_multitable - : (KW_SCHEMA opt_concurrently? schema_name) - | (KW_SYSTEM opt_concurrently? name) - | (KW_DATABASE opt_concurrently? database_name) - ; - -reindex_option_list - : reindex_option_elem (COMMA reindex_option_elem)* - ; - -reindex_option_elem - : KW_VERBOSE + : KW_REINDEX (OPEN_PAREN KW_VERBOSE (COMMA KW_VERBOSE)* CLOSE_PAREN)? ( + ( + KW_INDEX KW_CONCURRENTLY? qualified_name + | KW_TABLE KW_CONCURRENTLY? table_name + | KW_SCHEMA KW_CONCURRENTLY? schema_name + | KW_SYSTEM KW_CONCURRENTLY? colid + | KW_DATABASE KW_CONCURRENTLY? database_name + ) + ) ; altertblspcstmt - : KW_ALTER KW_TABLESPACE tablespace_name KW_SET reloptions - | KW_ALTER KW_TABLESPACE tablespace_name KW_RESET reloptions + : KW_ALTER opttablespace (KW_SET | KW_RESET) reloptions ; renamestmt - : KW_ALTER KW_AGGREGATE aggregate_with_argtypes KW_RENAME KW_TO name - | KW_ALTER KW_COLLATION any_name KW_RENAME KW_TO name - | KW_ALTER KW_CONVERSION any_name KW_RENAME KW_TO name + : KW_ALTER (KW_AGGREGATE aggregate_with_argtypes | KW_ROUTINE routine_with_argtypes) KW_RENAME KW_TO colid | KW_ALTER KW_DATABASE database_name KW_RENAME KW_TO database_name_create - | KW_ALTER KW_DOMAIN any_name KW_RENAME KW_TO name - | KW_ALTER KW_DOMAIN any_name KW_RENAME KW_CONSTRAINT name KW_TO name - | KW_ALTER KW_FOREIGN KW_DATA KW_WRAPPER name KW_RENAME KW_TO name + | KW_ALTER (KW_DOMAIN | KW_STATISTICS | KW_TYPE | KW_CONVERSION | KW_COLLATION) any_name KW_RENAME KW_TO colid | KW_ALTER KW_FUNCTION function_with_argtypes KW_RENAME KW_TO function_name_create - | KW_ALTER KW_GROUP roleid KW_RENAME KW_TO roleid - | KW_ALTER opt_procedural? KW_LANGUAGE name KW_RENAME KW_TO name - | KW_ALTER KW_OPERATOR KW_CLASS any_name KW_USING name KW_RENAME KW_TO name - | KW_ALTER KW_OPERATOR KW_FAMILY any_name KW_USING name KW_RENAME KW_TO name - | KW_ALTER KW_POLICY opt_if_exists? name KW_ON qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_OPERATOR (KW_CLASS | KW_FAMILY) any_name table_access_method_clause KW_RENAME KW_TO colid | KW_ALTER KW_PROCEDURE procedure_with_argtypes KW_RENAME KW_TO procedure_name_create - | KW_ALTER KW_PUBLICATION name KW_RENAME KW_TO name - | KW_ALTER KW_ROUTINE routine_with_argtypes KW_RENAME KW_TO name | KW_ALTER KW_SCHEMA schema_name KW_RENAME KW_TO schema_name_create - | KW_ALTER KW_SERVER name KW_RENAME KW_TO name - | KW_ALTER KW_SUBSCRIPTION name KW_RENAME KW_TO name - | KW_ALTER KW_TABLE opt_if_exists? relation_expr KW_RENAME KW_TO table_name_create - | KW_ALTER KW_SEQUENCE opt_if_exists? qualified_name KW_RENAME KW_TO name - | KW_ALTER KW_VIEW opt_if_exists? view_name KW_RENAME KW_TO view_name_create - | KW_ALTER KW_MATERIALIZED KW_VIEW opt_if_exists? view_name KW_RENAME KW_TO view_name_create - | KW_ALTER KW_INDEX opt_if_exists? qualified_name KW_RENAME KW_TO name - | KW_ALTER KW_FOREIGN KW_TABLE opt_if_exists? relation_expr KW_RENAME KW_TO table_name_create - | KW_ALTER KW_TABLE opt_if_exists? relation_expr KW_RENAME KW_COLUMN? column_name KW_TO column_name_create - | KW_ALTER KW_VIEW opt_if_exists? view_name KW_RENAME KW_COLUMN? column_name KW_TO column_name_create - | KW_ALTER KW_MATERIALIZED KW_VIEW opt_if_exists? view_name KW_RENAME KW_COLUMN? column_name KW_TO column_name_create - | KW_ALTER KW_TABLE opt_if_exists? relation_expr KW_RENAME KW_CONSTRAINT name KW_TO name - | KW_ALTER KW_FOREIGN KW_TABLE opt_if_exists? relation_expr KW_RENAME KW_COLUMN? column_name KW_TO column_name_create - | KW_ALTER KW_RULE name KW_ON qualified_name KW_RENAME KW_TO name - | KW_ALTER KW_TRIGGER name KW_ON qualified_name KW_RENAME KW_TO name - | KW_ALTER KW_EVENT KW_TRIGGER name KW_RENAME KW_TO name - | KW_ALTER KW_ROLE roleid KW_RENAME KW_TO roleid - | KW_ALTER KW_USER roleid KW_RENAME KW_TO roleid - | KW_ALTER KW_TABLESPACE tablespace_name KW_RENAME KW_TO tablespace_name_create - | KW_ALTER KW_STATISTICS any_name KW_RENAME KW_TO name - | KW_ALTER KW_TEXT KW_SEARCH KW_PARSER any_name KW_RENAME KW_TO name - | KW_ALTER KW_TEXT KW_SEARCH KW_DICTIONARY any_name KW_RENAME KW_TO name - | KW_ALTER KW_TEXT KW_SEARCH KW_TEMPLATE any_name KW_RENAME KW_TO name - | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_RENAME KW_TO name - | KW_ALTER KW_TYPE any_name KW_RENAME KW_TO name - | KW_ALTER KW_TYPE any_name KW_RENAME KW_ATTRIBUTE name KW_TO name opt_drop_behavior? - ; - -opt_set_data - : KW_SET KW_DATA + | KW_ALTER (KW_SEQUENCE | KW_INDEX) opt_if_exists? qualified_name KW_RENAME KW_TO colid + | KW_ALTER KW_MATERIALIZED? KW_VIEW opt_if_exists? view_name KW_RENAME KW_TO view_name_create + | KW_ALTER KW_FOREIGN? KW_TABLE opt_if_exists? relation_expr KW_RENAME KW_TO table_name_create + | KW_ALTER ( + KW_FOREIGN? KW_TABLE opt_if_exists? relation_expr KW_RENAME KW_COLUMN? + | KW_MATERIALIZED? KW_VIEW opt_if_exists? view_name KW_RENAME KW_COLUMN? + ) column_name KW_TO column_name_create + | KW_ALTER (KW_TABLE opt_if_exists? relation_expr | KW_DOMAIN any_name) KW_RENAME KW_CONSTRAINT colid KW_TO colid + | KW_ALTER ((KW_POLICY opt_if_exists?) | KW_RULE | KW_TRIGGER) colid KW_ON qualified_name KW_RENAME KW_TO colid + | KW_ALTER ( + KW_FOREIGN KW_DATA KW_WRAPPER + | KW_PROCEDURAL? KW_LANGUAGE + | KW_PUBLICATION + | KW_SERVER + | KW_SUBSCRIPTION + | KW_EVENT KW_TRIGGER + ) colid KW_RENAME KW_TO colid + | KW_ALTER (KW_USER | KW_ROLE | KW_GROUP) rolespec KW_RENAME KW_TO rolespec + | KW_ALTER opttablespace KW_RENAME KW_TO tablespace_name_create + | KW_ALTER KW_TEXT KW_SEARCH (KW_PARSER | KW_DICTIONARY | KW_TEMPLATE | KW_CONFIGURATION) any_name KW_RENAME KW_TO colid + | KW_ALTER KW_TYPE any_name KW_RENAME KW_ATTRIBUTE colid KW_TO colid opt_drop_behavior? ; alterobjectdependsstmt - : KW_ALTER KW_FUNCTION function_with_argtypes opt_no? KW_DEPENDS KW_ON KW_EXTENSION name - | KW_ALTER KW_PROCEDURE procedure_with_argtypes opt_no? KW_DEPENDS KW_ON KW_EXTENSION name - | KW_ALTER KW_ROUTINE routine_with_argtypes opt_no? KW_DEPENDS KW_ON KW_EXTENSION name - | KW_ALTER KW_TRIGGER name KW_ON qualified_name opt_no? KW_DEPENDS KW_ON KW_EXTENSION name - | KW_ALTER KW_MATERIALIZED KW_VIEW view_name opt_no? KW_DEPENDS KW_ON KW_EXTENSION name - | KW_ALTER KW_INDEX qualified_name opt_no? KW_DEPENDS KW_ON KW_EXTENSION name - ; - -opt_no - : KW_NO + : KW_ALTER ( + KW_FUNCTION function_with_argtypes + | KW_PROCEDURE procedure_with_argtypes + | KW_ROUTINE routine_with_argtypes + | KW_TRIGGER colid KW_ON qualified_name + | KW_MATERIALIZED KW_VIEW view_name + | KW_INDEX qualified_name + ) KW_NO? KW_DEPENDS KW_ON KW_EXTENSION colid ; alterobjectschemastmt - : KW_ALTER KW_AGGREGATE aggregate_with_argtypes KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_COLLATION any_name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_CONVERSION any_name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_DOMAIN any_name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_EXTENSION name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_FUNCTION function_with_argtypes KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_OPERATOR operator_with_argtypes KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_OPERATOR KW_CLASS any_name KW_USING name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_OPERATOR KW_FAMILY any_name KW_USING name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_PROCEDURE procedure_with_argtypes KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_ROUTINE routine_with_argtypes KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_TABLE opt_if_exists? relation_expr KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_STATISTICS any_name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_TEXT KW_SEARCH KW_PARSER any_name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_TEXT KW_SEARCH KW_DICTIONARY any_name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_TEXT KW_SEARCH KW_TEMPLATE any_name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_SEQUENCE opt_if_exists? qualified_name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_VIEW opt_if_exists? view_name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_MATERIALIZED KW_VIEW opt_if_exists? view_name KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_FOREIGN KW_TABLE opt_if_exists? relation_expr KW_SET KW_SCHEMA schema_name - | KW_ALTER KW_TYPE any_name KW_SET KW_SCHEMA schema_name + : KW_ALTER ( + KW_AGGREGATE aggregate_with_argtypes + | KW_EXTENSION colid + | KW_FUNCTION function_with_argtypes + | KW_OPERATOR operator_with_argtypes + | KW_OPERATOR (KW_CLASS | KW_FAMILY) any_name table_access_method_clause + | KW_PROCEDURE procedure_with_argtypes + | KW_ROUTINE routine_with_argtypes + | KW_SEQUENCE opt_if_exists? qualified_name + | KW_MATERIALIZED? KW_VIEW opt_if_exists? view_name + | KW_FOREIGN? KW_TABLE opt_if_exists? relation_expr + ) KW_SET KW_SCHEMA schema_name + | KW_ALTER ( + KW_TEXT KW_SEARCH (KW_PARSER | KW_DICTIONARY | KW_TEMPLATE | KW_CONFIGURATION) + | KW_COLLATION + | KW_CONVERSION + | KW_DOMAIN + | KW_STATISTICS + | KW_TYPE + ) any_name KW_SET KW_SCHEMA schema_name ; alteroperatorstmt - : KW_ALTER KW_OPERATOR operator_with_argtypes KW_SET OPEN_PAREN operator_def_list CLOSE_PAREN + : KW_ALTER KW_OPERATOR operator_with_argtypes KW_SET operator_def_list ; operator_def_list - : operator_def_elem (COMMA operator_def_elem)* + : OPEN_PAREN operator_def_elem (COMMA operator_def_elem)* CLOSE_PAREN ; operator_def_elem - : collabel EQUAL KW_NONE - | collabel EQUAL operator_def_arg - ; - -operator_def_arg - : func_type - | reserved_keyword - | qual_all_op - | numericonly - | sconst + : collabel EQUAL (KW_NONE | func_type | reserved_keyword | qual_all_op | numericonly | sconst) ; altertypestmt - : KW_ALTER KW_TYPE any_name KW_SET OPEN_PAREN operator_def_list CLOSE_PAREN + : KW_ALTER KW_TYPE any_name KW_SET operator_def_list ; alterownerstmt - : KW_ALTER KW_AGGREGATE aggregate_with_argtypes KW_OWNER KW_TO rolespec - | KW_ALTER KW_COLLATION any_name KW_OWNER KW_TO rolespec - | KW_ALTER KW_CONVERSION any_name KW_OWNER KW_TO rolespec - | KW_ALTER KW_DATABASE database_name KW_OWNER KW_TO rolespec - | KW_ALTER KW_DOMAIN any_name KW_OWNER KW_TO rolespec - | KW_ALTER KW_FUNCTION function_with_argtypes KW_OWNER KW_TO rolespec - | KW_ALTER opt_procedural? KW_LANGUAGE name KW_OWNER KW_TO rolespec - | KW_ALTER KW_LARGE KW_OBJECT numericonly KW_OWNER KW_TO rolespec - | KW_ALTER KW_OPERATOR operator_with_argtypes KW_OWNER KW_TO rolespec - | KW_ALTER KW_OPERATOR KW_CLASS any_name KW_USING name KW_OWNER KW_TO rolespec - | KW_ALTER KW_OPERATOR KW_FAMILY any_name KW_USING name KW_OWNER KW_TO rolespec - | KW_ALTER KW_PROCEDURE procedure_with_argtypes KW_OWNER KW_TO rolespec - | KW_ALTER KW_ROUTINE routine_with_argtypes KW_OWNER KW_TO rolespec - | KW_ALTER KW_SCHEMA schema_name KW_OWNER KW_TO rolespec - | KW_ALTER KW_TYPE any_name KW_OWNER KW_TO rolespec - | KW_ALTER KW_TABLESPACE tablespace_name KW_OWNER KW_TO rolespec - | KW_ALTER KW_STATISTICS any_name KW_OWNER KW_TO rolespec - | KW_ALTER KW_TEXT KW_SEARCH KW_DICTIONARY any_name KW_OWNER KW_TO rolespec - | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_OWNER KW_TO rolespec - | KW_ALTER KW_FOREIGN KW_DATA KW_WRAPPER name KW_OWNER KW_TO rolespec - | KW_ALTER KW_SERVER name KW_OWNER KW_TO rolespec - | KW_ALTER KW_EVENT KW_TRIGGER name KW_OWNER KW_TO rolespec - | KW_ALTER KW_PUBLICATION name KW_OWNER KW_TO rolespec - | KW_ALTER KW_SUBSCRIPTION name KW_OWNER KW_TO rolespec + : KW_ALTER KW_OPERATOR (KW_CLASS | KW_FAMILY) any_name table_access_method_clause KW_OWNER KW_TO rolespec + | KW_ALTER ( + KW_AGGREGATE aggregate_with_argtypes + | KW_DATABASE database_name + | KW_FUNCTION function_with_argtypes + | KW_PROCEDURAL? KW_LANGUAGE colid + | KW_LARGE KW_OBJECT numericonly + | KW_LARGE KW_OBJECT numericonly + | KW_OPERATOR operator_with_argtypes + | KW_PROCEDURE procedure_with_argtypes + | KW_ROUTINE routine_with_argtypes + | KW_SCHEMA schema_name + | opttablespace + ) KW_OWNER KW_TO rolespec + | KW_ALTER ( + KW_TEXT KW_SEARCH (KW_DICTIONARY | KW_CONFIGURATION) + | KW_COLLATION + | KW_CONVERSION + | KW_DOMAIN + | KW_TYPE + | KW_STATISTICS + ) any_name KW_OWNER KW_TO rolespec + | KW_ALTER ( + KW_SERVER + | (KW_FOREIGN KW_DATA KW_WRAPPER) + | (KW_EVENT KW_TRIGGER) + | KW_PUBLICATION + | KW_SUBSCRIPTION + ) colid KW_OWNER KW_TO rolespec ; createpublicationstmt - : KW_CREATE KW_PUBLICATION name opt_publication_for_tables? opt_definition? - ; - -opt_publication_for_tables - : publication_for_tables - ; - -publication_for_tables - : KW_FOR KW_TABLE relation_expr_list - | KW_FOR KW_ALL KW_TABLES + : KW_CREATE KW_PUBLICATION colid (KW_FOR KW_TABLE relation_expr_list | KW_FOR KW_ALL KW_TABLES)? opt_definition? ; alterpublicationstmt - : KW_ALTER KW_PUBLICATION name KW_SET definition - | KW_ALTER KW_PUBLICATION name KW_ADD publication_relation_expr_list - | KW_ALTER KW_PUBLICATION name KW_SET publication_relation_expr_list - | KW_ALTER KW_PUBLICATION name KW_DROP publication_relation_expr_list - | KW_ALTER KW_PUBLICATION name KW_OWNER KW_TO rolespec - | KW_ALTER KW_PUBLICATION name KW_RENAME KW_TO name + : KW_ALTER KW_PUBLICATION colid ( + (KW_OWNER KW_TO rolespec) + | (KW_SET definition) + | (KW_RENAME KW_TO colid) + | (KW_ADD | KW_SET | KW_DROP) publication_relation_expr (COMMA publication_relation_expr)* + ) ; createsubscriptionstmt - : KW_CREATE KW_SUBSCRIPTION name KW_CONNECTION sconst KW_PUBLICATION publication_name_list opt_definition? - ; - -publication_name_list - : publication_name_item (COMMA publication_name_item)* - ; - -publication_name_item - : collabel + : KW_CREATE KW_SUBSCRIPTION colid KW_CONNECTION sconst KW_PUBLICATION ( + collabel (COMMA collabel)* + ) opt_definition? ; altersubscriptionstmt - : KW_ALTER KW_SUBSCRIPTION name KW_SET definition - | KW_ALTER KW_SUBSCRIPTION name KW_CONNECTION sconst - | KW_ALTER KW_SUBSCRIPTION name KW_REFRESH KW_PUBLICATION opt_definition? - | KW_ALTER KW_SUBSCRIPTION name KW_SET KW_PUBLICATION publication_name_list opt_definition? - | KW_ALTER KW_SUBSCRIPTION name KW_ADD KW_PUBLICATION publication_name_list opt_definition? - | KW_ALTER KW_SUBSCRIPTION name KW_DROP KW_PUBLICATION publication_name_list opt_definition? - | KW_ALTER KW_SUBSCRIPTION name KW_ENABLE - | KW_ALTER KW_SUBSCRIPTION name KW_DISABLE - | KW_ALTER KW_SUBSCRIPTION name KW_SET definition - | KW_ALTER KW_SUBSCRIPTION name KW_SKIP OPEN_PAREN old_aggr_elem CLOSE_PAREN - | KW_ALTER KW_SUBSCRIPTION name KW_OWNER KW_TO rolespec + : KW_ALTER KW_SUBSCRIPTION colid KW_SET definition + | KW_ALTER KW_SUBSCRIPTION colid KW_CONNECTION sconst + | KW_ALTER KW_SUBSCRIPTION colid KW_REFRESH KW_PUBLICATION opt_definition? + | KW_ALTER KW_SUBSCRIPTION colid (KW_SET | KW_ADD | KW_DROP) KW_PUBLICATION ( + collabel (COMMA collabel)* + ) opt_definition? + | KW_ALTER KW_SUBSCRIPTION colid (KW_ENABLE | KW_DISABLE) + | KW_ALTER KW_SUBSCRIPTION colid KW_SKIP OPEN_PAREN old_aggr_elem CLOSE_PAREN + | KW_ALTER KW_SUBSCRIPTION colid KW_OWNER KW_TO rolespec ; rulestmt - : KW_CREATE opt_or_replace? KW_RULE name KW_AS KW_ON event KW_TO qualified_name where_clause? KW_DO opt_instead? ruleactionlist - ; - -ruleactionlist - : KW_NOTHING - | ruleactionstmt - | OPEN_PAREN ruleactionmulti CLOSE_PAREN - ; - -ruleactionmulti - : ruleactionstmtOrEmpty? (SEMI ruleactionstmtOrEmpty?)* + : KW_CREATE opt_or_replace? KW_RULE colid KW_AS KW_ON ( + KW_SELECT + | KW_UPDATE + | KW_DELETE + | KW_INSERT + ) KW_TO qualified_name where_clause? KW_DO (KW_INSTEAD | KW_ALSO)? ( + KW_NOTHING + | ruleactionstmt + | OPEN_PAREN (ruleactionstmt? (SEMI ruleactionstmt?)*) CLOSE_PAREN + ) ; ruleactionstmt @@ -2503,22 +1727,6 @@ ruleactionstmt | notifystmt ; -ruleactionstmtOrEmpty - : ruleactionstmt - ; - -event - : KW_SELECT - | KW_UPDATE - | KW_DELETE - | KW_INSERT - ; - -opt_instead - : KW_INSTEAD - | KW_ALSO - ; - notifystmt : KW_NOTIFY colid notify_payload? ; @@ -2532,23 +1740,18 @@ listenstmt ; unlistenstmt - : KW_UNLISTEN colid - | KW_UNLISTEN STAR + : KW_UNLISTEN (colid | STAR) ; transactionstmt - : KW_ABORT opt_transaction? opt_transaction_chain? - | KW_BEGIN opt_transaction? transaction_mode_list_or_empty? - | KW_START KW_TRANSACTION transaction_mode_list_or_empty? - | KW_END opt_transaction? opt_transaction_chain? + : KW_BEGIN opt_transaction? transaction_mode_list? + | KW_START KW_TRANSACTION transaction_mode_list? | KW_SAVEPOINT colid | KW_RELEASE KW_SAVEPOINT? colid | KW_PREPARE KW_TRANSACTION sconst - | KW_COMMIT KW_PREPARED sconst - | KW_COMMIT opt_transaction? opt_transaction_chain? - | KW_ROLLBACK KW_PREPARED sconst + | (KW_COMMIT | KW_ROLLBACK) KW_PREPARED sconst + | (KW_ABORT | KW_END | KW_COMMIT | KW_ROLLBACK) opt_transaction? (KW_AND KW_NO? KW_CHAIN)? | KW_ROLLBACK opt_transaction? KW_TO KW_SAVEPOINT? colid - | KW_ROLLBACK opt_transaction? opt_transaction_chain? ; opt_transaction @@ -2558,73 +1761,45 @@ opt_transaction transaction_mode_item : KW_ISOLATION KW_LEVEL iso_level - | KW_READ KW_ONLY - | KW_READ KW_WRITE - | KW_DEFERRABLE - | KW_NOT KW_DEFERRABLE + | KW_READ (KW_ONLY | KW_WRITE) + | KW_NOT? KW_DEFERRABLE ; transaction_mode_list : transaction_mode_item (COMMA? transaction_mode_item)* ; -transaction_mode_list_or_empty - : transaction_mode_list - ; - -opt_transaction_chain - : KW_AND KW_NO? KW_CHAIN - ; - viewstmt : KW_CREATE (KW_OR KW_REPLACE)? opttemp? ( KW_VIEW view_name_create opt_column_list_create? opt_reloptions? - | KW_RECURSIVE KW_VIEW view_name_create OPEN_PAREN column_list CLOSE_PAREN opt_reloptions? - ) KW_AS selectstmt opt_check_option? # createView - ; - -opt_check_option - : KW_WITH (KW_CASCADED | KW_LOCAL)? KW_CHECK KW_OPTION + | KW_RECURSIVE KW_VIEW view_name_create opt_column_list opt_reloptions? + ) KW_AS selectstmt (KW_WITH (KW_CASCADED | KW_LOCAL)? KW_CHECK KW_OPTION)? # createView ; loadstmt - : KW_LOAD file_name + : KW_LOAD sconst ; createdbstmt - : KW_CREATE KW_DATABASE database_name_create opt_with? createdb_opt_list? # createDatabase - ; - -createdb_opt_list - : createdb_opt_items - ; - -createdb_opt_items - : createdb_opt_item+ + : KW_CREATE KW_DATABASE database_name_create KW_WITH? (createdb_opt_item+)? # createDatabase ; createdb_opt_item - : createdb_opt_name opt_equal? (signediconst | opt_boolean_or_string | KW_DEFAULT) - ; - -createdb_opt_name - : KW_CONNECTION KW_LIMIT - | KW_ENCODING - | KW_LOCATION - | KW_OWNER - | KW_TABLESPACE - | KW_TEMPLATE - | identifier - ; - -opt_equal - : EQUAL + : ( + KW_CONNECTION KW_LIMIT + | KW_ENCODING + | KW_LOCATION + | KW_OWNER + | KW_TABLESPACE + | KW_TEMPLATE + | identifier + ) EQUAL? (signediconst | opt_boolean_or_string | KW_DEFAULT) ; alterdatabasestmt : KW_ALTER KW_DATABASE database_name ( (KW_SET KW_TABLESPACE tablespace_name_create)? - | (KW_WITH? createdb_opt_list)? + | (KW_WITH? createdb_opt_item+)? ) ; @@ -2632,14 +1807,6 @@ alterdatabasesetstmt : KW_ALTER KW_DATABASE database_name setresetclause? ; -drop_option_list - : drop_option (COMMA drop_option)* - ; - -drop_option - : KW_FORCE - ; - altercollationstmt : KW_ALTER KW_COLLATION any_name KW_REFRESH KW_VERSION ; @@ -2649,70 +1816,47 @@ altersystemstmt ; createdomainstmt - : KW_CREATE KW_DOMAIN any_name opt_as? typename colquallist + : KW_CREATE KW_DOMAIN any_name KW_AS? typename colconstraint* ; alterdomainstmt : KW_ALTER KW_DOMAIN any_name ( alter_column_default - | KW_DROP KW_NOT KW_NULL - | KW_SET KW_NOT KW_NULL - | KW_ADD tableconstraint - | KW_DROP KW_CONSTRAINT opt_if_exists? name opt_drop_behavior? - | KW_VALIDATE KW_CONSTRAINT name + | (KW_DROP | KW_SET) KW_NOT KW_NULL + | KW_ADD (KW_CONSTRAINT colid)? constraintelem + | KW_DROP KW_CONSTRAINT opt_if_exists? colid opt_drop_behavior? + | KW_VALIDATE KW_CONSTRAINT colid ) ; -opt_as - : KW_AS - ; - altertsdictionarystmt : KW_ALTER KW_TEXT KW_SEARCH KW_DICTIONARY any_name definition ; altertsconfigurationstmt - : KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_ADD KW_MAPPING KW_FOR name_list any_with any_name_list - | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_ALTER KW_MAPPING KW_FOR name_list any_with any_name_list - | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_ALTER KW_MAPPING KW_REPLACE any_name any_with any_name - | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_ALTER KW_MAPPING KW_FOR name_list KW_REPLACE any_name any_with any_name + : KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name (KW_ADD | KW_ALTER) KW_MAPPING KW_FOR name_list KW_WITH any_name_list + | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_ALTER KW_MAPPING (KW_FOR name_list)? KW_REPLACE any_name KW_WITH any_name | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_DROP KW_MAPPING opt_if_exists? KW_FOR name_list ; -any_with - : KW_WITH - ; // | WITH_LA - createconversionstmt - : KW_CREATE opt_default? KW_CONVERSION any_name KW_FOR sconst KW_TO sconst KW_FROM any_name + : KW_CREATE KW_DEFAULT? KW_CONVERSION any_name KW_FOR sconst KW_TO sconst KW_FROM any_name ; clusterstmt - : KW_CLUSTER opt_verbose? table_name cluster_index_specification? - | KW_CLUSTER opt_verbose? - | KW_CLUSTER opt_verbose_list table_name cluster_index_specification? - ; - -opt_verbose_list - : OPEN_PAREN opt_verbose (COMMA opt_verbose)* CLOSE_PAREN - ; - -cluster_index_specification - : KW_USING name + : KW_CLUSTER opt_verbose? (table_name table_access_method_clause?)? + | KW_CLUSTER OPEN_PAREN opt_verbose (COMMA opt_verbose)* CLOSE_PAREN table_name table_access_method_clause? ; vacuumstmt - : KW_VACUUM opt_full? opt_freeze? opt_verbose? opt_analyze? opt_vacuum_relation_list? - | KW_VACUUM (OPEN_PAREN vac_analyze_option_list CLOSE_PAREN)? opt_vacuum_relation_list? + : KW_VACUUM ((KW_FULL? KW_FREEZE? opt_verbose? analyze_keyword?) | (explain_option_list)?) vacuum_relation_list? ; analyzestmt - : analyze_keyword opt_verbose? opt_vacuum_relation_list? - | analyze_keyword OPEN_PAREN analyze_options_list CLOSE_PAREN opt_vacuum_relation_list? - ; - -vac_analyze_option_list - : vac_analyze_option_elem (COMMA vac_analyze_option_elem)* + : analyze_keyword ( + opt_verbose? + | OPEN_PAREN analyze_option_elem (COMMA analyze_option_elem)* CLOSE_PAREN + ) vacuum_relation_list? ; analyze_keyword @@ -2721,74 +1865,28 @@ analyze_keyword ; vac_analyze_option_elem - : vac_analyze_option_name vac_analyze_option_arg? - ; - -vac_analyze_option_name - : nonreservedword - | analyze_keyword - ; - -vac_analyze_option_arg - : opt_boolean_or_string - | numericonly - ; - -opt_analyze - : analyze_keyword - ; - -analyze_options_list - : analyze_option_elem (COMMA analyze_option_elem)* + : (nonreservedword | analyze_keyword) (opt_boolean_or_string | numericonly)? ; analyze_option_elem - : opt_verbose - | opt_skiplock - | opt_buffer_usage_limit + : (KW_SKIP_LOCKED | KW_VERBOSE) (KW_FALSE | KW_TRUE)? + | KW_BUFFER_USAGE_LIMIT (numericonly | sconst) ; // support on v12+ opt_verbose : KW_VERBOSE (KW_FALSE | KW_TRUE)? ; -opt_skiplock - : KW_SKIP_LOCKED (KW_FALSE | KW_TRUE)? - ; - -opt_buffer_usage_limit - : KW_BUFFER_USAGE_LIMIT (numericonly | sconst) - ; - -opt_full - : KW_FULL - ; - -opt_freeze - : KW_FREEZE - ; - -opt_name_list - : OPEN_PAREN column_list CLOSE_PAREN - ; - vacuum_relation - : table_name opt_name_list? + : table_name opt_column_list? ; vacuum_relation_list : vacuum_relation (COMMA vacuum_relation)* ; -opt_vacuum_relation_list - : vacuum_relation_list - ; - explainstmt - : KW_EXPLAIN explainablestmt - | KW_EXPLAIN analyze_keyword opt_verbose? explainablestmt - | KW_EXPLAIN KW_VERBOSE explainablestmt - | KW_EXPLAIN OPEN_PAREN explain_option_list CLOSE_PAREN explainablestmt + : KW_EXPLAIN (explain_option_list | KW_VERBOSE? | (analyze_keyword opt_verbose?)?) explainablestmt ; explainablestmt @@ -2804,29 +1902,15 @@ explainablestmt ; explain_option_list - : explain_option_elem (COMMA explain_option_elem)* - ; - -explain_option_elem - : explain_option_name explain_option_arg? - ; - -explain_option_name - : nonreservedword - | analyze_keyword - ; - -explain_option_arg - : opt_boolean_or_string - | numericonly + : OPEN_PAREN vac_analyze_option_elem (COMMA vac_analyze_option_elem)* CLOSE_PAREN ; preparestmt - : KW_PREPARE name prep_type_clause? KW_AS preparablestmt + : KW_PREPARE colid prep_type_clause? KW_AS preparablestmt ; prep_type_clause - : OPEN_PAREN type_list CLOSE_PAREN + : OPEN_PAREN typename (COMMA typename)* CLOSE_PAREN ; preparablestmt @@ -2837,8 +1921,8 @@ preparablestmt ; executestmt - : KW_EXECUTE name execute_param_clause? - | KW_CREATE opttemp? KW_TABLE opt_if_not_exists? create_as_target KW_AS KW_EXECUTE name execute_param_clause? opt_with_data? + : KW_EXECUTE colid execute_param_clause? + | KW_CREATE opttemp? KW_TABLE opt_if_not_exists? create_as_target KW_AS KW_EXECUTE colid execute_param_clause? opt_with_data? ; execute_param_clause @@ -2846,29 +1930,25 @@ execute_param_clause ; deallocatestmt - : KW_DEALLOCATE KW_PREPARE? (name | KW_ALL) + : KW_DEALLOCATE KW_PREPARE? (colid | KW_ALL) ; insertstmt - : opt_with_clause? KW_INSERT KW_INTO insert_target insert_rest opt_on_conflict? returning_clause? # insertStatement - ; - -insert_target - : table_name (KW_AS colid)? + : with_clause? KW_INSERT KW_INTO table_name (KW_AS colid)? insert_rest ( + KW_ON KW_CONFLICT (index_params where_clause? | KW_ON KW_CONSTRAINT colid)? KW_DO ( + KW_UPDATE KW_SET set_clause_list where_clause? + | KW_NOTHING + ) + )? returning_clause? # insertStatement ; insert_rest - : (OPEN_PAREN insert_column_list CLOSE_PAREN)? (KW_OVERRIDING override_kind KW_VALUE)? ( + : (OPEN_PAREN insert_column_list CLOSE_PAREN)? (KW_OVERRIDING (KW_USER | KW_SYSTEM) KW_VALUE)? ( default_values_or_values | selectstmt ) ; -override_kind - : KW_USER - | KW_SYSTEM - ; - insert_column_list : insert_column_item (COMMA insert_column_item)* ; @@ -2877,56 +1957,26 @@ insert_column_item : column_name opt_indirection ; -opt_on_conflict - : KW_ON KW_CONFLICT opt_conf_expr? KW_DO ( - KW_UPDATE KW_SET set_clause_list where_clause? - | KW_NOTHING - ) - ; - -opt_conf_expr - : OPEN_PAREN index_params CLOSE_PAREN where_clause? - | KW_ON KW_CONSTRAINT name - ; - returning_clause : KW_RETURNING target_list ; deletestmt - : opt_with_clause? KW_DELETE KW_FROM relation_expr_opt_alias using_clause? where_or_current_clause? returning_clause? - ; - -using_clause - : KW_USING from_list + : with_clause? KW_DELETE KW_FROM relation_expr_opt_alias (KW_USING from_list)? where_or_current_clause? returning_clause? ; lockstmt - : KW_LOCK opt_table? relation_expr_list opt_lock? opt_nowait? - ; - -opt_lock - : KW_IN lock_type KW_MODE - ; - -lock_type - : KW_ACCESS (KW_SHARE | KW_EXCLUSIVE) - | KW_ROW (KW_SHARE | KW_EXCLUSIVE) - | KW_SHARE (KW_UPDATE KW_EXCLUSIVE | KW_ROW KW_EXCLUSIVE)? - | KW_EXCLUSIVE - ; - -opt_nowait - : KW_NOWAIT - ; - -opt_nowait_or_skip - : KW_NOWAIT - | KW_SKIP KW_LOCKED + : KW_LOCK KW_TABLE? relation_expr_list ( + KW_IN ( + (KW_ACCESS | KW_ROW) (KW_SHARE | KW_EXCLUSIVE) + | KW_SHARE (KW_UPDATE KW_EXCLUSIVE | KW_ROW KW_EXCLUSIVE)? + | KW_EXCLUSIVE + ) KW_MODE + )? KW_NOWAIT? ; updatestmt - : opt_with_clause? KW_UPDATE relation_expr_opt_alias KW_SET set_clause_list from_clause? where_or_current_clause? returning_clause? + : with_clause? KW_UPDATE relation_expr_opt_alias KW_SET set_clause_list from_clause? where_or_current_clause? returning_clause? ; set_clause_list @@ -2934,37 +1984,17 @@ set_clause_list ; set_clause - : set_target EQUAL a_expr - | OPEN_PAREN set_target_list CLOSE_PAREN EQUAL ( - KW_ROW? a_expr + : insert_column_item EQUAL expression + | OPEN_PAREN insert_column_list CLOSE_PAREN EQUAL ( + KW_ROW? expression | OPEN_PAREN select_clause CLOSE_PAREN ) ; -set_target - : column_name opt_indirection - ; - -set_target_list - : set_target (COMMA set_target)* - ; - declarecursorstmt - : KW_DECLARE cursor_name cursor_options KW_CURSOR opt_hold KW_FOR selectstmt - ; - -cursor_name - : name - ; - -cursor_options - : (KW_NO KW_SCROLL | KW_SCROLL | KW_BINARY | KW_INSENSITIVE)* - ; - -opt_hold - : - | KW_WITH KW_HOLD - | KW_WITHOUT KW_HOLD + : KW_DECLARE colid (((KW_NO? KW_SCROLL) | KW_BINARY | KW_INSENSITIVE)*) KW_CURSOR ( + (KW_WITH | KW_WITHOUT) KW_HOLD + )? KW_FOR selectstmt ; /* @@ -2983,18 +2013,13 @@ selectstmt ; select_with_parens - : OPEN_PAREN select_no_parens CLOSE_PAREN - | OPEN_PAREN select_with_parens CLOSE_PAREN + : OPEN_PAREN (select_no_parens | select_with_parens) CLOSE_PAREN ; select_no_parens - : select_clause opt_sort_clause? ( - for_locking_clause opt_select_limit? - | select_limit opt_for_locking_clause? - )? - | with_clause select_clause opt_sort_clause? ( - for_locking_clause opt_select_limit? - | select_limit opt_for_locking_clause? + : with_clause? select_clause sort_clause? ( + for_locking_clause select_limit? + | select_limit for_locking_clause? )? ; @@ -3005,34 +2030,23 @@ select_clause simple_select : ( - KW_SELECT (opt_all_clause? into_clause? opt_target_list? | distinct_clause? target_list?) into_clause? from_clause? where_clause? group_clause - ? having_clause? window_clause? + KW_SELECT (KW_ALL? into_clause? | distinct_clause?) sql_expression | values_clause | KW_TABLE relation_expr | select_with_parens set_operator_with_all_or_distinct (simple_select | select_with_parens) ) (set_operator_with_all_or_distinct ( simple_select | select_with_parens))* ; -set_operator - : KW_UNION # union - | KW_INTERSECT # intersect - | KW_EXCEPT # except - ; - set_operator_with_all_or_distinct - : set_operator all_or_distinct? + : (KW_UNION | KW_INTERSECT | KW_EXCEPT) (KW_ALL | KW_DISTINCT)? ; with_clause - : KW_WITH KW_RECURSIVE? cte_list - ; - -cte_list - : common_table_expr (COMMA common_table_expr)* + : KW_WITH KW_RECURSIVE? (common_table_expr (COMMA common_table_expr)*) ; common_table_expr - : name opt_name_list? KW_AS opt_materialized? OPEN_PAREN preparablestmt CLOSE_PAREN search_cluase? cycle_cluase? + : colid opt_column_list? KW_AS (KW_NOT? KW_MATERIALIZED)? OPEN_PAREN preparablestmt CLOSE_PAREN search_cluase? cycle_cluase? ; search_cluase @@ -3040,125 +2054,59 @@ search_cluase ; cycle_cluase - : KW_CYCLE column_list KW_SET column_name (KW_TO name KW_DEFAULT name)? KW_USING column_name - ; - -opt_materialized - : KW_MATERIALIZED - | KW_NOT KW_MATERIALIZED - ; - -opt_with_clause - : with_clause + : KW_CYCLE column_list KW_SET column_name (KW_TO colid KW_DEFAULT colid)? KW_USING column_name ; into_clause - : KW_INTO (opt_strict opttempTableName | into_target) - ; - -opt_strict - : - | KW_STRICT + : KW_INTO (KW_STRICT? opttempTableName | expr_list) ; opttempTableName - : (KW_LOCAL | KW_GLOBAL)? (KW_TEMPORARY | KW_TEMP) opt_table? table_name_create - | KW_UNLOGGED opt_table? table_name_create - | KW_TABLE table_name_create - | table_name_create - ; - -opt_table - : KW_TABLE - ; - -all_or_distinct - : KW_ALL - | KW_DISTINCT + : (KW_LOCAL | KW_GLOBAL)? (KW_TEMPORARY | KW_TEMP) KW_TABLE? table_name_create + | KW_UNLOGGED? KW_TABLE? table_name_create ; distinct_clause - : KW_DISTINCT (KW_ON OPEN_PAREN expr_list CLOSE_PAREN)? - ; - -opt_all_clause - : KW_ALL - ; - -opt_sort_clause - : sort_clause + : KW_DISTINCT (KW_ON execute_param_clause)? ; sort_clause - : KW_ORDER KW_BY sortby_list - ; - -sortby_list - : sortby (COMMA sortby)* + : KW_ORDER KW_BY sortby (COMMA sortby)* ; sortby - : column_expr_noparen (KW_USING qual_all_op | opt_asc_desc)? opt_nulls_order? + : column_expr_noparen (KW_USING qual_all_op | (KW_ASC | KW_DESC))? ( + KW_NULLS (KW_FIRST | KW_LAST) + )? ; select_limit : // https://www.postgresql.org/docs/16/sql-select.html#SQL-LIMIT - limit_clause offset_clause? - | offset_clause fetch_clause? - | fetch_clause offset_clause? - ; - -opt_select_limit - : select_limit + offset_clause fetch_clause? + | (limit_clause | fetch_clause) offset_clause? ; limit_clause - : KW_LIMIT select_limit_value (COMMA select_offset_value)? + : KW_LIMIT (expression | KW_ALL) (COMMA expression)? ; fetch_clause - : KW_FETCH first_or_next ( - select_fetch_first_value row_or_rows (KW_ONLY | KW_WITH KW_TIES) - | row_or_rows (KW_ONLY | KW_WITH KW_TIES) + : KW_FETCH (KW_FIRST | KW_NEXT) ( + select_fetch_first_value? (KW_ROW | KW_ROWS) (KW_ONLY | KW_WITH KW_TIES) ) ; offset_clause - : KW_OFFSET (select_fetch_first_value row_or_rows | select_offset_value) - ; - -select_limit_value - : a_expr - | KW_ALL - ; - -select_offset_value - : a_expr + : KW_OFFSET (select_fetch_first_value (KW_ROW | KW_ROWS) | expression) ; select_fetch_first_value - : PLUS i_or_f_const - | MINUS i_or_f_const - | c_expr - ; - -i_or_f_const - : iconst - | fconst - ; - -row_or_rows - : KW_ROW - | KW_ROWS - ; - -first_or_next - : KW_FIRST - | KW_NEXT + : (PLUS | MINUS) (Integral | Numeric) + | primaryExpression ; group_clause - : KW_GROUP KW_BY (all_or_distinct)? group_by_list + : KW_GROUP KW_BY (KW_ALL | KW_DISTINCT)? group_by_list ; group_by_list @@ -3167,60 +2115,23 @@ group_by_list group_by_item : column_expr_noparen - | empty_grouping_set - | cube_clause - | rollup_clause - | grouping_sets_clause - | OPEN_PAREN column_expr_list_noparen CLOSE_PAREN - ; - -empty_grouping_set - : OPEN_PAREN CLOSE_PAREN - ; - -rollup_clause - : KW_ROLLUP OPEN_PAREN column_expr_list_noparen CLOSE_PAREN - ; - -cube_clause - : KW_CUBE OPEN_PAREN column_expr_list_noparen CLOSE_PAREN - ; - -grouping_sets_clause - : KW_GROUPING KW_SETS OPEN_PAREN group_by_list CLOSE_PAREN - ; - -having_clause - : KW_HAVING a_expr + | OPEN_PAREN CLOSE_PAREN + | (KW_CUBE | KW_ROLLUP)? OPEN_PAREN (column_expr_noparen (COMMA column_expr_noparen)*) CLOSE_PAREN + | KW_GROUPING KW_SETS OPEN_PAREN group_by_list CLOSE_PAREN ; for_locking_clause - : for_locking_items + : ( + KW_FOR ((KW_NO KW_KEY)? KW_UPDATE | KW_KEY? KW_SHARE) (KW_OF qualified_name_list)? ( + KW_NOWAIT + | KW_SKIP KW_LOCKED + )? + )+ | KW_FOR KW_READ KW_ONLY ; -opt_for_locking_clause - : for_locking_clause - ; - -for_locking_items - : for_locking_item+ - ; - -for_locking_item - : for_locking_strength locked_rels_list? opt_nowait_or_skip? - ; - -for_locking_strength - : KW_FOR ((KW_NO KW_KEY)? KW_UPDATE | KW_KEY? KW_SHARE) - ; - -locked_rels_list - : KW_OF qualified_name_list - ; - values_clause - : KW_VALUES OPEN_PAREN expr_list CLOSE_PAREN (COMMA OPEN_PAREN expr_list CLOSE_PAREN)* + : KW_VALUES execute_param_clause (COMMA execute_param_clause)* ; from_clause @@ -3233,20 +2144,17 @@ from_list table_ref : ( - (relation_expr | view_relation_expr) opt_alias_clause? tablesample_clause? - | func_table func_alias_clause? - | xmltable opt_alias_clause? - | select_with_parens opt_alias_clause? - | KW_LATERAL ( - xmltable opt_alias_clause? + (relation_expr | (KW_ONLY? view_name STAR? column_list? where_clause?)) alias_clause? tablesample_clause? + | KW_LATERAL? ( + xmltable alias_clause? | func_table func_alias_clause? - | select_with_parens opt_alias_clause? + | select_with_parens alias_clause? ) | OPEN_PAREN table_ref ( KW_CROSS KW_JOIN table_ref | KW_NATURAL join_type? KW_JOIN table_ref | join_type? KW_JOIN table_ref join_qual - )? CLOSE_PAREN opt_alias_clause? + )? CLOSE_PAREN alias_clause? ) ( KW_CROSS KW_JOIN table_ref | KW_NATURAL join_type? KW_JOIN table_ref @@ -3258,10 +2166,6 @@ alias_clause : KW_AS? colid (OPEN_PAREN name_list CLOSE_PAREN)? ; -opt_alias_clause - : alias_clause - ; - func_alias_clause : alias_clause | (KW_AS colid? | colid) OPEN_PAREN tablefuncelementlist CLOSE_PAREN @@ -3272,22 +2176,18 @@ join_type ; join_qual - : KW_USING OPEN_PAREN column_list CLOSE_PAREN - | KW_ON a_expr + : KW_USING opt_column_list + | KW_ON expression ; relation_expr - : KW_ONLY? table_name STAR? + : truncate_table | KW_ONLY ( table_name | OPEN_PAREN table_name CLOSE_PAREN) | KW_IN KW_SCHEMA (schema_name | KW_CURRENT_SCHEMA) ; -view_relation_expr - : KW_ONLY? view_name STAR? column_list? where_clause? - ; - publication_relation_expr - : KW_TABLE KW_ONLY? table_name STAR? (OPEN_PAREN column_list CLOSE_PAREN)? where_clause? + : KW_TABLE truncate_table (opt_column_list)? where_clause? | KW_TABLE KW_ONLY ( table_name | OPEN_PAREN table_name CLOSE_PAREN) | KW_TABLES KW_IN KW_SCHEMA (schema_name | KW_CURRENT_SCHEMA) ; @@ -3296,41 +2196,25 @@ relation_expr_list : relation_expr (COMMA relation_expr)* ; -publication_relation_expr_list - : publication_relation_expr (COMMA publication_relation_expr)* - ; - relation_expr_opt_alias : relation_expr (KW_AS? colid)? ; tablesample_clause - : KW_TABLESAMPLE function_name OPEN_PAREN expr_list CLOSE_PAREN opt_repeatable_clause? - ; - -opt_repeatable_clause - : KW_REPEATABLE OPEN_PAREN a_expr CLOSE_PAREN + : KW_TABLESAMPLE function_name execute_param_clause ( + KW_REPEATABLE OPEN_PAREN expression CLOSE_PAREN + )? ; func_table - : func_expr_windowless opt_ordinality? - | KW_ROWS KW_FROM OPEN_PAREN rowsfrom_list CLOSE_PAREN opt_ordinality? + : ( + func_expr_windowless + | (KW_ROWS KW_FROM OPEN_PAREN rowsfrom_item (COMMA rowsfrom_item)* CLOSE_PAREN) + ) (KW_WITH KW_ORDINALITY)? ; rowsfrom_item - : func_expr_windowless opt_col_def_list? - ; - -rowsfrom_list - : rowsfrom_item (COMMA rowsfrom_item)* - ; - -opt_col_def_list - : KW_AS OPEN_PAREN tablefuncelementlist CLOSE_PAREN - ; - -opt_ordinality - : KW_WITH KW_ORDINALITY + : func_expr_windowless (KW_AS OPEN_PAREN tablefuncelementlist CLOSE_PAREN)? ; where_clause @@ -3338,11 +2222,7 @@ where_clause ; where_or_current_clause - : KW_WHERE (KW_CURRENT KW_OF cursor_name | a_expr) - ; - -opttablefuncelementlist - : tablefuncelementlist + : KW_WHERE (KW_CURRENT KW_OF colid | expression) ; tablefuncelementlist @@ -3355,72 +2235,44 @@ tablefuncelement xmltable : KW_XMLTABLE OPEN_PAREN ( - c_expr xmlexists_argument KW_COLUMNS xmltable_column_list - | KW_XMLNAMESPACES OPEN_PAREN xml_namespace_list CLOSE_PAREN COMMA c_expr xmlexists_argument KW_COLUMNS xmltable_column_list + (KW_XMLNAMESPACES OPEN_PAREN xml_namespace_el (COMMA xml_namespace_el)* CLOSE_PAREN COMMA)? primaryExpression xmlexists_argument KW_COLUMNS + xmltable_column_el (COMMA xmltable_column_el)* ) CLOSE_PAREN ; -xmltable_column_list - : xmltable_column_el (COMMA xmltable_column_el)* - ; - xmltable_column_el - : colid (typename xmltable_column_option_list? | KW_FOR KW_ORDINALITY) - ; - -xmltable_column_option_list - : xmltable_column_option_el+ - ; - -xmltable_column_option_el - : KW_DEFAULT a_expr - | identifier a_expr - | KW_NOT KW_NULL - | KW_NULL - ; - -xml_namespace_list - : xml_namespace_el (COMMA xml_namespace_el)* + : colid ( + typename (((KW_DEFAULT | identifier) expression | KW_NOT? KW_NULL)+)? + | KW_FOR KW_ORDINALITY + ) ; xml_namespace_el - : b_expr KW_AS collabel - | KW_DEFAULT b_expr + : primaryExpression KW_AS collabel + | KW_DEFAULT primaryExpression ; typename - : KW_SETOF? simpletypename (opt_array_bounds | KW_ARRAY (OPEN_BRACKET iconst CLOSE_BRACKET)?) + : KW_SETOF? simpletypename ( + ((OPEN_BRACKET Integral? CLOSE_BRACKET)*) + | KW_ARRAY (OPEN_BRACKET Integral CLOSE_BRACKET)? + ) | qualified_name PERCENT (KW_ROWTYPE | KW_TYPE) ; -opt_array_bounds - : (OPEN_BRACKET iconst? CLOSE_BRACKET)* - ; - simpletypename - : generictype - | numeric - | bit - | character - | constdatetime - | constinterval ( opt_interval? | OPEN_PAREN iconst CLOSE_PAREN) + : type_function_name attrs? execute_param_clause? + | consttypename + | KW_INTERVAL ( opt_interval? | opt_float) ; consttypename : numeric - | constbit - | constcharacter + | bit + | character | constdatetime ; -generictype - : type_function_name attrs? opt_type_modifiers? - ; - -opt_type_modifiers - : OPEN_PAREN expr_list CLOSE_PAREN - ; - numeric : KW_INT | KW_INTEGER @@ -3429,86 +2281,41 @@ numeric | KW_REAL | KW_FLOAT opt_float? | KW_DOUBLE KW_PRECISION - | KW_DECIMAL opt_type_modifiers? - | KW_DEC opt_type_modifiers? - | KW_NUMERIC opt_type_modifiers? + | (KW_DECIMAL | KW_DEC | KW_NUMERIC) execute_param_clause? | KW_BOOLEAN ; opt_float - : OPEN_PAREN iconst CLOSE_PAREN + : OPEN_PAREN Integral CLOSE_PAREN ; bit - : bitwithlength - | bitwithoutlength - ; - -constbit - : bitwithlength - | bitwithoutlength - ; - -bitwithlength - : KW_BIT opt_varying? OPEN_PAREN expr_list CLOSE_PAREN - ; - -bitwithoutlength - : KW_BIT opt_varying? + : KW_BIT KW_VARYING? execute_param_clause? ; character - : character_c (OPEN_PAREN iconst CLOSE_PAREN)? - ; - -constcharacter - : character_c (OPEN_PAREN iconst CLOSE_PAREN)? - ; - -character_c - : (KW_CHARACTER | KW_CHAR | KW_NCHAR) opt_varying? - | KW_VARCHAR - | KW_NATIONAL (KW_CHARACTER | KW_CHAR) opt_varying? - ; - -opt_varying - : KW_VARYING + : ( + (KW_CHARACTER | KW_CHAR | KW_NCHAR) KW_VARYING? + | KW_VARCHAR + | KW_NATIONAL (KW_CHARACTER | KW_CHAR) KW_VARYING? + ) (opt_float)? ; constdatetime - : (KW_TIMESTAMP | KW_TIME) (OPEN_PAREN iconst CLOSE_PAREN)? opt_timezone? - ; - -constinterval - : KW_INTERVAL - ; - -//TODO with_la was used - -opt_timezone - : KW_WITH KW_TIME KW_ZONE - | KW_WITHOUT KW_TIME KW_ZONE + : (KW_TIMESTAMP | KW_TIME) (opt_float)? ((KW_WITH | KW_WITHOUT) KW_TIME KW_ZONE)? ; opt_interval - : KW_YEAR - | KW_MONTH - | KW_DAY - | KW_HOUR - | KW_MINUTE + : KW_MONTH | interval_second - | KW_YEAR KW_TO KW_MONTH - | KW_DAY KW_TO (KW_HOUR | KW_MINUTE | interval_second) - | KW_HOUR KW_TO (KW_MINUTE | interval_second) - | KW_MINUTE KW_TO interval_second + | KW_YEAR (KW_TO KW_MONTH)? + | KW_DAY (KW_TO (KW_HOUR | KW_MINUTE | interval_second))? + | KW_HOUR (KW_TO (KW_MINUTE | interval_second))? + | KW_MINUTE (KW_TO interval_second)? ; interval_second - : KW_SECOND (OPEN_PAREN iconst CLOSE_PAREN)? - ; - -opt_escape - : KW_ESCAPE a_expr + : KW_SECOND (opt_float)? ; //precendence accroding to Table 4.2. Operator Precedence (highest to lowest) @@ -3516,7 +2323,7 @@ opt_escape //https://www.postgresql.org/docs/12/sql-syntax-lexical.html#SQL-PRECEDENCE /* - original version of a_expr, for info a_expr: c_expr //:: left PostgreSQL-style typecast | a_expr + original version of a_expr, for info a_expr: primaryExpression //:: left PostgreSQL-style typecast | a_expr TYPECAST typename -- 1 | a_expr KW_COLLATE any_name -- 2 | a_expr AT TIME ZONE a_expr-- 3 //right unary plus, unary minus | (PLUS| MINUS) a_expr -- 4 //left exponentiation | a_expr CARET a_expr -- 5 //left multiplication, division, modulo | a_expr (STAR | SLASH | PERCENT) a_expr -- 6 //left @@ -3526,7 +2333,7 @@ opt_escape SYMMETRIC?)) a_expr opt_escape? -- 10 //< > = <= >= <> comparison operators | a_expr (LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) a_expr -- 11 //IS ISNULL NOTNULL IS TRUE, IS FALSE, IS NULL, IS KW_DISTINCT FROM, etc | a_expr IS NOT? ( NULL_P |TRUE_P |FALSE_P |UNKNOWN |KW_DISTINCT - KW_FROM a_expr |OF OPEN_PAREN type_list CLOSE_PAREN |DOCUMENT_P |unicode_normal_form? NORMALIZED ) -- + KW_FROM a_expr |OF OPEN_PAREN type_name_list CLOSE_PAREN |DOCUMENT_P |unicode_normal_form? NORMALIZED ) -- 12 | a_expr (ISNULL|NOTNULL) -- 13 | row OVERLAPS row -- 14 //NOT right logical negation | NOT a_expr -- 15 //AND left logical conjunction | a_expr AND a_expr -- 16 //OR left logical disjunction | a_expr OR a_expr -- 17 | a_expr (LESS_LESS|GREATER_GREATER) a_expr -- 18 | a_expr qual_op -- 19 | @@ -3534,205 +2341,93 @@ opt_escape CLOSE_PAREN) -- 21 | UNIQUE select_with_parens -- 22 | KW_DEFAULT -- 23 ; */ -a_expr - : a_expr_qual - ; - -/*23*/ - -/*moved to c_expr*/ - -/*22*/ - -/*moved to c_expr*/ - -/*19*/ - -a_expr_qual - : a_expr_lessless qual_op? - ; - -/*18*/ - -a_expr_lessless - : a_expr_or ((LESS_LESS | GREATER_GREATER) a_expr_or)* - ; - -/*17*/ - -a_expr_or - : a_expr_and (KW_OR a_expr_and)* - ; - -/*16*/ - -a_expr_and - : a_expr_in (KW_AND a_expr_in)* - ; - -/*20*/ - -a_expr_in - : a_expr_unary_not (KW_NOT? KW_IN in_expr)? - ; - -/*15*/ - -a_expr_unary_not - : KW_NOT? a_expr_isnull - ; - -/*14*/ - -/*moved to c_expr*/ - -/*13*/ - -a_expr_isnull - : a_expr_is_not (KW_ISNULL | KW_NOTNULL)? - ; - -/*12*/ - -a_expr_is_not - : a_expr_compare ( - KW_IS KW_NOT? ( - KW_NULL - | KW_TRUE - | KW_FALSE - | KW_UNKNOWN - | KW_DISTINCT KW_FROM a_expr - | KW_OF OPEN_PAREN type_list CLOSE_PAREN - | KW_DOCUMENT - | unicode_normal_form? KW_NORMALIZED - ) - )? - ; - -/*11*/ - -a_expr_compare - : a_expr_like ( - (LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) a_expr_like - | subquery_Op sub_type (select_with_parens | OPEN_PAREN a_expr CLOSE_PAREN) /*21*/ - )? - ; - -/*10*/ - -a_expr_like - : a_expr_qual_op ( - KW_NOT? (KW_LIKE | KW_ILIKE | KW_SIMILAR KW_TO | KW_BETWEEN KW_SYMMETRIC?) a_expr_qual_op opt_escape? - )? - ; - -/* 8*/ - -a_expr_qual_op - : a_expr_unary_qualop (qual_op a_expr_unary_qualop)* - ; - -/* 9*/ - -a_expr_unary_qualop - : qual_op? a_expr_add - ; - -/* 7*/ - -a_expr_add - : a_expr_mul ((MINUS | PLUS) a_expr_mul)* - ; - -/* 6*/ - -a_expr_mul - : a_expr_caret ((STAR | SLASH | PERCENT) a_expr_caret)* - ; - -/* 5*/ - -a_expr_caret - : a_expr_unary_sign (CARET a_expr)? - ; - -/* 4*/ - -a_expr_unary_sign - : (MINUS | PLUS)? a_expr_at_time_zone /* */ - ; - -/* 3*/ - -a_expr_at_time_zone - : a_expr_collate (KW_AT KW_TIME KW_ZONE a_expr)? - ; - -/* 2*/ - -a_expr_collate - : a_expr_typecast (KW_COLLATE any_name)? - ; - -/* 1*/ - -a_expr_typecast - : c_expr (TYPECAST typename)* +comparisonOperator + : LT + | GT + | EQUAL + | LESS_EQUALS + | GREATER_EQUALS + | NOT_EQUALS ; -b_expr - : c_expr - | b_expr TYPECAST typename - //right unary plus, unary minus - | (PLUS | MINUS) b_expr - //^ left exponentiation - | b_expr CARET b_expr - //* / % left multiplication, division, modulo - | b_expr (STAR | SLASH | PERCENT) b_expr - //+ - left addition, subtraction - | b_expr (PLUS | MINUS) b_expr - //(any other operator) left all other native and user-defined operators - | b_expr qual_op b_expr - //< > = <= >= <> comparison operators - | b_expr ( LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) b_expr - | qual_op b_expr - | b_expr qual_op - //S ISNULL NOTNULL IS TRUE, IS FALSE, IS NULL, IS KW_DISTINCT FROM, etc - | b_expr KW_IS KW_NOT? ( - KW_DISTINCT KW_FROM b_expr - | KW_OF OPEN_PAREN type_list CLOSE_PAREN +expression + : booleanExpression + ; + +booleanExpression + : valueExpression predicate[$valueExpression.ctx]? # predicated + | KW_NOT booleanExpression # logicalNot + | left= booleanExpression operator= KW_AND right= booleanExpression # logicalBinary + | left= booleanExpression operator= KW_OR right= booleanExpression # logicalBinary + ; + +predicate[antlr.ParserRuleContext value] + : comparisonOperator right= valueExpression # comparison + | comparisonOperator subquery_Op sub_type ( + select_with_parens + | OPEN_PAREN expression CLOSE_PAREN + ) # quantifiedComparison + | KW_NOT? KW_BETWEEN lower= valueExpression KW_AND upper= valueExpression # between + | KW_NOT? KW_IN OPEN_PAREN expression (COMMA expression)* CLOSE_PAREN # inList + | KW_NOT? KW_IN select_with_parens # inSubquery + | KW_NOT? (KW_LIKE | KW_ILIKE | KW_SIMILAR KW_TO | KW_BETWEEN KW_SYMMETRIC?) pattern= valueExpression ( + KW_ESCAPE escape= valueExpression + )? # like + | KW_IS KW_NOT? KW_NULL # nullPredicate + | KW_IS KW_NOT? KW_DISTINCT KW_FROM right= valueExpression # distinctFrom + ; + +valueExpression + : primaryExpression # valueExpressionDefault + | valueExpression KW_AT KW_TIME KW_ZONE expression # atTimeZone + | operator= (MINUS | PLUS) valueExpression # arithmeticUnary + | left= valueExpression operator= (STAR | SLASH | PERCENT) right= valueExpression # arithmeticBinary + | left= valueExpression operator= (PLUS | MINUS) right= valueExpression # arithmeticBinary + | left= valueExpression CARET right= valueExpression # concatenation + ; + +primaryExpression + : (KW_EXISTS | KW_UNIQUE) select_with_parens + | KW_ARRAY (select_with_parens | array_expr) + | PARAM opt_indirection + | KW_GROUPING execute_param_clause + | Integral + | Numeric + | BinaryStringConstant + | HexadecimalStringConstant + | function_name (sconst | OPEN_PAREN func_arg_list sort_clause? CLOSE_PAREN sconst) + | consttypename? sconst + | KW_INTERVAL ( sconst opt_interval? | opt_float sconst) + | KW_TRUE + | KW_FALSE + | KW_NULL + | PLSQLVARIABLENAME + | OPEN_PAREN a_expr_in_parens= expression CLOSE_PAREN opt_indirection + | KW_CASE expression? when_clause+ (KW_ELSE expression)? KW_END + | func_expr + | select_with_parens indirection? + | explicit_row + | OPEN_PAREN expression COMMA expr_list CLOSE_PAREN + | row KW_OVERLAPS row + | qualified_name + | primaryExpression TYPECAST typename + | (PLUS | MINUS) primaryExpression + | primaryExpression qual_op primaryExpression? + | primaryExpression mathop primaryExpression + | qual_op primaryExpression + | primaryExpression KW_IS KW_NOT? ( + KW_DISTINCT KW_FROM primaryExpression + | KW_OF prep_type_clause | KW_DOCUMENT ) ; -c_expr - : KW_EXISTS select_with_parens # c_expr_exists - | KW_ARRAY (select_with_parens | array_expr) # c_expr_expr - | PARAM opt_indirection # c_expr_expr - | KW_GROUPING OPEN_PAREN expr_list CLOSE_PAREN # c_expr_expr - | /*22*/ KW_UNIQUE select_with_parens # c_expr_expr - | aexprconst # c_expr_expr - | plsqlvariablename # c_expr_expr - | OPEN_PAREN a_expr_in_parens= a_expr CLOSE_PAREN opt_indirection # c_expr_expr - | case_expr # c_expr_case - | func_expr # c_expr_expr - | select_with_parens indirection? # c_expr_expr - | explicit_row # c_expr_expr - | implicit_row # c_expr_expr - | row KW_OVERLAPS row /* 14*/ # c_expr_expr - | columnref # c_expr_expr - ; - -plsqlvariablename - : PLSQLVARIABLENAME - ; - func_application : function_name ( OPEN_PAREN ( - func_arg_list (COMMA KW_VARIADIC func_arg_expr)? opt_sort_clause? - | KW_VARIADIC func_arg_expr opt_sort_clause? - | (KW_ALL | KW_DISTINCT) func_arg_list opt_sort_clause? + func_arg_list (COMMA KW_VARIADIC func_arg_expr)? sort_clause? + | KW_VARIADIC func_arg_expr sort_clause? + | (KW_ALL | KW_DISTINCT) func_arg_list sort_clause? | STAR | ) CLOSE_PAREN @@ -3740,7 +2435,9 @@ func_application ; func_expr - : func_application within_group_clause? filter_clause? over_clause? + : func_application (KW_WITHIN KW_GROUP OPEN_PAREN sort_clause CLOSE_PAREN)? ( + KW_FILTER OPEN_PAREN KW_WHERE expression CLOSE_PAREN + )? (KW_OVER (window_specification | colid))? | func_expr_common_subexpr ; @@ -3750,53 +2447,39 @@ func_expr_windowless ; func_expr_common_subexpr - : KW_COLLATION KW_FOR OPEN_PAREN a_expr CLOSE_PAREN + : KW_COLLATION KW_FOR OPEN_PAREN expression CLOSE_PAREN | KW_CURRENT_DATE - | KW_CURRENT_TIME (OPEN_PAREN iconst CLOSE_PAREN)? - | KW_CURRENT_TIMESTAMP (OPEN_PAREN iconst CLOSE_PAREN)? - | KW_LOCALTIME (OPEN_PAREN iconst CLOSE_PAREN)? - | KW_LOCALTIMESTAMP (OPEN_PAREN iconst CLOSE_PAREN)? + | (KW_CURRENT_TIME | KW_CURRENT_TIMESTAMP | KW_LOCALTIME | KW_LOCALTIMESTAMP) (opt_float)? | KW_CURRENT_ROLE | KW_CURRENT_USER | KW_SESSION_USER | KW_USER | KW_CURRENT_CATALOG | KW_CURRENT_SCHEMA - | KW_CAST OPEN_PAREN a_expr KW_AS typename CLOSE_PAREN - | KW_EXTRACT OPEN_PAREN extract_list? CLOSE_PAREN - | KW_NORMALIZE OPEN_PAREN a_expr (COMMA unicode_normal_form)? CLOSE_PAREN - | KW_OVERLAY OPEN_PAREN overlay_list CLOSE_PAREN - | KW_POSITION OPEN_PAREN position_list? CLOSE_PAREN + | (KW_CAST | KW_TREAT) OPEN_PAREN expression KW_AS typename CLOSE_PAREN + | KW_EXTRACT OPEN_PAREN (extract_arg KW_FROM expression)? CLOSE_PAREN + | KW_NORMALIZE OPEN_PAREN expression (COMMA unicode_normal_form)? CLOSE_PAREN + | KW_OVERLAY OPEN_PAREN ( + expression KW_PLACING expression KW_FROM expression (KW_FOR expression)? + ) CLOSE_PAREN + | KW_POSITION OPEN_PAREN (primaryExpression KW_IN primaryExpression)? CLOSE_PAREN | KW_SUBSTRING OPEN_PAREN substr_list? CLOSE_PAREN - | KW_TREAT OPEN_PAREN a_expr KW_AS typename CLOSE_PAREN - | KW_TRIM OPEN_PAREN (KW_BOTH | KW_LEADING | KW_TRAILING)? trim_list CLOSE_PAREN - | KW_NULLIF OPEN_PAREN a_expr COMMA a_expr CLOSE_PAREN - | KW_COALESCE OPEN_PAREN expr_list CLOSE_PAREN - | KW_GREATEST OPEN_PAREN expr_list CLOSE_PAREN - | KW_LEAST OPEN_PAREN expr_list CLOSE_PAREN - | KW_XMLCONCAT OPEN_PAREN expr_list CLOSE_PAREN - | KW_XMLELEMENT OPEN_PAREN KW_NAME collabel (COMMA (xml_attributes | expr_list))? CLOSE_PAREN - | KW_XMLEXISTS OPEN_PAREN c_expr xmlexists_argument CLOSE_PAREN + | KW_TRIM OPEN_PAREN (KW_BOTH | KW_LEADING | KW_TRAILING)? ((expression? KW_FROM)? expr_list) CLOSE_PAREN + | KW_NULLIF OPEN_PAREN expression COMMA expression CLOSE_PAREN + | (KW_COALESCE | KW_GREATEST | KW_LEAST | KW_XMLCONCAT) execute_param_clause + | KW_XMLELEMENT OPEN_PAREN KW_NAME collabel ( + COMMA ((KW_XMLATTRIBUTES OPEN_PAREN xml_attribute_list CLOSE_PAREN) | expr_list) + )? CLOSE_PAREN + | KW_XMLEXISTS OPEN_PAREN primaryExpression xmlexists_argument CLOSE_PAREN | KW_XMLFOREST OPEN_PAREN xml_attribute_list CLOSE_PAREN - | KW_XMLPARSE OPEN_PAREN document_or_content a_expr xml_whitespace_option? CLOSE_PAREN - | KW_XMLPI OPEN_PAREN KW_NAME collabel (COMMA a_expr)? CLOSE_PAREN - | KW_XMLROOT OPEN_PAREN KW_XML a_expr COMMA xml_root_version opt_xml_root_standalone? CLOSE_PAREN - | KW_XMLSERIALIZE OPEN_PAREN document_or_content a_expr KW_AS simpletypename CLOSE_PAREN - ; - -xml_root_version - : KW_VERSION a_expr - | KW_VERSION KW_NO KW_VALUE - ; - -opt_xml_root_standalone - : COMMA KW_STANDALONE KW_YES - | COMMA KW_STANDALONE KW_NO - | COMMA KW_STANDALONE KW_NO KW_VALUE - ; - -xml_attributes - : KW_XMLATTRIBUTES OPEN_PAREN xml_attribute_list CLOSE_PAREN + | KW_XMLPARSE OPEN_PAREN document_or_content expression ( + (KW_PRESERVE | KW_STRIP) KW_WHITESPACE + )? CLOSE_PAREN + | KW_XMLPI OPEN_PAREN KW_NAME collabel (COMMA expression)? CLOSE_PAREN + | KW_XMLROOT OPEN_PAREN KW_XML expression COMMA KW_VERSION (( KW_NO KW_VALUE) | expression) ( + COMMA KW_STANDALONE ((KW_NO? KW_VALUE) | KW_YES) + )? CLOSE_PAREN + | KW_XMLSERIALIZE OPEN_PAREN document_or_content expression KW_AS simpletypename CLOSE_PAREN ; xml_attribute_list @@ -3804,7 +2487,7 @@ xml_attribute_list ; xml_attribute_el - : a_expr (KW_AS collabel)? + : expression (KW_AS collabel)? ; document_or_content @@ -3812,36 +2495,16 @@ document_or_content | KW_CONTENT ; -xml_whitespace_option - : KW_PRESERVE KW_WHITESPACE - | KW_STRIP KW_WHITESPACE - ; - xmlexists_argument - : KW_PASSING c_expr - | KW_PASSING c_expr xml_passing_mech - | KW_PASSING xml_passing_mech c_expr - | KW_PASSING xml_passing_mech c_expr xml_passing_mech + : KW_PASSING xml_passing_mech? primaryExpression xml_passing_mech? ; xml_passing_mech : KW_BY (KW_REF | KW_VALUE) ; -within_group_clause - : KW_WITHIN KW_GROUP OPEN_PAREN sort_clause CLOSE_PAREN - ; - -filter_clause - : KW_FILTER OPEN_PAREN KW_WHERE a_expr CLOSE_PAREN - ; - window_clause - : KW_WINDOW window_definition_list - ; - -window_definition_list - : window_definition (COMMA window_definition)* + : KW_WINDOW window_definition (COMMA window_definition)* ; window_definition @@ -3853,51 +2516,29 @@ over_clause ; window_specification - : OPEN_PAREN opt_existing_window_name? opt_partition_clause? opt_sort_clause? opt_frame_clause? CLOSE_PAREN - ; - -opt_existing_window_name - : colid - ; - -opt_partition_clause - : KW_PARTITION KW_BY expr_list + : OPEN_PAREN colid? (KW_PARTITION KW_BY expr_list)? sort_clause? opt_frame_clause? CLOSE_PAREN ; opt_frame_clause - : KW_RANGE frame_extent opt_window_exclusion_clause? - | KW_ROWS frame_extent opt_window_exclusion_clause? - | KW_GROUPS frame_extent opt_window_exclusion_clause? - ; - -frame_extent - : frame_bound - | KW_BETWEEN frame_bound KW_AND frame_bound + : (KW_RANGE | KW_ROWS | KW_GROUPS) ((KW_BETWEEN frame_bound KW_AND)? frame_bound) ( + KW_EXCLUDE (KW_CURRENT KW_ROW | KW_GROUP | KW_TIES | KW_NO KW_OTHERS) + )? ; frame_bound - : KW_UNBOUNDED (KW_PRECEDING | KW_FOLLOWING) + : (KW_UNBOUNDED | expression) (KW_PRECEDING | KW_FOLLOWING) | KW_CURRENT KW_ROW - | a_expr (KW_PRECEDING | KW_FOLLOWING) - ; - -opt_window_exclusion_clause - : KW_EXCLUDE (KW_CURRENT KW_ROW | KW_GROUP | KW_TIES | KW_NO KW_OTHERS) ; row - : KW_ROW OPEN_PAREN expr_list? CLOSE_PAREN - | OPEN_PAREN expr_list COMMA a_expr CLOSE_PAREN + : explicit_row + | OPEN_PAREN expr_list COMMA expression CLOSE_PAREN ; explicit_row : KW_ROW OPEN_PAREN expr_list? CLOSE_PAREN ; -implicit_row - : OPEN_PAREN a_expr COMMA expr_list CLOSE_PAREN - ; - sub_type : KW_ANY | KW_SOME @@ -3935,33 +2576,21 @@ qual_all_op ; subquery_Op - : all_op - | KW_OPERATOR OPEN_PAREN any_operator CLOSE_PAREN - | KW_LIKE - | KW_NOT KW_LIKE - | KW_ILIKE - | KW_NOT KW_ILIKE + : qual_all_op + | KW_NOT? (KW_LIKE | KW_ILIKE) ; expr_list - : a_expr (COMMA a_expr)* - ; - -column_expr_list_noparen - : column_expr_noparen (COMMA column_expr_noparen)* - ; - -column_expr_list - : column_expr (COMMA column_expr)* + : expression (COMMA expression)* ; column_expr - : (OPEN_PAREN a_expr CLOSE_PAREN) + : (OPEN_PAREN expression CLOSE_PAREN) | column_name ; column_expr_noparen - : a_expr + : expression | column_name ; @@ -3970,24 +2599,12 @@ func_arg_list ; func_arg_expr - : a_expr - | param_name (COLON_EQUALS | EQUALS_GREATER) a_expr - ; - -type_list - : typename (COMMA typename)* + : expression + | type_function_name (COLON_EQUALS | EQUALS_GREATER) expression ; array_expr - : OPEN_BRACKET (expr_list | array_expr_list)? CLOSE_BRACKET - ; - -array_expr_list - : array_expr (COMMA array_expr)* - ; - -extract_list - : extract_arg KW_FROM a_expr + : OPEN_BRACKET (expr_list | (array_expr (COMMA array_expr)*))? CLOSE_BRACKET ; extract_arg @@ -4008,65 +2625,20 @@ unicode_normal_form | KW_NFKD ; -overlay_list - : a_expr KW_PLACING a_expr KW_FROM a_expr (KW_FOR a_expr)? - ; - -position_list - : b_expr KW_IN b_expr - ; - substr_list - : a_expr KW_FROM a_expr KW_FOR a_expr - | a_expr KW_FOR a_expr KW_FROM a_expr - | a_expr KW_FROM a_expr - | a_expr KW_FOR a_expr - | a_expr KW_SIMILAR a_expr KW_ESCAPE a_expr + : expression KW_FROM expression (KW_FOR expression)? + | expression KW_FOR expression (KW_FROM expression)? + | expression KW_SIMILAR expression KW_ESCAPE expression | expr_list ; -trim_list - : a_expr KW_FROM expr_list - | KW_FROM expr_list - | expr_list - ; - -in_expr - : select_with_parens # in_expr_select - | OPEN_PAREN expr_list CLOSE_PAREN # in_expr_list - ; - -case_expr - : KW_CASE case_arg? when_clause_list case_default? KW_END - ; - -when_clause_list - : when_clause+ - ; - -when_clause - : KW_WHEN a_expr KW_THEN a_expr - ; - -case_default - : KW_ELSE a_expr - ; - -case_arg - : a_expr - ; - -columnref - : colid indirection? +when_clause + : KW_WHEN expression KW_THEN expression ; indirection_el - : DOT (attr_name | STAR) - | OPEN_BRACKET (a_expr | opt_slice_bound? COLON opt_slice_bound?) CLOSE_BRACKET - ; - -opt_slice_bound - : a_expr + : DOT (collabel | STAR) + | OPEN_BRACKET (expression | expression? COLON expression?) CLOSE_BRACKET ; indirection @@ -4077,10 +2649,6 @@ opt_indirection : indirection_el* ; -opt_target_list - : target_list - ; - target_list : target_el (COMMA target_el)* ; @@ -4106,32 +2674,28 @@ database_nameList : database_name (COMMA database_name)* ; -procedure_name_list - : procedure_name (COMMA procedure_name)* - ; - tablespace_name_create - : colid indirection? # tablespaceNameCreate + : qualified_name # tablespaceNameCreate ; tablespace_name - : colid indirection? # tablespaceName + : qualified_name # tablespaceName ; table_name_create - : colid indirection? # tableNameCreate + : qualified_name # tableNameCreate ; table_name - : colid indirection? # tableName + : qualified_name # tableName ; view_name_create - : colid indirection? # viewNameCreate + : qualified_name # viewNameCreate ; view_name - : colid attrs? # viewName + : any_name # viewName ; qualified_name @@ -4143,19 +2707,19 @@ tablespace_name_list ; name_list - : name (COMMA name)* + : colid (COMMA colid)* ; database_name_create - : colid attrs? # databaseNameCreate + : any_name # databaseNameCreate ; database_name - : colid attrs? # databaseName + : any_name # databaseName ; schema_name - : colid attrs? # schemaName + : any_name # schemaName ; routine_name_create @@ -4177,7 +2741,7 @@ procedure_name_create ; column_name - : colid indirection_el* # columnName + : colid opt_indirection # columnName | {this.shouldMatchEmpty()}? # columnNameMatch ; @@ -4185,18 +2749,6 @@ column_name_create : colid # columnNameCreate ; -name - : colid - ; - -attr_name - : collabel - ; - -file_name - : sconst - ; - function_name_create : type_function_name # functionNameCreate | colid indirection # functionNameCreate @@ -4207,43 +2759,8 @@ function_name | colid indirection # functionName ; -usual_name - : type_usual_name - | colid indirection - ; - -aexprconst - : iconst - | fconst - | sconst - | bconst - | xconst - | function_name (sconst | OPEN_PAREN func_arg_list opt_sort_clause? CLOSE_PAREN sconst) - | consttypename sconst - | constinterval ( sconst opt_interval? | OPEN_PAREN iconst CLOSE_PAREN sconst) - | KW_TRUE - | KW_FALSE - | KW_NULL - ; - -xconst - : HexadecimalStringConstant - ; - -bconst - : BinaryStringConstant - ; - -fconst - : Numeric - ; - -iconst - : Integral - ; - sconst - : anysconst opt_uescape? + : anysconst (KW_UESCAPE anysconst)? ; anysconst @@ -4253,22 +2770,8 @@ anysconst | EscapeStringConstant ; -opt_uescape - : KW_UESCAPE anysconst - ; - signediconst - : iconst - | PLUS iconst - | MINUS iconst - ; - -groupname - : rolespec - ; - -roleid - : rolespec + : (PLUS | MINUS)? Integral ; rolespec @@ -4290,19 +2793,6 @@ colid | plsql_unreserved_keyword ; -index_method_choices - : identifier - ; - -exclude_element - : opt_definition - | (OPEN_PAREN a_expr CLOSE_PAREN) identifier opt_asc_desc? opt_nulls_order? - ; - -index_paramenters - : (KW_WITH reloptions)? optconstablespace? - ; - type_function_name : identifier | unreserved_keyword @@ -4310,18 +2800,6 @@ type_function_name | type_func_name_keyword ; -type_usual_name - : identifier - | unreserved_keyword - | plsql_unreserved_keyword - | type_func_name_keyword - ; - -nonreservedword_column - : column_name - | type_func_name_keyword - ; - nonreservedword : identifier | unreserved_keyword @@ -4330,28 +2808,21 @@ nonreservedword ; collabel - : identifier + : nonreservedword | plsql_unreserved_keyword - | unreserved_keyword - | col_name_keyword - | type_func_name_keyword | reserved_keyword ; identifier - : Identifier opt_uescape? + : Identifier (KW_UESCAPE anysconst)? | sconst | QuotedIdentifier | UnicodeQuotedIdentifier - | plsqlvariablename - | plsqlidentifier + | PLSQLVARIABLENAME + | PLSQLIDENTIFIER | plsql_unreserved_keyword ; -plsqlidentifier - : PLSQLIDENTIFIER - ; - unreserved_keyword : KW_ABORT | KW_ABSOLUTE @@ -4821,144 +3292,30 @@ reserved_keyword | KW_WITH ; -/************************************************************************************************************************************************************/ -/*PL/SQL GRAMMAR */ - -/*PLSQL grammar */ - -/************************************************************************************************************************************************************/ -pl_function - : comp_options pl_block opt_semi - ; - -comp_options - : comp_option* - ; - -comp_option - : sharp KW_OPTION KW_DUMP - | sharp KW_PRINT_STRICT_PARAMS option_value - | sharp KW_VARIABLE_CONFLICT KW_ERROR - | sharp KW_VARIABLE_CONFLICT KW_USE_VARIABLE - | sharp KW_VARIABLE_CONFLICT KW_USE_COLUMN - ; - -sharp - : Operator - ; - -option_value - : sconst - | reserved_keyword - | plsql_unreserved_keyword - | unreserved_keyword - ; - -opt_semi - : - | SEMI - ; - // exception_sect means opt_exception_sect in original grammar, don't be confused! pl_block - : decl_sect KW_BEGIN proc_sect exception_sect KW_END opt_label - ; - -decl_sect - : opt_block_label (decl_start decl_stmts?)? - ; - -decl_start - : KW_DECLARE - ; - -decl_stmts - : decl_stmt+ + : (label_decl? (KW_DECLARE ((decl_statement | KW_DECLARE | label_decl)+)?)?) KW_BEGIN proc_stmt* exception_sect? KW_END any_identifier? ; label_decl : LESS_LESS any_identifier GREATER_GREATER ; -decl_stmt - : decl_statement - | KW_DECLARE - | label_decl - ; - decl_statement - : decl_varname ( - KW_ALIAS KW_FOR decl_aliasitem - | decl_const decl_datatype decl_collate decl_notnull decl_defval - | opt_scrollable KW_CURSOR decl_cursor_args decl_is_for decl_cursor_query + : any_identifier ( + KW_ALIAS KW_FOR (PARAM | colid) + | KW_CONSTANT? typename (opt_collate_clause)? (KW_NOT KW_NULL)? ( + ( assign_operator | KW_DEFAULT) sql_expression + )? + | (KW_NO? KW_SCROLL)? KW_CURSOR ( + OPEN_PAREN decl_cursor_arg (COMMA decl_cursor_arg)* CLOSE_PAREN + )? (KW_IS | KW_FOR) selectstmt ) SEMI ; -opt_scrollable - : - | KW_NO KW_SCROLL - | KW_SCROLL - ; - -decl_cursor_query - : selectstmt - ; - -decl_cursor_args - : - | OPEN_PAREN decl_cursor_arglist CLOSE_PAREN - ; - -decl_cursor_arglist - : decl_cursor_arg (COMMA decl_cursor_arg)* - ; - decl_cursor_arg - : decl_varname decl_datatype - ; - -decl_is_for - : KW_IS - | KW_FOR - ; - -decl_aliasitem - : PARAM - | colid - ; - -decl_varname - : any_identifier - ; - -decl_const - : - | KW_CONSTANT - ; - -decl_datatype - : typename - ; //TODO: $$ = read_datatype(yychar); - -decl_collate - : - | KW_COLLATE any_name - ; - -decl_notnull - : - | KW_NOT KW_NULL - ; - -decl_defval - : - | decl_defkey sql_expression - ; - -decl_defkey - : assign_operator - | KW_DEFAULT + : any_identifier typename ; assign_operator @@ -4966,10 +3323,6 @@ assign_operator | COLON_EQUALS ; -proc_sect - : proc_stmt* - ; - proc_stmt : pl_block SEMI | stmt_return @@ -4977,9 +3330,7 @@ proc_stmt | stmt_assign | stmt_if | stmt_case - | stmt_loop - | stmt_while - | stmt_for + | stmt_loop_while_for | stmt_foreach_a | stmt_exit | stmt_assert @@ -4993,23 +3344,17 @@ proc_stmt | stmt_move | stmt_close | stmt_null - | stmt_commit - | stmt_rollback + | stmt_commit_or_rollback | stmt_set ; stmt_perform - : KW_PERFORM expr_until_semi SEMI + : KW_PERFORM sql_expression SEMI ; stmt_call - : KW_CALL any_identifier (OPEN_PAREN opt_expr_list CLOSE_PAREN SEMI)? - | KW_DO any_identifier OPEN_PAREN opt_expr_list CLOSE_PAREN SEMI - ; - -opt_expr_list - : - | expr_list + : KW_CALL any_identifier (OPEN_PAREN expr_list? CLOSE_PAREN SEMI)? + | KW_DO any_identifier OPEN_PAREN expr_list? CLOSE_PAREN SEMI ; stmt_assign @@ -5017,134 +3362,53 @@ stmt_assign ; stmt_getdiag - : KW_GET getdiag_area_opt KW_DIAGNOSTICS getdiag_list SEMI - ; - -getdiag_area_opt - : - | KW_CURRENT - | KW_STACKED - ; - -getdiag_list - : getdiag_list_item (COMMA getdiag_list_item)* + : KW_GET (KW_CURRENT | KW_STACKED)? KW_DIAGNOSTICS ( + getdiag_list_item (COMMA getdiag_list_item)* + ) SEMI ; getdiag_list_item - : getdiag_target assign_operator getdiag_item - ; - -getdiag_item - : colid - ; - -getdiag_target - : assign_var + : assign_var assign_operator colid ; assign_var - : (any_name | PARAM) (OPEN_BRACKET expr_until_rightbracket CLOSE_BRACKET)* + : (any_name | PARAM) (OPEN_BRACKET expression CLOSE_BRACKET)* ; stmt_if - : KW_IF expr_until_then KW_THEN proc_sect stmt_elsifs stmt_else KW_END KW_IF SEMI - ; - -stmt_elsifs - : (KW_ELSIF a_expr KW_THEN proc_sect)* + : KW_IF sql_expression KW_THEN proc_stmt* ((KW_ELSIF expression KW_THEN proc_stmt*)*) stmt_else? KW_END KW_IF SEMI ; stmt_else - : - | KW_ELSE proc_sect + : KW_ELSE proc_stmt* ; stmt_case - : KW_CASE opt_expr_until_when case_when_list opt_case_else KW_END KW_CASE SEMI - ; - -opt_expr_until_when - : - | sql_expression + : KW_CASE sql_expression? (KW_WHEN expr_list KW_THEN proc_stmt*)+ stmt_else? KW_END KW_CASE SEMI ; -case_when_list - : case_when+ - ; - -case_when - : KW_WHEN expr_list KW_THEN proc_sect - ; - -opt_case_else - : - | KW_ELSE proc_sect - ; - -stmt_loop - : opt_loop_label loop_body - ; - -stmt_while - : opt_loop_label KW_WHILE expr_until_loop loop_body - ; - -stmt_for - : opt_loop_label KW_FOR for_control loop_body +stmt_loop_while_for + : label_decl? ((KW_WHILE expression) | (KW_FOR for_control))? loop_body ; //TODO: rewrite using read_sql_expression logic? for_control - : for_variable KW_IN ( - cursor_name opt_cursor_parameters + : any_name_list KW_IN ( + colid execute_param_clause? | selectstmt | explainstmt - | KW_EXECUTE a_expr opt_for_using_expression - | opt_reverse a_expr DOT_DOT a_expr opt_by_expression + | KW_EXECUTE expression (KW_USING expr_list)? + | KW_REVERSE? expression DOT_DOT expression (KW_BY expression)? ) ; -opt_for_using_expression - : - | KW_USING expr_list - ; - -opt_cursor_parameters - : - | OPEN_PAREN a_expr (COMMA a_expr)* CLOSE_PAREN - ; - -opt_reverse - : - | KW_REVERSE - ; - -opt_by_expression - : - | KW_BY a_expr - ; - -for_variable - : any_name_list - ; - stmt_foreach_a - : opt_loop_label KW_FOREACH for_variable foreach_slice KW_IN KW_ARRAY a_expr loop_body - ; - -foreach_slice - : - | KW_SLICE iconst + : label_decl? KW_FOREACH any_name_list (KW_SLICE Integral)? KW_IN KW_ARRAY expression loop_body ; stmt_exit - : exit_type opt_label opt_exitcond? SEMI - ; - -exit_type - : KW_EXIT - | KW_CONTINUE + : (KW_EXIT | KW_CONTINUE) any_identifier? (KW_WHEN sql_expression)? SEMI ; //todo implement RETURN statement according to initial grammar line 1754 @@ -5152,16 +3416,11 @@ exit_type stmt_return : KW_RETURN ( KW_NEXT sql_expression - | KW_QUERY ( KW_EXECUTE a_expr opt_for_using_expression | selectstmt) - | opt_return_result + | KW_QUERY ( KW_EXECUTE expression KW_USING expr_list | selectstmt) + | sql_expression? ) SEMI ; -opt_return_result - : - | sql_expression - ; - //https://www.postgresql.org/docs/current/plpgsql-errors-and-messages.html //RAISE [ level ] 'format' [, expression [, ... ]] [ USING option = expression [, ... ] ]; @@ -5175,53 +3434,25 @@ opt_return_result //RAISE ; stmt_raise - : KW_RAISE opt_stmt_raise_level? sconst opt_raise_list opt_raise_using SEMI - | KW_RAISE opt_stmt_raise_level? identifier opt_raise_using SEMI - | KW_RAISE opt_stmt_raise_level? KW_SQLSTATE sconst opt_raise_using SEMI - | KW_RAISE opt_stmt_raise_level? opt_raise_using SEMI - | KW_RAISE - ; - -opt_stmt_raise_level - : KW_DEBUG - | KW_LOG - | KW_INFO - | KW_NOTICE - | KW_WARNING - | KW_EXCEPTION - ; - -opt_raise_list - : - | (COMMA a_expr)+ - ; - -opt_raise_using - : - | KW_USING opt_raise_using_elem_list + : KW_RAISE ( + (KW_DEBUG | KW_LOG | KW_INFO | KW_NOTICE | KW_WARNING | KW_EXCEPTION)? ( + identifier + | (KW_SQLSTATE sconst) + | (sconst ((COMMA expression)+)?) + )? (KW_USING (opt_raise_using_elem (COMMA opt_raise_using_elem)*))? SEMI + )? ; opt_raise_using_elem - : identifier EQUAL a_expr - ; - -opt_raise_using_elem_list - : opt_raise_using_elem (COMMA opt_raise_using_elem)* + : identifier EQUAL expression ; -//todo imnplement - stmt_assert - : KW_ASSERT sql_expression opt_stmt_assert_message SEMI - ; - -opt_stmt_assert_message - : - | COMMA sql_expression + : KW_ASSERT sql_expression (COMMA sql_expression)? SEMI ; loop_body - : KW_LOOP proc_sect KW_END KW_LOOP opt_label SEMI + : KW_LOOP proc_stmt* KW_END KW_LOOP any_identifier? SEMI ; //TODO: looks like all other statements like INSERT/SELECT/UPDATE/DELETE are handled here; @@ -5229,10 +3460,7 @@ loop_body //pls take a look at original grammar stmt_execsql - : make_execsql_stmt SEMI - /*K_IMPORT - | K_INSERT | t_word | t_cword - */ + : stmt opt_execute_into? SEMI ; //https://www.postgresql.org/docs/current/plpgsql-statements.html#PLPGSQL-STATEMENTS-SQL-NORESULT @@ -5240,25 +3468,17 @@ stmt_execsql //EXECUTE command-string [ INTO [STRICT] target ] [ USING expression [, ... ] ]; stmt_dynexecute - : KW_EXECUTE a_expr ( - /*this is silly, but i have to time to find nice way to code */ opt_execute_into opt_execute_using - | opt_execute_using opt_execute_into - | + : KW_EXECUTE expression ( + /*this is silly, but i have to time to find nice way to code */ opt_execute_into? ( + KW_USING expr_list + )? + | (KW_USING expr_list)? opt_execute_into? + | //TODO ) SEMI ; -opt_execute_using - : - | KW_USING opt_execute_using_list - ; - -opt_execute_using_list - : a_expr (COMMA a_expr)* - ; - opt_execute_into - : - | KW_INTO KW_STRICT? into_target + : KW_INTO KW_STRICT? expr_list ; //https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING @@ -5273,36 +3493,18 @@ opt_execute_into stmt_open : KW_OPEN ( - cursor_variable opt_scroll_option KW_FOR ( + cursor_variable (KW_NO? KW_SCROLL)? KW_FOR ( selectstmt - | KW_EXECUTE sql_expression opt_open_using + | KW_EXECUTE sql_expression (KW_USING expr_list)? ) - | colid (OPEN_PAREN opt_open_bound_list CLOSE_PAREN)? + | colid ( + OPEN_PAREN (opt_open_bound_list_item (COMMA opt_open_bound_list_item)*) CLOSE_PAREN + )? ) SEMI ; opt_open_bound_list_item - : colid COLON_EQUALS a_expr - | a_expr - ; - -opt_open_bound_list - : opt_open_bound_list_item (COMMA opt_open_bound_list_item)* - ; - -opt_open_using - : - | KW_USING expr_list - ; - -opt_scroll_option - : - | opt_scroll_option_no KW_SCROLL - ; - -opt_scroll_option_no - : - | KW_NO + : (colid COLON_EQUALS)? expression ; //https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING @@ -5310,17 +3512,7 @@ opt_scroll_option_no //FETCH [ direction { KW_FROM | IN } ] cursor INTO target; stmt_fetch - : KW_FETCH direction= opt_fetch_direction? opt_cursor_from cursor_variable KW_INTO into_target SEMI - ; - -into_target - : expr_list - ; - -opt_cursor_from - : - | KW_FROM - | KW_IN + : KW_FETCH direction= opt_fetch_direction? from_in? cursor_variable KW_INTO expr_list SEMI ; opt_fetch_direction @@ -5328,11 +3520,9 @@ opt_fetch_direction | KW_PRIOR | KW_FIRST | KW_LAST - | KW_ABSOLUTE a_expr - | KW_RELATIVE a_expr - | a_expr + | (KW_ABSOLUTE | KW_RELATIVE)? expression | KW_ALL - | (KW_FORWARD | KW_BACKWARD) (a_expr | KW_ALL)? + | (KW_FORWARD | KW_BACKWARD) (expression | KW_ALL)? ; //https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING @@ -5344,44 +3534,34 @@ stmt_move ; mergestmt - : with_clause? KW_MERGE KW_INTO (KW_ONLY)? table_name (STAR)? (KW_AS? colid)? KW_USING data_source KW_ON join_condition merge_when_clause+ + : with_clause? KW_MERGE KW_INTO (KW_ONLY)? table_name (STAR)? (KW_AS? colid)? KW_USING data_source KW_ON expression merge_when_clause+ ; data_source : ((KW_ONLY)? table_name (STAR)? | ( select_no_parens | values_clause)) (KW_AS? colid)? ; -join_condition - : a_expr - ; - merge_when_clause - : KW_WHEN KW_MATCHED (KW_AND a_expr)? KW_THEN (merge_update | KW_DELETE | KW_DO KW_NOTHING) - | KW_WHEN KW_NOT KW_MATCHED (KW_AND a_expr)? KW_THEN (merge_insert | KW_DO KW_NOTHING) + : KW_WHEN KW_MATCHED (KW_AND expression)? KW_THEN (merge_update | KW_DELETE | KW_DO KW_NOTHING) + | KW_WHEN KW_NOT KW_MATCHED (KW_AND expression)? KW_THEN (merge_insert | KW_DO KW_NOTHING) ; merge_insert - : KW_INSERT (OPEN_PAREN column_list CLOSE_PAREN)? ( - KW_OVERRIDING (KW_SYSTEM | KW_USER) KW_VALUE - )? default_values_or_values + : KW_INSERT (opt_column_list)? (KW_OVERRIDING (KW_SYSTEM | KW_USER) KW_VALUE)? default_values_or_values ; merge_update : KW_UPDATE KW_SET ( column_name EQUAL exprofdefault - | OPEN_PAREN column_list CLOSE_PAREN EQUAL OPEN_PAREN exprofdefaultlist CLOSE_PAREN + | opt_column_list EQUAL OPEN_PAREN exprofdefault (COMMA exprofdefault)* CLOSE_PAREN )+ ; default_values_or_values - : KW_VALUES exprofdefaultlist + : KW_VALUES OPEN_PAREN exprofdefault (COMMA exprofdefault)* CLOSE_PAREN | KW_DEFAULT KW_VALUES ; -exprofdefaultlist - : OPEN_PAREN exprofdefault (COMMA exprofdefault)* CLOSE_PAREN - ; - exprofdefault : sortby | KW_DEFAULT @@ -5395,16 +3575,8 @@ stmt_null : KW_NULL SEMI ; -stmt_commit - : KW_COMMIT plsql_opt_transaction_chain? SEMI - ; - -stmt_rollback - : KW_ROLLBACK plsql_opt_transaction_chain? SEMI - ; - -plsql_opt_transaction_chain - : KW_AND KW_NO? KW_CHAIN +stmt_commit_or_rollback + : (KW_COMMIT | KW_ROLLBACK) (KW_AND KW_NO? KW_CHAIN)? SEMI ; stmt_set @@ -5418,20 +3590,7 @@ cursor_variable ; exception_sect - : - | KW_EXCEPTION proc_exceptions - ; - -proc_exceptions - : proc_exception+ - ; - -proc_exception - : KW_WHEN proc_conditions KW_THEN proc_sect - ; - -proc_conditions - : proc_condition (KW_OR proc_condition)* + : KW_EXCEPTION (KW_WHEN (proc_condition (KW_OR proc_condition)*) KW_THEN proc_stmt*)+ ; proc_condition @@ -5439,37 +3598,6 @@ proc_condition | KW_SQLSTATE sconst ; -//expr_until_semi: - -//; - -//expr_until_rightbracket: - -//; - -//expr_until_loop: - -//; - -opt_block_label - : - | label_decl - ; - -opt_loop_label - : - | label_decl - ; - -opt_label - : - | any_identifier - ; - -opt_exitcond - : KW_WHEN expr_until_semi - ; - any_identifier : colid | plsql_unreserved_keyword @@ -5486,23 +3614,18 @@ plsql_unreserved_keyword | KW_CHAIN | KW_CLOSE | KW_COLLATE - //| COLUMN_NAME | KW_COMMIT | KW_CONSTANT | KW_CONSTRAINT - //| CONSTRAINT_NAME | KW_CONTINUE | KW_CURRENT | KW_CURSOR - //| DATATYPE | KW_DEBUG | KW_DEFAULT - //| DETAIL | KW_DIAGNOSTICS | KW_DO | KW_DUMP | KW_ELSIF - //| ERRCODE | KW_ERROR | KW_EXCEPTION | KW_EXIT @@ -5510,17 +3633,11 @@ plsql_unreserved_keyword | KW_FIRST | KW_FORWARD | KW_GET - //| HINT - - //| IMPORT | KW_INFO | KW_INSERT | KW_IS | KW_LAST | KW_LOG - //| MESSAGE - - //| MESSAGE_TEXT | KW_MOVE | KW_NEXT | KW_NO @@ -5528,15 +3645,6 @@ plsql_unreserved_keyword | KW_OPEN | KW_OPTION | KW_PERFORM - //| PG_CONTEXT - - //| PG_DATATYPE_NAME - - //| PG_EXCEPTION_CONTEXT - - //| PG_EXCEPTION_DETAIL - - //| PG_EXCEPTION_HINT | KW_PRINT_STRICT_PARAMS | KW_PRIOR | KW_QUERY @@ -5544,19 +3652,15 @@ plsql_unreserved_keyword | KW_RELATIVE | KW_RESET | KW_RETURN - //| RETURNED_SQLSTATE | KW_REVERSE | KW_ROLLBACK - //| ROW_COUNT | KW_ROWTYPE | KW_SCHEMA - //| SCHEMA_NAME | KW_SCROLL | KW_SET | KW_SLICE | KW_SQLSTATE | KW_STACKED - //| TABLE_NAME | KW_TYPE | KW_USE_COLUMN | KW_USE_VARIABLE @@ -5566,29 +3670,5 @@ plsql_unreserved_keyword ; sql_expression - : opt_target_list? into_clause? from_clause? where_clause? group_clause? having_clause? window_clause? - ; - -expr_until_then - : sql_expression - ; - -expr_until_semi - : sql_expression - ; - -expr_until_rightbracket - : a_expr - ; - -expr_until_loop - : a_expr - ; - -make_execsql_stmt - : stmt opt_returning_clause_into? - ; - -opt_returning_clause_into - : KW_INTO opt_strict into_target + : target_list? into_clause? from_clause? where_clause? group_clause? (KW_HAVING expression)? window_clause? ; \ No newline at end of file diff --git a/src/lib/postgresql/PostgreSqlParser.interp b/src/lib/postgresql/PostgreSqlParser.interp index 24dde746..68bf4dae 100644 --- a/src/lib/postgresql/PostgreSqlParser.interp +++ b/src/lib/postgresql/PostgreSqlParser.interp @@ -1186,31 +1186,22 @@ AfterEscapeStringConstantWithNewlineMode_Continued rule names: program -plsqlroot singleStmt stmt -plsqlconsolecommand callstmt createrolestmt -opt_with -optrolelist -alteroptrolelist alteroptroleelem createoptroleelem createuserstmt alterrolestmt -opt_in_database alterrolesetstmt alterroutinestmt alter_routine_cluase -routine_action_list routine_action creategroupstmt altergroupstmt -add_drop createschemastmt schema_name_create -optschemaeltlist schema_stmt variablesetstmt set_rest @@ -1223,18 +1214,13 @@ iso_level opt_boolean_or_string_column opt_boolean_or_string zone_value -opt_encoding -nonreservedword_or_sconst_column nonreservedword_or_sconst variableresetstmt reset_rest -generic_reset setresetclause functionsetresetclause variableshowstmt constraintssetstmt -constraints_set_list -constraints_set_mode checkpointstmt discardstmt altertablestmt @@ -1249,85 +1235,45 @@ alter_table_cmd alter_column_default opt_drop_behavior opt_collate_clause -alter_using -replica_identity reloptions opt_reloptions -reloption_list reloption_elem -alter_identity_column_option_list -alter_identity_column_option partitionboundspec -hash_partbound_elem -hash_partbound altercompositetypestmt -alter_type_cmds alter_type_cmd closeportalstmt copystmt -copy_from -opt_program -copy_file_name copy_options -copy_opt_list -copy_opt_item -opt_binary -copy_delimiter -opt_using -copy_generic_opt_list copy_generic_opt_elem -copy_generic_opt_arg -copy_generic_opt_arg_list -copy_generic_opt_arg_list_item createstmt opttemp -table_column_list -opttableelementlist opttypedtableelementlist tableelementlist -typedtableelementlist tableelement typedtableelement column_def -compressionCluase -storageCluase -columnOptions -colquallist colconstraint colconstraintelem -nulls_distinct generated_when -deferrable_trigger -initially_trigger -tablelikeclause -tablelikeoptionlist tablelikeoption -tableconstraint constraintelem -opt_no_inherit opt_column_list opt_column_list_create column_list -column_list_create opt_c_include key_match -exclusionconstraintlist exclusionconstraintelem -exclusionwhereclause key_actions key_update key_delete key_action optinherit -optpartitionspec partitionspec -part_params part_elem table_access_method_clause optwith oncommitoption opttablespace -index_paramenters_create optconstablespace existingindex createstatsstmt @@ -1336,184 +1282,92 @@ createasstmt create_as_target opt_with_data creatematviewstmt -create_mv_target -optnolog refreshmatviewstmt createseqstmt alterseqstmt -optseqoptlist -optparenthesizedseqoptlist -seqoptlist seqoptelem -opt_by numericonly -numericonly_list createplangstmt -opt_trusted -handler_name -opt_inline_handler -validator_clause -opt_validator -opt_procedural createtablespacestmt -opttablespaceowner createextensionstmt -create_extension_opt_list -create_extension_opt_item alterextensionstmt -alter_extension_opt_list -alter_extension_opt_item alterextensioncontentsstmt createfdwstmt fdw_option -fdw_options -opt_fdw_options alterfdwstmt create_generic_options -generic_option_list alter_generic_options -alter_generic_option_list alter_generic_option_elem generic_option_elem -generic_option_name -generic_option_arg createforeignserverstmt -opt_type foreign_server_version -opt_foreign_server_version alterforeignserverstmt createforeigntablestmt importforeignschemastmt -import_qualification_type -import_qualification createusermappingstmt -auth_ident alterusermappingstmt createpolicystmt alterpolicystmt alterprocedurestmt -procedure_cluase procedure_action rowsecurityoptionalexpr rowsecurityoptionalwithcheck -rowsecuritydefaulttorole -rowsecurityoptionaltorole -rowsecuritydefaultpermissive -rowsecuritydefaultforcmd -row_security_cmd createamstmt -am_type createtrigstmt triggeractiontime -foreachrow -roworstatment triggerevents triggeroneevent -triggerreferencing -triggertransitions -triggertransition -transitionoldornew -transitionrowortable -transitionrelname -triggerforspec -triggerforopteach -triggerfortype triggerwhen function_or_procedure triggerfuncargs triggerfuncarg -optconstrfromtable -constraintattributespec constraintattributeElem createeventtrigstmt -event_trigger_when_list event_trigger_when_item -event_trigger_value_list altereventtrigstmt -enable_trigger createassertionstmt definestmt definition -def_list def_elem def_arg -old_aggr_definition -old_aggr_list old_aggr_elem -opt_enum_val_list -enum_val_list alterenumstmt opt_if_not_exists createopclassstmt -opclass_item_list opclass_item -opt_default -opt_opfamily -opclass_purpose -opt_recheck createopfamilystmt alteropfamilystmt -opclass_drop_list opclass_drop reassignownedstmt dropstmt -view_nameList object_type_any_name object_type_name -object_type_name_on_any_name any_name_list -relation_column_name -relation_name any_name attrs -type_name_list truncatestmt truncate_table commentstmt -comment_text seclabelstmt -opt_provider -security_label fetchstmt fetch_args from_in -opt_from_in grantstmt revokestmt privileges -beforeprivilegeselectlist beforeprivilegeselect -privilege_list privilege privilege_target grantee_list -grantee -opt_grant_grant_option grantrolestmt revokerolestmt -opt_grant_admin_option -opt_granted_by alterdefaultprivilegesstmt -defacloptionlist -defacloption defaclaction defacl_privilege_target indexstmt -opt_unique -opt_concurrently -opt_index_name -access_method_clause index_params -index_elem_options index_elem -opt_include -index_including_params -opt_collate -opt_class -opt_asc_desc -opt_nulls_order createfunctionstmt -attrilist opt_or_replace func_args func_args_list @@ -1523,77 +1377,44 @@ procedure_with_argtypes_list procedure_with_argtypes function_with_argtypes_list function_with_argtypes -func_args_with_defaults -func_args_with_defaults_list func_arg arg_class -param_name -func_return func_type func_arg_with_default -aggr_arg aggr_args -aggr_args_list aggregate_with_argtypes -aggregate_with_argtypes_list -createfunc_opt_list common_func_opt_item createfunc_opt_item -transform_type_list opt_definition table_func_column -table_func_column_list alterfunctionstmt -alterFunctionTypeClause -alterfunc_opt_list -opt_restrict removefuncstmt removeaggrstmt removeoperstmt oper_argtypes any_operator -operator_with_argtypes_list operator_with_argtypes dostmt -dostmt_opt_list -dostmt_opt_item createcaststmt -cast_context opt_if_exists createtransformstmt -transform_element_list +sql_with_function reindexstmt -reindex_target_type -reindex_target_multitable -reindex_option_list -reindex_option_elem altertblspcstmt renamestmt -opt_set_data alterobjectdependsstmt -opt_no alterobjectschemastmt alteroperatorstmt operator_def_list operator_def_elem -operator_def_arg altertypestmt alterownerstmt createpublicationstmt -opt_publication_for_tables -publication_for_tables alterpublicationstmt createsubscriptionstmt -publication_name_list -publication_name_item altersubscriptionstmt rulestmt -ruleactionlist -ruleactionmulti ruleactionstmt -ruleactionstmtOrEmpty -event -opt_instead notifystmt notify_payload listenstmt @@ -1602,58 +1423,31 @@ transactionstmt opt_transaction transaction_mode_item transaction_mode_list -transaction_mode_list_or_empty -opt_transaction_chain viewstmt -opt_check_option loadstmt createdbstmt -createdb_opt_list -createdb_opt_items createdb_opt_item -createdb_opt_name -opt_equal alterdatabasestmt alterdatabasesetstmt -drop_option_list -drop_option altercollationstmt altersystemstmt createdomainstmt alterdomainstmt -opt_as altertsdictionarystmt altertsconfigurationstmt -any_with createconversionstmt clusterstmt -opt_verbose_list -cluster_index_specification vacuumstmt analyzestmt -vac_analyze_option_list analyze_keyword vac_analyze_option_elem -vac_analyze_option_name -vac_analyze_option_arg -opt_analyze -analyze_options_list analyze_option_elem opt_verbose -opt_skiplock -opt_buffer_usage_limit -opt_full -opt_freeze -opt_name_list vacuum_relation vacuum_relation_list -opt_vacuum_relation_list explainstmt explainablestmt explain_option_list -explain_option_elem -explain_option_name -explain_option_arg preparestmt prep_type_clause preparablestmt @@ -1661,188 +1455,95 @@ executestmt execute_param_clause deallocatestmt insertstmt -insert_target insert_rest -override_kind insert_column_list insert_column_item -opt_on_conflict -opt_conf_expr returning_clause deletestmt -using_clause lockstmt -opt_lock -lock_type -opt_nowait -opt_nowait_or_skip updatestmt set_clause_list set_clause -set_target -set_target_list declarecursorstmt -cursor_name -cursor_options -opt_hold selectstmt select_with_parens select_no_parens select_clause simple_select -set_operator set_operator_with_all_or_distinct with_clause -cte_list common_table_expr search_cluase cycle_cluase -opt_materialized -opt_with_clause into_clause -opt_strict opttempTableName -opt_table -all_or_distinct distinct_clause -opt_all_clause -opt_sort_clause sort_clause -sortby_list sortby select_limit -opt_select_limit limit_clause fetch_clause offset_clause -select_limit_value -select_offset_value select_fetch_first_value -i_or_f_const -row_or_rows -first_or_next group_clause group_by_list group_by_item -empty_grouping_set -rollup_clause -cube_clause -grouping_sets_clause -having_clause for_locking_clause -opt_for_locking_clause -for_locking_items -for_locking_item -for_locking_strength -locked_rels_list values_clause from_clause from_list table_ref alias_clause -opt_alias_clause func_alias_clause join_type join_qual relation_expr -view_relation_expr publication_relation_expr relation_expr_list -publication_relation_expr_list relation_expr_opt_alias tablesample_clause -opt_repeatable_clause func_table rowsfrom_item -rowsfrom_list -opt_col_def_list -opt_ordinality where_clause where_or_current_clause -opttablefuncelementlist tablefuncelementlist tablefuncelement xmltable -xmltable_column_list xmltable_column_el -xmltable_column_option_list -xmltable_column_option_el -xml_namespace_list xml_namespace_el typename -opt_array_bounds simpletypename consttypename -generictype -opt_type_modifiers numeric opt_float bit -constbit -bitwithlength -bitwithoutlength character -constcharacter -character_c -opt_varying constdatetime -constinterval -opt_timezone opt_interval interval_second -opt_escape -a_expr -a_expr_qual -a_expr_lessless -a_expr_or -a_expr_and -a_expr_in -a_expr_unary_not -a_expr_isnull -a_expr_is_not -a_expr_compare -a_expr_like -a_expr_qual_op -a_expr_unary_qualop -a_expr_add -a_expr_mul -a_expr_caret -a_expr_unary_sign -a_expr_at_time_zone -a_expr_collate -a_expr_typecast -b_expr -c_expr -plsqlvariablename +comparisonOperator +expression +booleanExpression +predicate +valueExpression +primaryExpression func_application func_expr func_expr_windowless func_expr_common_subexpr -xml_root_version -opt_xml_root_standalone -xml_attributes xml_attribute_list xml_attribute_el document_or_content -xml_whitespace_option xmlexists_argument xml_passing_mech -within_group_clause -filter_clause window_clause -window_definition_list window_definition over_clause window_specification -opt_existing_window_name -opt_partition_clause opt_frame_clause -frame_extent frame_bound -opt_window_exclusion_clause row explicit_row -implicit_row sub_type all_op mathop @@ -1850,41 +1551,24 @@ qual_op qual_all_op subquery_Op expr_list -column_expr_list_noparen -column_expr_list column_expr column_expr_noparen func_arg_list func_arg_expr -type_list array_expr -array_expr_list -extract_list extract_arg unicode_normal_form -overlay_list -position_list substr_list -trim_list -in_expr -case_expr -when_clause_list when_clause -case_default -case_arg -columnref indirection_el -opt_slice_bound indirection opt_indirection -opt_target_list target_list target_el qualified_name_list table_name_list schema_name_list database_nameList -procedure_name_list tablespace_name_create tablespace_name table_name_create @@ -1903,164 +1587,72 @@ procedure_name procedure_name_create column_name column_name_create -name -attr_name -file_name function_name_create function_name -usual_name -aexprconst -xconst -bconst -fconst -iconst sconst anysconst -opt_uescape signediconst -groupname -roleid rolespec role_list colid -index_method_choices -exclude_element -index_paramenters type_function_name -type_usual_name -nonreservedword_column nonreservedword collabel identifier -plsqlidentifier unreserved_keyword col_name_keyword type_func_name_keyword reserved_keyword -pl_function -comp_options -comp_option -sharp -option_value -opt_semi pl_block -decl_sect -decl_start -decl_stmts label_decl -decl_stmt decl_statement -opt_scrollable -decl_cursor_query -decl_cursor_args -decl_cursor_arglist decl_cursor_arg -decl_is_for -decl_aliasitem -decl_varname -decl_const -decl_datatype -decl_collate -decl_notnull -decl_defval -decl_defkey assign_operator -proc_sect proc_stmt stmt_perform stmt_call -opt_expr_list stmt_assign stmt_getdiag -getdiag_area_opt -getdiag_list getdiag_list_item -getdiag_item -getdiag_target assign_var stmt_if -stmt_elsifs stmt_else stmt_case -opt_expr_until_when -case_when_list -case_when -opt_case_else -stmt_loop -stmt_while -stmt_for +stmt_loop_while_for for_control -opt_for_using_expression -opt_cursor_parameters -opt_reverse -opt_by_expression -for_variable stmt_foreach_a -foreach_slice stmt_exit -exit_type stmt_return -opt_return_result stmt_raise -opt_stmt_raise_level -opt_raise_list -opt_raise_using opt_raise_using_elem -opt_raise_using_elem_list stmt_assert -opt_stmt_assert_message loop_body stmt_execsql stmt_dynexecute -opt_execute_using -opt_execute_using_list opt_execute_into stmt_open opt_open_bound_list_item -opt_open_bound_list -opt_open_using -opt_scroll_option -opt_scroll_option_no stmt_fetch -into_target -opt_cursor_from opt_fetch_direction stmt_move mergestmt data_source -join_condition merge_when_clause merge_insert merge_update default_values_or_values -exprofdefaultlist exprofdefault stmt_close stmt_null -stmt_commit -stmt_rollback -plsql_opt_transaction_chain +stmt_commit_or_rollback stmt_set cursor_variable exception_sect -proc_exceptions -proc_exception -proc_conditions proc_condition -opt_block_label -opt_loop_label -opt_label -opt_exitcond any_identifier plsql_unreserved_keyword sql_expression -expr_until_then -expr_until_semi -expr_until_rightbracket -expr_until_loop -make_execsql_stmt -opt_returning_clause_into atn: -[4, 1, 590, 11834, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, 2, 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, 468, 7, 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, 472, 2, 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, 477, 7, 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, 481, 2, 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, 486, 7, 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, 490, 2, 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, 495, 7, 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, 499, 2, 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, 504, 7, 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, 508, 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, 513, 7, 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, 517, 2, 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, 522, 7, 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, 526, 2, 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, 531, 7, 531, 2, 532, 7, 532, 2, 533, 7, 533, 2, 534, 7, 534, 2, 535, 7, 535, 2, 536, 7, 536, 2, 537, 7, 537, 2, 538, 7, 538, 2, 539, 7, 539, 2, 540, 7, 540, 2, 541, 7, 541, 2, 542, 7, 542, 2, 543, 7, 543, 2, 544, 7, 544, 2, 545, 7, 545, 2, 546, 7, 546, 2, 547, 7, 547, 2, 548, 7, 548, 2, 549, 7, 549, 2, 550, 7, 550, 2, 551, 7, 551, 2, 552, 7, 552, 2, 553, 7, 553, 2, 554, 7, 554, 2, 555, 7, 555, 2, 556, 7, 556, 2, 557, 7, 557, 2, 558, 7, 558, 2, 559, 7, 559, 2, 560, 7, 560, 2, 561, 7, 561, 2, 562, 7, 562, 2, 563, 7, 563, 2, 564, 7, 564, 2, 565, 7, 565, 2, 566, 7, 566, 2, 567, 7, 567, 2, 568, 7, 568, 2, 569, 7, 569, 2, 570, 7, 570, 2, 571, 7, 571, 2, 572, 7, 572, 2, 573, 7, 573, 2, 574, 7, 574, 2, 575, 7, 575, 2, 576, 7, 576, 2, 577, 7, 577, 2, 578, 7, 578, 2, 579, 7, 579, 2, 580, 7, 580, 2, 581, 7, 581, 2, 582, 7, 582, 2, 583, 7, 583, 2, 584, 7, 584, 2, 585, 7, 585, 2, 586, 7, 586, 2, 587, 7, 587, 2, 588, 7, 588, 2, 589, 7, 589, 2, 590, 7, 590, 2, 591, 7, 591, 2, 592, 7, 592, 2, 593, 7, 593, 2, 594, 7, 594, 2, 595, 7, 595, 2, 596, 7, 596, 2, 597, 7, 597, 2, 598, 7, 598, 2, 599, 7, 599, 2, 600, 7, 600, 2, 601, 7, 601, 2, 602, 7, 602, 2, 603, 7, 603, 2, 604, 7, 604, 2, 605, 7, 605, 2, 606, 7, 606, 2, 607, 7, 607, 2, 608, 7, 608, 2, 609, 7, 609, 2, 610, 7, 610, 2, 611, 7, 611, 2, 612, 7, 612, 2, 613, 7, 613, 2, 614, 7, 614, 2, 615, 7, 615, 2, 616, 7, 616, 2, 617, 7, 617, 2, 618, 7, 618, 2, 619, 7, 619, 2, 620, 7, 620, 2, 621, 7, 621, 2, 622, 7, 622, 2, 623, 7, 623, 2, 624, 7, 624, 2, 625, 7, 625, 2, 626, 7, 626, 2, 627, 7, 627, 2, 628, 7, 628, 2, 629, 7, 629, 2, 630, 7, 630, 2, 631, 7, 631, 2, 632, 7, 632, 2, 633, 7, 633, 2, 634, 7, 634, 2, 635, 7, 635, 2, 636, 7, 636, 2, 637, 7, 637, 2, 638, 7, 638, 2, 639, 7, 639, 2, 640, 7, 640, 2, 641, 7, 641, 2, 642, 7, 642, 2, 643, 7, 643, 2, 644, 7, 644, 2, 645, 7, 645, 2, 646, 7, 646, 2, 647, 7, 647, 2, 648, 7, 648, 2, 649, 7, 649, 2, 650, 7, 650, 2, 651, 7, 651, 2, 652, 7, 652, 2, 653, 7, 653, 2, 654, 7, 654, 2, 655, 7, 655, 2, 656, 7, 656, 2, 657, 7, 657, 2, 658, 7, 658, 2, 659, 7, 659, 2, 660, 7, 660, 2, 661, 7, 661, 2, 662, 7, 662, 2, 663, 7, 663, 2, 664, 7, 664, 2, 665, 7, 665, 2, 666, 7, 666, 2, 667, 7, 667, 2, 668, 7, 668, 2, 669, 7, 669, 2, 670, 7, 670, 2, 671, 7, 671, 2, 672, 7, 672, 2, 673, 7, 673, 2, 674, 7, 674, 2, 675, 7, 675, 2, 676, 7, 676, 2, 677, 7, 677, 2, 678, 7, 678, 2, 679, 7, 679, 2, 680, 7, 680, 2, 681, 7, 681, 2, 682, 7, 682, 2, 683, 7, 683, 2, 684, 7, 684, 2, 685, 7, 685, 2, 686, 7, 686, 2, 687, 7, 687, 2, 688, 7, 688, 2, 689, 7, 689, 2, 690, 7, 690, 2, 691, 7, 691, 2, 692, 7, 692, 2, 693, 7, 693, 2, 694, 7, 694, 2, 695, 7, 695, 2, 696, 7, 696, 2, 697, 7, 697, 2, 698, 7, 698, 2, 699, 7, 699, 2, 700, 7, 700, 2, 701, 7, 701, 2, 702, 7, 702, 2, 703, 7, 703, 2, 704, 7, 704, 2, 705, 7, 705, 2, 706, 7, 706, 2, 707, 7, 707, 2, 708, 7, 708, 2, 709, 7, 709, 2, 710, 7, 710, 2, 711, 7, 711, 2, 712, 7, 712, 2, 713, 7, 713, 2, 714, 7, 714, 2, 715, 7, 715, 2, 716, 7, 716, 2, 717, 7, 717, 2, 718, 7, 718, 2, 719, 7, 719, 2, 720, 7, 720, 2, 721, 7, 721, 2, 722, 7, 722, 2, 723, 7, 723, 2, 724, 7, 724, 2, 725, 7, 725, 2, 726, 7, 726, 2, 727, 7, 727, 2, 728, 7, 728, 2, 729, 7, 729, 2, 730, 7, 730, 2, 731, 7, 731, 2, 732, 7, 732, 2, 733, 7, 733, 2, 734, 7, 734, 2, 735, 7, 735, 2, 736, 7, 736, 2, 737, 7, 737, 2, 738, 7, 738, 2, 739, 7, 739, 2, 740, 7, 740, 2, 741, 7, 741, 2, 742, 7, 742, 2, 743, 7, 743, 2, 744, 7, 744, 2, 745, 7, 745, 2, 746, 7, 746, 2, 747, 7, 747, 2, 748, 7, 748, 2, 749, 7, 749, 2, 750, 7, 750, 2, 751, 7, 751, 2, 752, 7, 752, 2, 753, 7, 753, 2, 754, 7, 754, 2, 755, 7, 755, 2, 756, 7, 756, 2, 757, 7, 757, 2, 758, 7, 758, 2, 759, 7, 759, 2, 760, 7, 760, 2, 761, 7, 761, 2, 762, 7, 762, 2, 763, 7, 763, 2, 764, 7, 764, 2, 765, 7, 765, 2, 766, 7, 766, 2, 767, 7, 767, 2, 768, 7, 768, 2, 769, 7, 769, 2, 770, 7, 770, 2, 771, 7, 771, 2, 772, 7, 772, 2, 773, 7, 773, 2, 774, 7, 774, 2, 775, 7, 775, 2, 776, 7, 776, 2, 777, 7, 777, 2, 778, 7, 778, 2, 779, 7, 779, 2, 780, 7, 780, 2, 781, 7, 781, 2, 782, 7, 782, 2, 783, 7, 783, 2, 784, 7, 784, 2, 785, 7, 785, 2, 786, 7, 786, 2, 787, 7, 787, 2, 788, 7, 788, 2, 789, 7, 789, 2, 790, 7, 790, 2, 791, 7, 791, 2, 792, 7, 792, 2, 793, 7, 793, 2, 794, 7, 794, 2, 795, 7, 795, 2, 796, 7, 796, 2, 797, 7, 797, 2, 798, 7, 798, 2, 799, 7, 799, 2, 800, 7, 800, 2, 801, 7, 801, 2, 802, 7, 802, 2, 803, 7, 803, 2, 804, 7, 804, 2, 805, 7, 805, 2, 806, 7, 806, 2, 807, 7, 807, 2, 808, 7, 808, 2, 809, 7, 809, 2, 810, 7, 810, 2, 811, 7, 811, 2, 812, 7, 812, 2, 813, 7, 813, 2, 814, 7, 814, 2, 815, 7, 815, 2, 816, 7, 816, 2, 817, 7, 817, 2, 818, 7, 818, 2, 819, 7, 819, 2, 820, 7, 820, 2, 821, 7, 821, 2, 822, 7, 822, 2, 823, 7, 823, 2, 824, 7, 824, 2, 825, 7, 825, 2, 826, 7, 826, 2, 827, 7, 827, 2, 828, 7, 828, 2, 829, 7, 829, 2, 830, 7, 830, 2, 831, 7, 831, 2, 832, 7, 832, 2, 833, 7, 833, 2, 834, 7, 834, 2, 835, 7, 835, 2, 836, 7, 836, 2, 837, 7, 837, 2, 838, 7, 838, 2, 839, 7, 839, 2, 840, 7, 840, 2, 841, 7, 841, 2, 842, 7, 842, 2, 843, 7, 843, 2, 844, 7, 844, 2, 845, 7, 845, 2, 846, 7, 846, 2, 847, 7, 847, 2, 848, 7, 848, 2, 849, 7, 849, 2, 850, 7, 850, 2, 851, 7, 851, 2, 852, 7, 852, 2, 853, 7, 853, 2, 854, 7, 854, 2, 855, 7, 855, 2, 856, 7, 856, 2, 857, 7, 857, 2, 858, 7, 858, 2, 859, 7, 859, 2, 860, 7, 860, 2, 861, 7, 861, 2, 862, 7, 862, 2, 863, 7, 863, 2, 864, 7, 864, 2, 865, 7, 865, 2, 866, 7, 866, 2, 867, 7, 867, 2, 868, 7, 868, 2, 869, 7, 869, 2, 870, 7, 870, 2, 871, 7, 871, 2, 872, 7, 872, 2, 873, 7, 873, 2, 874, 7, 874, 1, 0, 5, 0, 1752, 8, 0, 10, 0, 12, 0, 1755, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 3, 2, 1763, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 1882, 8, 3, 1, 4, 1, 4, 3, 4, 1886, 8, 4, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 1895, 8, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 5, 8, 1902, 8, 8, 10, 8, 12, 8, 1905, 9, 8, 1, 9, 5, 9, 1908, 8, 9, 10, 9, 12, 9, 1911, 9, 9, 1, 10, 1, 10, 1, 10, 3, 10, 1916, 8, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 1948, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1960, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1966, 8, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 1974, 8, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 1982, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1988, 8, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 1997, 8, 16, 1, 16, 1, 16, 1, 17, 1, 17, 3, 17, 2003, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2015, 8, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 2021, 8, 17, 1, 18, 1, 18, 5, 18, 2025, 8, 18, 10, 18, 12, 18, 2028, 9, 18, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 2034, 8, 19, 1, 19, 1, 19, 3, 19, 2038, 8, 19, 1, 19, 1, 19, 1, 19, 3, 19, 2043, 8, 19, 1, 19, 1, 19, 3, 19, 2047, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 2060, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 2071, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 2077, 8, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 3, 23, 2093, 8, 23, 1, 23, 3, 23, 2096, 8, 23, 1, 23, 1, 23, 1, 23, 3, 23, 2101, 8, 23, 1, 23, 1, 23, 1, 24, 1, 24, 3, 24, 2107, 8, 24, 1, 25, 5, 25, 2110, 8, 25, 10, 25, 12, 25, 2113, 9, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 2121, 8, 26, 1, 27, 1, 27, 3, 27, 2125, 8, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 2137, 8, 28, 1, 29, 1, 29, 3, 29, 2141, 8, 29, 1, 29, 3, 29, 2144, 8, 29, 1, 29, 1, 29, 3, 29, 2148, 8, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 3, 30, 2159, 8, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 3, 30, 2177, 8, 30, 1, 31, 1, 31, 1, 31, 5, 31, 2182, 8, 31, 10, 31, 12, 31, 2185, 9, 31, 1, 32, 1, 32, 1, 32, 5, 32, 2190, 8, 32, 10, 32, 12, 32, 2193, 9, 32, 1, 33, 1, 33, 3, 33, 2197, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 2204, 8, 34, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 2210, 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 2216, 8, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 2223, 8, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 2234, 8, 37, 1, 38, 1, 38, 3, 38, 2238, 8, 38, 1, 39, 1, 39, 3, 39, 2242, 8, 39, 1, 40, 1, 40, 3, 40, 2246, 8, 40, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 2259, 8, 42, 1, 43, 1, 43, 3, 43, 2263, 8, 43, 1, 44, 1, 44, 1, 44, 3, 44, 2268, 8, 44, 1, 45, 1, 45, 1, 45, 3, 45, 2273, 8, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 2285, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 3, 48, 2294, 8, 48, 1, 49, 1, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 3, 52, 2306, 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2311, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2322, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2328, 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2333, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2343, 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2348, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2355, 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2360, 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2365, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2376, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2382, 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2387, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2395, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2404, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2419, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2425, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2431, 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 2436, 8, 52, 1, 53, 1, 53, 1, 53, 5, 53, 2441, 8, 53, 10, 53, 12, 53, 2444, 9, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2455, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 2461, 8, 55, 10, 55, 12, 55, 2464, 9, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 3, 56, 2471, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 2489, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 3, 60, 2498, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2512, 8, 60, 1, 60, 1, 60, 3, 60, 2516, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2531, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2539, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2549, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2589, 8, 60, 1, 60, 3, 60, 2592, 8, 60, 1, 60, 1, 60, 3, 60, 2596, 8, 60, 1, 60, 1, 60, 3, 60, 2600, 8, 60, 1, 60, 3, 60, 2603, 8, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2608, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2615, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2624, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2630, 8, 60, 1, 60, 1, 60, 3, 60, 2634, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2643, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2651, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2660, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2669, 8, 60, 1, 60, 1, 60, 3, 60, 2673, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2680, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2686, 8, 60, 1, 60, 1, 60, 3, 60, 2690, 8, 60, 1, 60, 1, 60, 3, 60, 2694, 8, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2699, 8, 60, 1, 60, 3, 60, 2702, 8, 60, 1, 60, 1, 60, 3, 60, 2706, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2712, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 2719, 8, 61, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 2735, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 5, 68, 2747, 8, 68, 10, 68, 12, 68, 2750, 9, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 2759, 8, 69, 3, 69, 2761, 8, 69, 1, 70, 4, 70, 2764, 8, 70, 11, 70, 12, 70, 2765, 1, 71, 1, 71, 3, 71, 2770, 8, 71, 1, 71, 3, 71, 2773, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2779, 8, 71, 3, 71, 2781, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 2809, 8, 72, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 5, 74, 2817, 8, 74, 10, 74, 12, 74, 2820, 9, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 5, 76, 2830, 8, 76, 10, 76, 12, 76, 2833, 9, 76, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2839, 8, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2844, 8, 77, 1, 77, 1, 77, 3, 77, 2848, 8, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2854, 8, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2859, 8, 77, 1, 77, 3, 77, 2862, 8, 77, 3, 77, 2864, 8, 77, 1, 78, 1, 78, 1, 78, 3, 78, 2869, 8, 78, 1, 79, 1, 79, 3, 79, 2873, 8, 79, 1, 79, 1, 79, 3, 79, 2877, 8, 79, 1, 79, 1, 79, 3, 79, 2881, 8, 79, 1, 79, 1, 79, 3, 79, 2885, 8, 79, 1, 79, 3, 79, 2888, 8, 79, 1, 79, 1, 79, 3, 79, 2892, 8, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 2900, 8, 79, 1, 79, 1, 79, 3, 79, 2904, 8, 79, 1, 79, 1, 79, 3, 79, 2908, 8, 79, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 3, 82, 2917, 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 2924, 8, 83, 1, 84, 5, 84, 2927, 8, 84, 10, 84, 12, 84, 2930, 9, 84, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 2936, 8, 85, 1, 85, 1, 85, 1, 85, 3, 85, 2941, 8, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 2948, 8, 85, 1, 85, 1, 85, 1, 85, 3, 85, 2953, 8, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 2971, 8, 85, 1, 86, 1, 86, 1, 87, 3, 87, 2976, 8, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 5, 89, 2986, 8, 89, 10, 89, 12, 89, 2989, 9, 89, 1, 90, 1, 90, 3, 90, 2993, 8, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 3002, 8, 91, 1, 92, 1, 92, 1, 92, 5, 92, 3007, 8, 92, 10, 92, 12, 92, 3010, 9, 92, 1, 93, 1, 93, 1, 94, 1, 94, 3, 94, 3016, 8, 94, 1, 94, 1, 94, 3, 94, 3020, 8, 94, 1, 94, 1, 94, 1, 94, 3, 94, 3025, 8, 94, 1, 94, 1, 94, 3, 94, 3029, 8, 94, 1, 94, 3, 94, 3032, 8, 94, 1, 94, 3, 94, 3035, 8, 94, 1, 94, 3, 94, 3038, 8, 94, 1, 94, 3, 94, 3041, 8, 94, 1, 94, 3, 94, 3044, 8, 94, 1, 94, 1, 94, 1, 94, 3, 94, 3049, 8, 94, 1, 94, 3, 94, 3052, 8, 94, 1, 94, 3, 94, 3055, 8, 94, 1, 94, 3, 94, 3058, 8, 94, 1, 94, 3, 94, 3061, 8, 94, 1, 94, 3, 94, 3064, 8, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 3070, 8, 94, 1, 94, 1, 94, 3, 94, 3074, 8, 94, 1, 94, 3, 94, 3077, 8, 94, 1, 94, 3, 94, 3080, 8, 94, 1, 94, 3, 94, 3083, 8, 94, 1, 94, 3, 94, 3086, 8, 94, 3, 94, 3088, 8, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 3097, 8, 95, 1, 96, 1, 96, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 5, 99, 3110, 8, 99, 10, 99, 12, 99, 3113, 9, 99, 1, 100, 1, 100, 1, 100, 5, 100, 3118, 8, 100, 10, 100, 12, 100, 3121, 9, 100, 1, 101, 1, 101, 1, 101, 3, 101, 3126, 8, 101, 1, 102, 1, 102, 3, 102, 3130, 8, 102, 1, 103, 1, 103, 1, 103, 3, 103, 3135, 8, 103, 1, 103, 3, 103, 3138, 8, 103, 1, 103, 3, 103, 3141, 8, 103, 1, 103, 1, 103, 3, 103, 3145, 8, 103, 1, 103, 1, 103, 3, 103, 3149, 8, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 3163, 8, 105, 1, 106, 1, 106, 1, 106, 3, 106, 3168, 8, 106, 1, 106, 1, 106, 1, 107, 5, 107, 3173, 8, 107, 10, 107, 12, 107, 3176, 9, 107, 1, 108, 1, 108, 3, 108, 3180, 8, 108, 1, 108, 1, 108, 3, 108, 3184, 8, 108, 1, 108, 3, 108, 3187, 8, 108, 1, 108, 1, 108, 3, 108, 3191, 8, 108, 1, 108, 3, 108, 3194, 8, 108, 3, 108, 3196, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 3203, 8, 109, 1, 109, 3, 109, 3206, 8, 109, 1, 109, 1, 109, 3, 109, 3210, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 3216, 8, 109, 1, 109, 3, 109, 3219, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 3226, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 3235, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 3242, 8, 109, 1, 109, 1, 109, 1, 109, 3, 109, 3247, 8, 109, 1, 109, 3, 109, 3250, 8, 109, 1, 109, 3, 109, 3253, 8, 109, 1, 109, 3, 109, 3256, 8, 109, 1, 110, 1, 110, 3, 110, 3260, 8, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 3, 111, 3267, 8, 111, 1, 112, 1, 112, 1, 112, 3, 112, 3272, 8, 112, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 5, 115, 3283, 8, 115, 10, 115, 12, 115, 3286, 9, 115, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3295, 8, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3308, 8, 118, 1, 118, 3, 118, 3311, 8, 118, 1, 118, 3, 118, 3314, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3321, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3329, 8, 118, 1, 118, 3, 118, 3332, 8, 118, 1, 118, 3, 118, 3335, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3342, 8, 118, 1, 118, 1, 118, 3, 118, 3346, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3352, 8, 118, 1, 118, 3, 118, 3355, 8, 118, 1, 118, 3, 118, 3358, 8, 118, 1, 118, 3, 118, 3361, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3373, 8, 118, 1, 118, 3, 118, 3376, 8, 118, 1, 118, 3, 118, 3379, 8, 118, 1, 118, 1, 118, 3, 118, 3383, 8, 118, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 5, 122, 3399, 8, 122, 10, 122, 12, 122, 3402, 9, 122, 1, 123, 1, 123, 1, 123, 5, 123, 3407, 8, 123, 10, 123, 12, 123, 3410, 9, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 5, 126, 3423, 8, 126, 10, 126, 12, 126, 3426, 9, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 3436, 8, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 3451, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 3468, 8, 132, 3, 132, 3470, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 5, 136, 3489, 8, 136, 10, 136, 12, 136, 3492, 9, 136, 1, 137, 1, 137, 3, 137, 3496, 8, 137, 1, 137, 3, 137, 3499, 8, 137, 1, 137, 1, 137, 3, 137, 3503, 8, 137, 1, 137, 3, 137, 3506, 8, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 3512, 8, 137, 1, 137, 3, 137, 3515, 8, 137, 3, 137, 3517, 8, 137, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 3528, 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 3537, 8, 140, 1, 141, 1, 141, 1, 141, 1, 142, 3, 142, 3543, 8, 142, 1, 142, 3, 142, 3546, 8, 142, 1, 142, 3, 142, 3549, 8, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 3, 145, 3563, 8, 145, 1, 145, 3, 145, 3566, 8, 145, 1, 145, 3, 145, 3569, 8, 145, 1, 145, 1, 145, 1, 145, 3, 145, 3574, 8, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 3, 146, 3582, 8, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 3, 147, 3591, 8, 147, 1, 147, 1, 147, 3, 147, 3595, 8, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 3601, 8, 147, 1, 148, 1, 148, 3, 148, 3605, 8, 148, 1, 148, 3, 148, 3608, 8, 148, 1, 148, 3, 148, 3611, 8, 148, 1, 148, 3, 148, 3614, 8, 148, 1, 148, 3, 148, 3617, 8, 148, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3623, 8, 149, 1, 150, 1, 150, 3, 150, 3627, 8, 150, 1, 150, 1, 150, 1, 150, 3, 150, 3632, 8, 150, 1, 150, 1, 150, 1, 150, 1, 150, 3, 150, 3638, 8, 150, 1, 151, 1, 151, 3, 151, 3642, 8, 151, 1, 151, 3, 151, 3645, 8, 151, 1, 151, 3, 151, 3648, 8, 151, 1, 151, 3, 151, 3651, 8, 151, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 3659, 8, 153, 1, 153, 1, 153, 3, 153, 3663, 8, 153, 1, 154, 1, 154, 3, 154, 3667, 8, 154, 1, 154, 1, 154, 3, 154, 3671, 8, 154, 1, 154, 1, 154, 3, 154, 3675, 8, 154, 1, 155, 1, 155, 1, 155, 3, 155, 3680, 8, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 158, 4, 158, 3692, 8, 158, 11, 158, 12, 158, 3693, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 3703, 8, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 3720, 8, 159, 1, 159, 1, 159, 1, 159, 3, 159, 3725, 8, 159, 1, 159, 3, 159, 3728, 8, 159, 3, 159, 3730, 8, 159, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 3740, 8, 161, 1, 162, 1, 162, 1, 162, 5, 162, 3745, 8, 162, 10, 162, 12, 162, 3748, 9, 162, 1, 163, 1, 163, 3, 163, 3752, 8, 163, 1, 163, 3, 163, 3755, 8, 163, 1, 163, 3, 163, 3758, 8, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 3765, 8, 163, 1, 163, 3, 163, 3768, 8, 163, 3, 163, 3770, 8, 163, 1, 164, 1, 164, 1, 165, 1, 165, 3, 165, 3776, 8, 165, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 3785, 8, 167, 1, 168, 1, 168, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3795, 8, 170, 1, 170, 1, 170, 1, 170, 3, 170, 3800, 8, 170, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 3, 172, 3808, 8, 172, 1, 172, 1, 172, 3, 172, 3812, 8, 172, 1, 172, 1, 172, 1, 173, 5, 173, 3817, 8, 173, 10, 173, 12, 173, 3820, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 3829, 8, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 5, 176, 3838, 8, 176, 10, 176, 12, 176, 3841, 9, 176, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 3948, 8, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 3, 179, 3956, 8, 179, 1, 179, 3, 179, 3959, 8, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 3, 180, 3969, 8, 180, 1, 181, 4, 181, 3972, 8, 181, 11, 181, 12, 181, 3973, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 3984, 8, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 3995, 8, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 5, 185, 4005, 8, 185, 10, 185, 12, 185, 4008, 9, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 5, 187, 4018, 8, 187, 10, 187, 12, 187, 4021, 9, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 3, 188, 4030, 8, 188, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 3, 192, 4042, 8, 192, 1, 192, 1, 192, 3, 192, 4046, 8, 192, 1, 192, 3, 192, 4049, 8, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 3, 192, 4056, 8, 192, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 3, 194, 4064, 8, 194, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 3, 196, 4074, 8, 196, 3, 196, 4076, 8, 196, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, 4082, 8, 197, 1, 197, 1, 197, 1, 197, 3, 197, 4087, 8, 197, 1, 197, 1, 197, 3, 197, 4091, 8, 197, 1, 197, 1, 197, 1, 197, 3, 197, 4096, 8, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, 4102, 8, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, 4109, 8, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, 4115, 8, 197, 3, 197, 4117, 8, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 4124, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 4132, 8, 198, 1, 199, 1, 199, 1, 199, 3, 199, 4137, 8, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 3, 201, 4148, 8, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 3, 201, 4155, 8, 201, 1, 202, 1, 202, 3, 202, 4159, 8, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4176, 8, 204, 1, 204, 3, 204, 4179, 8, 204, 1, 204, 3, 204, 4182, 8, 204, 1, 204, 3, 204, 4185, 8, 204, 1, 204, 3, 204, 4188, 8, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 3, 205, 4196, 8, 205, 1, 205, 3, 205, 4199, 8, 205, 1, 205, 3, 205, 4202, 8, 205, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 4208, 8, 206, 1, 206, 1, 206, 1, 207, 1, 207, 5, 207, 4214, 8, 207, 10, 207, 12, 207, 4217, 9, 207, 1, 207, 3, 207, 4220, 8, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 3, 207, 4232, 8, 207, 1, 207, 1, 207, 1, 207, 1, 207, 3, 207, 4238, 8, 207, 1, 208, 3, 208, 4241, 8, 208, 1, 208, 1, 208, 1, 208, 3, 208, 4246, 8, 208, 1, 208, 1, 208, 3, 208, 4250, 8, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 3, 208, 4257, 8, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 3, 208, 4268, 8, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 4291, 8, 213, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 218, 1, 218, 3, 218, 4311, 8, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 4320, 8, 218, 1, 218, 3, 218, 4323, 8, 218, 1, 218, 3, 218, 4326, 8, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 4336, 8, 218, 1, 218, 3, 218, 4339, 8, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 4348, 8, 218, 1, 218, 1, 218, 3, 218, 4352, 8, 218, 1, 218, 3, 218, 4355, 8, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 4363, 8, 218, 1, 219, 1, 219, 1, 219, 1, 219, 3, 219, 4369, 8, 219, 1, 220, 1, 220, 3, 220, 4373, 8, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 5, 222, 4382, 8, 222, 10, 222, 12, 222, 4385, 9, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 4394, 8, 223, 1, 224, 1, 224, 1, 224, 1, 225, 4, 225, 4400, 8, 225, 11, 225, 12, 225, 4401, 1, 226, 1, 226, 1, 226, 3, 226, 4407, 8, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 228, 1, 228, 1, 229, 1, 229, 1, 230, 1, 230, 3, 230, 4419, 8, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, 234, 1, 234, 3, 234, 4436, 8, 234, 1, 235, 1, 235, 3, 235, 4440, 8, 235, 1, 235, 1, 235, 5, 235, 4444, 8, 235, 10, 235, 12, 235, 4447, 9, 235, 1, 236, 1, 236, 1, 236, 1, 236, 3, 236, 4453, 8, 236, 1, 237, 1, 237, 1, 237, 1, 238, 5, 238, 4459, 8, 238, 10, 238, 12, 238, 4462, 9, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 3, 239, 4475, 8, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 3, 240, 4501, 8, 240, 1, 241, 1, 241, 1, 241, 5, 241, 4506, 8, 241, 10, 241, 12, 241, 4509, 9, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 5, 243, 4520, 8, 243, 10, 243, 12, 243, 4523, 9, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 3, 245, 4533, 8, 245, 1, 245, 3, 245, 4536, 8, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 3, 247, 4549, 8, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 4558, 8, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 4583, 8, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 4594, 8, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 4636, 8, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 4644, 8, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 4650, 8, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 5, 249, 4659, 8, 249, 10, 249, 12, 249, 4662, 9, 249, 1, 250, 1, 250, 1, 250, 3, 250, 4667, 8, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 3, 251, 4675, 8, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 5, 253, 4684, 8, 253, 10, 253, 12, 253, 4687, 9, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 5, 256, 4698, 8, 256, 10, 256, 12, 256, 4701, 9, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 3, 257, 4709, 8, 257, 1, 257, 1, 257, 1, 257, 3, 257, 4714, 8, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 3, 257, 4725, 8, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 3, 259, 4736, 8, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 3, 259, 4744, 8, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 5, 260, 4752, 8, 260, 10, 260, 12, 260, 4755, 9, 260, 1, 261, 1, 261, 1, 261, 1, 261, 3, 261, 4761, 8, 261, 1, 261, 3, 261, 4764, 8, 261, 1, 261, 1, 261, 1, 261, 1, 261, 3, 261, 4770, 8, 261, 1, 261, 3, 261, 4773, 8, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 3, 261, 4788, 8, 261, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 3, 264, 4801, 8, 264, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 3, 267, 4830, 8, 267, 1, 268, 1, 268, 1, 268, 5, 268, 4835, 8, 268, 10, 268, 12, 268, 4838, 9, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 4852, 8, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 271, 1, 271, 1, 271, 3, 271, 4864, 8, 271, 1, 271, 1, 271, 3, 271, 4868, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4873, 8, 271, 1, 271, 1, 271, 3, 271, 4877, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4882, 8, 271, 1, 271, 1, 271, 3, 271, 4886, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4892, 8, 271, 1, 271, 1, 271, 3, 271, 4896, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4901, 8, 271, 1, 271, 1, 271, 3, 271, 4905, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4911, 8, 271, 1, 271, 1, 271, 3, 271, 4915, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4920, 8, 271, 1, 271, 1, 271, 3, 271, 4924, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4929, 8, 271, 1, 271, 1, 271, 3, 271, 4933, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4938, 8, 271, 1, 271, 1, 271, 3, 271, 4942, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4949, 8, 271, 1, 271, 1, 271, 3, 271, 4953, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4960, 8, 271, 1, 271, 1, 271, 3, 271, 4964, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4971, 8, 271, 1, 271, 1, 271, 3, 271, 4975, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4982, 8, 271, 1, 271, 1, 271, 3, 271, 4986, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 4992, 8, 271, 1, 271, 1, 271, 3, 271, 4996, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5002, 8, 271, 1, 271, 1, 271, 3, 271, 5006, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5011, 8, 271, 1, 271, 1, 271, 3, 271, 5015, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5022, 8, 271, 1, 271, 1, 271, 3, 271, 5026, 8, 271, 1, 271, 1, 271, 3, 271, 5030, 8, 271, 1, 271, 1, 271, 3, 271, 5034, 8, 271, 1, 271, 1, 271, 3, 271, 5038, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5043, 8, 271, 1, 271, 1, 271, 3, 271, 5047, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5052, 8, 271, 1, 271, 1, 271, 3, 271, 5056, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5061, 8, 271, 1, 271, 1, 271, 3, 271, 5065, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5070, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5076, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5081, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5087, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5092, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5098, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5103, 8, 271, 1, 271, 1, 271, 3, 271, 5107, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5112, 8, 271, 1, 271, 1, 271, 3, 271, 5116, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5122, 8, 271, 1, 271, 1, 271, 3, 271, 5126, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5131, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5139, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5145, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5151, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5157, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5163, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5170, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5175, 8, 271, 1, 271, 1, 271, 3, 271, 5179, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5184, 8, 271, 1, 271, 1, 271, 3, 271, 5188, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5193, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5199, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5206, 8, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5211, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5218, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5228, 8, 271, 1, 271, 1, 271, 3, 271, 5232, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 3, 271, 5238, 8, 271, 3, 271, 5240, 8, 271, 1, 272, 1, 272, 1, 272, 5, 272, 5245, 8, 272, 10, 272, 12, 272, 5248, 9, 272, 1, 273, 3, 273, 5251, 8, 273, 1, 273, 1, 273, 1, 273, 3, 273, 5256, 8, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 3, 273, 5274, 8, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 5289, 8, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 5307, 8, 274, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 5, 276, 5314, 8, 276, 10, 276, 12, 276, 5317, 9, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 3, 278, 5325, 8, 278, 1, 279, 1, 279, 3, 279, 5329, 8, 279, 1, 280, 1, 280, 4, 280, 5333, 8, 280, 11, 280, 12, 280, 5334, 1, 281, 1, 281, 1, 281, 5, 281, 5340, 8, 281, 10, 281, 12, 281, 5343, 9, 281, 1, 282, 1, 282, 3, 282, 5347, 8, 282, 1, 282, 1, 282, 1, 282, 5, 282, 5352, 8, 282, 10, 282, 12, 282, 5355, 9, 282, 1, 282, 1, 282, 3, 282, 5359, 8, 282, 1, 282, 3, 282, 5362, 8, 282, 1, 283, 3, 283, 5365, 8, 283, 1, 283, 1, 283, 3, 283, 5369, 8, 283, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 3, 284, 5440, 8, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 3, 284, 5536, 8, 284, 1, 285, 1, 285, 3, 285, 5540, 8, 285, 1, 286, 1, 286, 1, 286, 3, 286, 5545, 8, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 3, 286, 5556, 8, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 3, 286, 5567, 8, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 3, 286, 5578, 8, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 3, 286, 5589, 8, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 3, 286, 5600, 8, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 3, 286, 5612, 8, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 3, 286, 5623, 8, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 3, 286, 5634, 8, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 3, 286, 5644, 8, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 3, 286, 5651, 8, 286, 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, 3, 288, 5658, 8, 288, 1, 289, 1, 289, 1, 289, 1, 289, 3, 289, 5664, 8, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5672, 8, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5677, 8, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5682, 8, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5687, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5693, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5700, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5706, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5712, 8, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5717, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5723, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5730, 8, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5735, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5741, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 5748, 8, 290, 1, 290, 3, 290, 5751, 8, 290, 1, 291, 1, 291, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 3, 293, 5764, 8, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 5773, 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 5785, 8, 294, 3, 294, 5787, 8, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 3, 295, 5805, 8, 295, 1, 296, 1, 296, 1, 296, 5, 296, 5810, 8, 296, 10, 296, 12, 296, 5813, 9, 296, 1, 297, 1, 297, 1, 298, 1, 298, 1, 298, 5, 298, 5820, 8, 298, 10, 298, 12, 298, 5823, 9, 298, 1, 299, 1, 299, 3, 299, 5827, 8, 299, 1, 299, 1, 299, 3, 299, 5831, 8, 299, 1, 299, 1, 299, 3, 299, 5835, 8, 299, 1, 299, 1, 299, 3, 299, 5839, 8, 299, 3, 299, 5841, 8, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 3, 300, 5901, 8, 300, 1, 301, 1, 301, 1, 301, 5, 301, 5906, 8, 301, 10, 301, 12, 301, 5909, 9, 301, 1, 302, 1, 302, 1, 302, 3, 302, 5914, 8, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 3, 304, 5925, 8, 304, 1, 304, 3, 304, 5928, 8, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 3, 305, 5935, 8, 305, 1, 305, 3, 305, 5938, 8, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 3, 305, 5948, 8, 305, 1, 305, 3, 305, 5951, 8, 305, 3, 305, 5953, 8, 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 5, 309, 5970, 8, 309, 10, 309, 12, 309, 5973, 9, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 3, 310, 5984, 8, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 5993, 8, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 6002, 8, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 6014, 8, 311, 3, 311, 6016, 8, 311, 1, 312, 1, 312, 1, 313, 1, 313, 3, 313, 6022, 8, 313, 1, 313, 1, 313, 3, 313, 6026, 8, 313, 1, 313, 3, 313, 6029, 8, 313, 1, 313, 3, 313, 6032, 8, 313, 1, 313, 1, 313, 1, 313, 3, 313, 6037, 8, 313, 1, 313, 1, 313, 1, 313, 1, 313, 3, 313, 6043, 8, 313, 1, 313, 3, 313, 6046, 8, 313, 1, 313, 3, 313, 6049, 8, 313, 1, 313, 3, 313, 6052, 8, 313, 1, 313, 3, 313, 6055, 8, 313, 1, 314, 1, 314, 1, 315, 1, 315, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, 318, 5, 318, 6069, 8, 318, 10, 318, 12, 318, 6072, 9, 318, 1, 319, 3, 319, 6075, 8, 319, 1, 319, 3, 319, 6078, 8, 319, 1, 319, 3, 319, 6081, 8, 319, 1, 319, 3, 319, 6084, 8, 319, 1, 319, 3, 319, 6087, 8, 319, 1, 319, 1, 319, 1, 319, 3, 319, 6092, 8, 319, 1, 319, 3, 319, 6095, 8, 319, 3, 319, 6097, 8, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 6110, 8, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, 5, 322, 6120, 8, 322, 10, 322, 12, 322, 6123, 9, 322, 1, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 1, 326, 3, 326, 6136, 8, 326, 1, 327, 1, 327, 3, 327, 6140, 8, 327, 1, 327, 1, 327, 1, 327, 1, 327, 3, 327, 6146, 8, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 3, 327, 6156, 8, 327, 3, 327, 6158, 8, 327, 1, 327, 1, 327, 1, 327, 3, 327, 6163, 8, 327, 1, 328, 1, 328, 1, 328, 1, 328, 5, 328, 6169, 8, 328, 10, 328, 12, 328, 6172, 9, 328, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 3, 330, 6181, 8, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 5, 331, 6188, 8, 331, 10, 331, 12, 331, 6191, 9, 331, 1, 332, 1, 332, 1, 332, 5, 332, 6196, 8, 332, 10, 332, 12, 332, 6199, 9, 332, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 3, 333, 6207, 8, 333, 3, 333, 6209, 8, 333, 1, 334, 1, 334, 1, 334, 5, 334, 6214, 8, 334, 10, 334, 12, 334, 6217, 9, 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 3, 335, 6225, 8, 335, 3, 335, 6227, 8, 335, 1, 336, 1, 336, 1, 336, 5, 336, 6232, 8, 336, 10, 336, 12, 336, 6235, 9, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 3, 337, 6243, 8, 337, 3, 337, 6245, 8, 337, 1, 338, 1, 338, 3, 338, 6249, 8, 338, 1, 338, 1, 338, 1, 339, 1, 339, 1, 339, 5, 339, 6256, 8, 339, 10, 339, 12, 339, 6259, 9, 339, 1, 340, 1, 340, 3, 340, 6263, 8, 340, 1, 340, 1, 340, 1, 340, 1, 340, 3, 340, 6269, 8, 340, 1, 340, 1, 340, 1, 340, 3, 340, 6274, 8, 340, 1, 341, 1, 341, 3, 341, 6278, 8, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6283, 8, 341, 1, 342, 1, 342, 1, 343, 1, 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 3, 344, 6301, 8, 344, 1, 345, 1, 345, 1, 345, 3, 345, 6306, 8, 345, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 3, 347, 6321, 8, 347, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 5, 348, 6328, 8, 348, 10, 348, 12, 348, 6331, 9, 348, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 5, 350, 6339, 8, 350, 10, 350, 12, 350, 6342, 9, 350, 1, 351, 4, 351, 6345, 8, 351, 11, 351, 12, 351, 6346, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 3, 352, 6384, 8, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 3, 353, 6404, 8, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 3, 353, 6411, 8, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 5, 354, 6420, 8, 354, 10, 354, 12, 354, 6423, 9, 354, 1, 355, 1, 355, 1, 355, 1, 356, 1, 356, 1, 356, 1, 357, 1, 357, 1, 357, 5, 357, 6434, 8, 357, 10, 357, 12, 357, 6437, 9, 357, 1, 358, 1, 358, 1, 358, 1, 358, 3, 358, 6443, 8, 358, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 3, 359, 6451, 8, 359, 1, 360, 4, 360, 6454, 8, 360, 11, 360, 12, 360, 6455, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 3, 362, 6463, 8, 362, 1, 362, 1, 362, 3, 362, 6467, 8, 362, 1, 362, 1, 362, 1, 362, 3, 362, 6472, 8, 362, 1, 362, 1, 362, 3, 362, 6476, 8, 362, 1, 362, 1, 362, 1, 362, 3, 362, 6481, 8, 362, 1, 362, 1, 362, 3, 362, 6485, 8, 362, 3, 362, 6487, 8, 362, 1, 363, 1, 363, 1, 363, 3, 363, 6492, 8, 363, 1, 363, 1, 363, 3, 363, 6496, 8, 363, 1, 364, 1, 364, 1, 364, 3, 364, 6501, 8, 364, 1, 364, 1, 364, 3, 364, 6505, 8, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 3, 365, 6529, 8, 365, 1, 366, 1, 366, 1, 366, 5, 366, 6534, 8, 366, 10, 366, 12, 366, 6537, 9, 366, 1, 366, 1, 366, 1, 367, 1, 367, 1, 367, 5, 367, 6544, 8, 367, 10, 367, 12, 367, 6547, 9, 367, 1, 368, 1, 368, 1, 368, 1, 369, 1, 369, 1, 369, 1, 370, 4, 370, 6556, 8, 370, 11, 370, 12, 370, 6557, 1, 371, 1, 371, 1, 371, 3, 371, 6563, 8, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 6576, 8, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 6588, 8, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 6600, 8, 372, 3, 372, 6602, 8, 372, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 6608, 8, 373, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 3, 375, 6615, 8, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 3, 376, 6660, 8, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 3, 377, 6678, 8, 377, 1, 378, 1, 378, 3, 378, 6682, 8, 378, 1, 378, 1, 378, 1, 378, 3, 378, 6687, 8, 378, 1, 378, 3, 378, 6690, 8, 378, 1, 379, 1, 379, 3, 379, 6694, 8, 379, 1, 379, 1, 379, 1, 379, 3, 379, 6699, 8, 379, 1, 379, 1, 379, 1, 379, 3, 379, 6704, 8, 379, 1, 379, 3, 379, 6707, 8, 379, 1, 380, 1, 380, 1, 380, 5, 380, 6712, 8, 380, 10, 380, 12, 380, 6715, 9, 380, 1, 381, 1, 381, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 6731, 8, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6802, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6833, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6887, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6897, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6907, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6918, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6928, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6939, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6949, 8, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6954, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6963, 8, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6968, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6978, 8, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6983, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 6992, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 7005, 8, 383, 1, 383, 1, 383, 1, 383, 3, 383, 7010, 8, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 7122, 8, 383, 3, 383, 7124, 8, 383, 1, 384, 1, 384, 1, 384, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 7133, 8, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 7144, 8, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 7155, 8, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 7168, 8, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 7180, 8, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 7191, 8, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 7198, 8, 385, 1, 386, 1, 386, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 7288, 8, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 7341, 8, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 7351, 8, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 7362, 8, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 7373, 8, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 7387, 8, 387, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 389, 1, 389, 1, 389, 5, 389, 7400, 8, 389, 10, 389, 12, 389, 7403, 9, 389, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 3, 390, 7413, 8, 390, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 3, 391, 7420, 8, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 3, 393, 7474, 8, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 3, 393, 7615, 8, 393, 1, 394, 1, 394, 1, 394, 1, 394, 3, 394, 7621, 8, 394, 1, 394, 3, 394, 7624, 8, 394, 1, 395, 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 3, 396, 7634, 8, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 3, 397, 7674, 8, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 3, 398, 7684, 8, 398, 1, 399, 1, 399, 1, 399, 5, 399, 7689, 8, 399, 10, 399, 12, 399, 7692, 9, 399, 1, 400, 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 7714, 8, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 7723, 8, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 7732, 8, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 7741, 8, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 3, 401, 7774, 8, 401, 1, 402, 1, 402, 3, 402, 7778, 8, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 3, 402, 7788, 8, 402, 1, 402, 1, 402, 3, 402, 7792, 8, 402, 1, 402, 1, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 3, 403, 7802, 8, 403, 1, 404, 3, 404, 7805, 8, 404, 1, 404, 1, 404, 3, 404, 7809, 8, 404, 5, 404, 7811, 8, 404, 10, 404, 12, 404, 7814, 9, 404, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 3, 405, 7821, 8, 405, 1, 406, 1, 406, 1, 407, 1, 407, 1, 408, 1, 408, 1, 409, 1, 409, 1, 409, 3, 409, 7832, 8, 409, 1, 410, 1, 410, 1, 410, 1, 411, 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, 412, 3, 412, 7844, 8, 412, 1, 413, 1, 413, 3, 413, 7848, 8, 413, 1, 413, 3, 413, 7851, 8, 413, 1, 413, 1, 413, 3, 413, 7855, 8, 413, 1, 413, 3, 413, 7858, 8, 413, 1, 413, 1, 413, 1, 413, 3, 413, 7863, 8, 413, 1, 413, 1, 413, 3, 413, 7867, 8, 413, 1, 413, 3, 413, 7870, 8, 413, 1, 413, 1, 413, 1, 413, 1, 413, 3, 413, 7876, 8, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 3, 413, 7887, 8, 413, 1, 413, 3, 413, 7890, 8, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 3, 413, 7897, 8, 413, 1, 413, 1, 413, 3, 413, 7901, 8, 413, 1, 413, 1, 413, 1, 413, 3, 413, 7906, 8, 413, 1, 413, 3, 413, 7909, 8, 413, 3, 413, 7911, 8, 413, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 3, 415, 7925, 8, 415, 1, 416, 1, 416, 3, 416, 7929, 8, 416, 1, 416, 5, 416, 7932, 8, 416, 10, 416, 12, 416, 7935, 9, 416, 1, 417, 1, 417, 1, 418, 1, 418, 3, 418, 7941, 8, 418, 1, 418, 1, 418, 1, 419, 1, 419, 1, 419, 3, 419, 7948, 8, 419, 1, 419, 3, 419, 7951, 8, 419, 1, 419, 1, 419, 1, 419, 3, 419, 7956, 8, 419, 1, 419, 3, 419, 7959, 8, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 3, 419, 7968, 8, 419, 3, 419, 7970, 8, 419, 1, 419, 1, 419, 1, 419, 3, 419, 7975, 8, 419, 1, 420, 1, 420, 3, 420, 7979, 8, 420, 1, 420, 1, 420, 1, 420, 1, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 422, 1, 422, 3, 422, 7991, 8, 422, 1, 422, 3, 422, 7994, 8, 422, 1, 423, 1, 423, 1, 424, 4, 424, 7999, 8, 424, 11, 424, 12, 424, 8000, 1, 425, 1, 425, 3, 425, 8005, 8, 425, 1, 425, 1, 425, 1, 425, 3, 425, 8010, 8, 425, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 3, 426, 8020, 8, 426, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 3, 428, 8030, 8, 428, 1, 428, 3, 428, 8033, 8, 428, 1, 428, 3, 428, 8036, 8, 428, 3, 428, 8038, 8, 428, 1, 429, 1, 429, 1, 429, 1, 429, 3, 429, 8044, 8, 429, 1, 430, 1, 430, 1, 430, 5, 430, 8049, 8, 430, 10, 430, 12, 430, 8052, 9, 430, 1, 431, 1, 431, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 8071, 8, 434, 1, 434, 1, 434, 1, 434, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 3, 435, 8091, 8, 435, 1, 435, 1, 435, 3, 435, 8095, 8, 435, 1, 435, 1, 435, 1, 435, 3, 435, 8100, 8, 435, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 3, 438, 8169, 8, 438, 1, 438, 1, 438, 1, 438, 3, 438, 8174, 8, 438, 1, 439, 1, 439, 1, 440, 1, 440, 3, 440, 8180, 8, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 441, 1, 441, 3, 441, 8193, 8, 441, 1, 441, 1, 441, 3, 441, 8197, 8, 441, 1, 441, 1, 441, 3, 441, 8201, 8, 441, 1, 441, 1, 441, 1, 441, 1, 441, 3, 441, 8207, 8, 441, 3, 441, 8209, 8, 441, 1, 442, 1, 442, 1, 442, 1, 442, 5, 442, 8215, 8, 442, 10, 442, 12, 442, 8218, 9, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 1, 444, 1, 444, 3, 444, 8227, 8, 444, 1, 444, 3, 444, 8230, 8, 444, 1, 444, 3, 444, 8233, 8, 444, 1, 444, 3, 444, 8236, 8, 444, 1, 444, 3, 444, 8239, 8, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 3, 444, 8246, 8, 444, 1, 444, 3, 444, 8249, 8, 444, 3, 444, 8251, 8, 444, 1, 445, 1, 445, 3, 445, 8255, 8, 445, 1, 445, 3, 445, 8258, 8, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 3, 445, 8265, 8, 445, 3, 445, 8267, 8, 445, 1, 446, 1, 446, 1, 446, 5, 446, 8272, 8, 446, 10, 446, 12, 446, 8275, 9, 446, 1, 447, 1, 447, 1, 448, 1, 448, 3, 448, 8281, 8, 448, 1, 449, 1, 449, 3, 449, 8285, 8, 449, 1, 450, 1, 450, 3, 450, 8289, 8, 450, 1, 451, 1, 451, 1, 452, 1, 452, 1, 452, 5, 452, 8296, 8, 452, 10, 452, 12, 452, 8299, 9, 452, 1, 453, 1, 453, 1, 453, 3, 453, 8304, 8, 453, 1, 454, 1, 454, 3, 454, 8308, 8, 454, 1, 455, 1, 455, 3, 455, 8312, 8, 455, 1, 456, 1, 456, 1, 456, 3, 456, 8317, 8, 456, 1, 457, 1, 457, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, 3, 460, 8329, 8, 460, 1, 461, 1, 461, 1, 461, 5, 461, 8334, 8, 461, 10, 461, 12, 461, 8337, 9, 461, 1, 462, 1, 462, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 3, 463, 8346, 8, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 3, 463, 8359, 8, 463, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 3, 464, 8370, 8, 464, 1, 465, 1, 465, 1, 465, 5, 465, 8375, 8, 465, 10, 465, 12, 465, 8378, 9, 465, 1, 466, 1, 466, 3, 466, 8382, 8, 466, 1, 467, 1, 467, 3, 467, 8386, 8, 467, 1, 468, 1, 468, 3, 468, 8390, 8, 468, 1, 469, 1, 469, 1, 469, 3, 469, 8395, 8, 469, 1, 469, 1, 469, 1, 469, 1, 470, 1, 470, 1, 470, 1, 470, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, 8408, 8, 471, 1, 472, 1, 472, 1, 472, 3, 472, 8413, 8, 472, 1, 472, 1, 472, 3, 472, 8417, 8, 472, 1, 472, 1, 472, 3, 472, 8421, 8, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 3, 472, 8428, 8, 472, 1, 472, 3, 472, 8431, 8, 472, 3, 472, 8433, 8, 472, 1, 473, 1, 473, 1, 473, 1, 473, 1, 474, 1, 474, 3, 474, 8441, 8, 474, 1, 474, 1, 474, 3, 474, 8445, 8, 474, 1, 475, 3, 475, 8448, 8, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 3, 475, 8455, 8, 475, 1, 475, 3, 475, 8458, 8, 475, 1, 476, 1, 476, 1, 476, 3, 476, 8463, 8, 476, 1, 477, 1, 477, 1, 477, 1, 477, 3, 477, 8469, 8, 477, 1, 477, 1, 477, 1, 477, 1, 477, 3, 477, 8475, 8, 477, 1, 477, 1, 477, 3, 477, 8479, 8, 477, 1, 478, 1, 478, 1, 479, 1, 479, 1, 479, 5, 479, 8486, 8, 479, 10, 479, 12, 479, 8489, 9, 479, 1, 480, 1, 480, 1, 480, 1, 481, 1, 481, 1, 481, 3, 481, 8497, 8, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 3, 481, 8504, 8, 481, 1, 481, 3, 481, 8507, 8, 481, 1, 482, 1, 482, 1, 482, 1, 482, 3, 482, 8513, 8, 482, 1, 482, 1, 482, 1, 482, 3, 482, 8518, 8, 482, 1, 483, 1, 483, 1, 483, 1, 484, 3, 484, 8524, 8, 484, 1, 484, 1, 484, 1, 484, 1, 484, 3, 484, 8530, 8, 484, 1, 484, 3, 484, 8533, 8, 484, 1, 484, 3, 484, 8536, 8, 484, 1, 485, 1, 485, 1, 485, 1, 486, 1, 486, 3, 486, 8543, 8, 486, 1, 486, 1, 486, 3, 486, 8547, 8, 486, 1, 486, 3, 486, 8550, 8, 486, 1, 487, 1, 487, 1, 487, 1, 487, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 3, 488, 8565, 8, 488, 1, 488, 3, 488, 8568, 8, 488, 1, 489, 1, 489, 1, 490, 1, 490, 1, 490, 3, 490, 8575, 8, 490, 1, 491, 3, 491, 8578, 8, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 3, 491, 8585, 8, 491, 1, 491, 3, 491, 8588, 8, 491, 1, 491, 3, 491, 8591, 8, 491, 1, 492, 1, 492, 1, 492, 5, 492, 8596, 8, 492, 10, 492, 12, 492, 8599, 9, 492, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 3, 493, 8610, 8, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 3, 493, 8617, 8, 493, 3, 493, 8619, 8, 493, 1, 494, 1, 494, 1, 494, 1, 495, 1, 495, 1, 495, 5, 495, 8627, 8, 495, 10, 495, 12, 495, 8630, 9, 495, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 497, 1, 497, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 5, 498, 8647, 8, 498, 10, 498, 12, 498, 8650, 9, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 3, 499, 8657, 8, 499, 1, 500, 1, 500, 3, 500, 8661, 8, 500, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 3, 501, 8671, 8, 501, 1, 502, 1, 502, 3, 502, 8675, 8, 502, 1, 502, 1, 502, 3, 502, 8679, 8, 502, 1, 502, 1, 502, 3, 502, 8683, 8, 502, 3, 502, 8685, 8, 502, 1, 502, 1, 502, 1, 502, 3, 502, 8690, 8, 502, 1, 502, 1, 502, 3, 502, 8694, 8, 502, 1, 502, 1, 502, 3, 502, 8698, 8, 502, 3, 502, 8700, 8, 502, 3, 502, 8702, 8, 502, 1, 503, 1, 503, 3, 503, 8706, 8, 503, 1, 504, 1, 504, 3, 504, 8710, 8, 504, 1, 504, 3, 504, 8713, 8, 504, 1, 504, 3, 504, 8716, 8, 504, 1, 504, 3, 504, 8719, 8, 504, 1, 504, 3, 504, 8722, 8, 504, 3, 504, 8724, 8, 504, 1, 504, 3, 504, 8727, 8, 504, 1, 504, 3, 504, 8730, 8, 504, 1, 504, 3, 504, 8733, 8, 504, 1, 504, 3, 504, 8736, 8, 504, 1, 504, 3, 504, 8739, 8, 504, 1, 504, 3, 504, 8742, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 8751, 8, 504, 3, 504, 8753, 8, 504, 1, 504, 1, 504, 1, 504, 3, 504, 8758, 8, 504, 5, 504, 8760, 8, 504, 10, 504, 12, 504, 8763, 9, 504, 1, 505, 1, 505, 1, 505, 3, 505, 8768, 8, 505, 1, 506, 1, 506, 3, 506, 8772, 8, 506, 1, 507, 1, 507, 3, 507, 8776, 8, 507, 1, 507, 1, 507, 1, 508, 1, 508, 1, 508, 5, 508, 8783, 8, 508, 10, 508, 12, 508, 8786, 9, 508, 1, 509, 1, 509, 3, 509, 8790, 8, 509, 1, 509, 1, 509, 3, 509, 8794, 8, 509, 1, 509, 1, 509, 1, 509, 1, 509, 3, 509, 8800, 8, 509, 1, 509, 3, 509, 8803, 8, 509, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 3, 511, 8822, 8, 511, 1, 511, 1, 511, 1, 511, 1, 512, 1, 512, 1, 512, 3, 512, 8830, 8, 512, 1, 513, 1, 513, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 3, 514, 8839, 8, 514, 1, 515, 1, 515, 3, 515, 8843, 8, 515, 1, 516, 3, 516, 8846, 8, 516, 1, 516, 1, 516, 3, 516, 8850, 8, 516, 1, 516, 1, 516, 1, 516, 3, 516, 8855, 8, 516, 1, 516, 1, 516, 1, 516, 1, 516, 3, 516, 8861, 8, 516, 1, 517, 1, 517, 1, 518, 1, 518, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 3, 519, 8873, 8, 519, 1, 520, 1, 520, 1, 521, 1, 521, 1, 522, 1, 522, 1, 522, 1, 522, 1, 523, 1, 523, 1, 523, 5, 523, 8886, 8, 523, 10, 523, 12, 523, 8889, 9, 523, 1, 524, 1, 524, 1, 524, 1, 524, 3, 524, 8895, 8, 524, 1, 524, 3, 524, 8898, 8, 524, 1, 525, 1, 525, 3, 525, 8902, 8, 525, 1, 525, 1, 525, 3, 525, 8906, 8, 525, 1, 525, 1, 525, 3, 525, 8910, 8, 525, 3, 525, 8912, 8, 525, 1, 526, 1, 526, 1, 527, 1, 527, 1, 527, 1, 527, 3, 527, 8920, 8, 527, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 3, 528, 8929, 8, 528, 1, 528, 1, 528, 1, 528, 1, 528, 3, 528, 8935, 8, 528, 3, 528, 8937, 8, 528, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 3, 529, 8944, 8, 529, 1, 530, 1, 530, 3, 530, 8948, 8, 530, 1, 531, 1, 531, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 3, 532, 8957, 8, 532, 1, 533, 1, 533, 3, 533, 8961, 8, 533, 1, 534, 1, 534, 1, 535, 1, 535, 1, 536, 1, 536, 1, 536, 3, 536, 8970, 8, 536, 1, 536, 1, 536, 1, 537, 1, 537, 1, 537, 5, 537, 8977, 8, 537, 10, 537, 12, 537, 8980, 9, 537, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 3, 538, 8991, 8, 538, 1, 539, 1, 539, 1, 539, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 543, 1, 543, 1, 543, 1, 544, 1, 544, 1, 544, 1, 544, 3, 544, 9019, 8, 544, 1, 545, 1, 545, 1, 546, 4, 546, 9024, 8, 546, 11, 546, 12, 546, 9025, 1, 547, 1, 547, 3, 547, 9030, 8, 547, 1, 547, 3, 547, 9033, 8, 547, 1, 548, 1, 548, 1, 548, 3, 548, 9038, 8, 548, 1, 548, 1, 548, 3, 548, 9042, 8, 548, 1, 548, 3, 548, 9045, 8, 548, 1, 549, 1, 549, 1, 549, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 5, 550, 9059, 8, 550, 10, 550, 12, 550, 9062, 9, 550, 1, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 552, 5, 552, 9070, 8, 552, 10, 552, 12, 552, 9073, 9, 552, 1, 553, 1, 553, 3, 553, 9077, 8, 553, 1, 553, 3, 553, 9080, 8, 553, 1, 553, 3, 553, 9083, 8, 553, 1, 553, 1, 553, 3, 553, 9087, 8, 553, 1, 553, 1, 553, 3, 553, 9091, 8, 553, 1, 553, 1, 553, 3, 553, 9095, 8, 553, 1, 553, 1, 553, 1, 553, 3, 553, 9100, 8, 553, 1, 553, 1, 553, 3, 553, 9104, 8, 553, 1, 553, 1, 553, 3, 553, 9108, 8, 553, 3, 553, 9110, 8, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 9119, 8, 553, 1, 553, 1, 553, 1, 553, 3, 553, 9124, 8, 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 9130, 8, 553, 1, 553, 1, 553, 3, 553, 9134, 8, 553, 3, 553, 9136, 8, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 9143, 8, 553, 1, 553, 1, 553, 1, 553, 3, 553, 9148, 8, 553, 1, 553, 1, 553, 1, 553, 1, 553, 5, 553, 9154, 8, 553, 10, 553, 12, 553, 9157, 9, 553, 1, 554, 3, 554, 9160, 8, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 3, 554, 9167, 8, 554, 1, 555, 1, 555, 1, 556, 1, 556, 1, 556, 3, 556, 9174, 8, 556, 1, 556, 3, 556, 9177, 8, 556, 1, 556, 1, 556, 1, 556, 1, 556, 3, 556, 9183, 8, 556, 1, 557, 1, 557, 3, 557, 9187, 8, 557, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 3, 558, 9196, 8, 558, 1, 559, 3, 559, 9199, 8, 559, 1, 559, 1, 559, 3, 559, 9203, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 9211, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 9217, 8, 559, 3, 559, 9219, 8, 559, 1, 560, 3, 560, 9222, 8, 560, 1, 560, 1, 560, 3, 560, 9226, 8, 560, 1, 560, 3, 560, 9229, 8, 560, 1, 560, 3, 560, 9232, 8, 560, 1, 561, 1, 561, 3, 561, 9236, 8, 561, 1, 561, 1, 561, 3, 561, 9240, 8, 561, 1, 561, 1, 561, 1, 561, 1, 561, 3, 561, 9246, 8, 561, 1, 561, 3, 561, 9249, 8, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 3, 561, 9258, 8, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 3, 561, 9265, 8, 561, 3, 561, 9267, 8, 561, 1, 562, 1, 562, 1, 562, 5, 562, 9272, 8, 562, 10, 562, 12, 562, 9275, 9, 562, 1, 563, 1, 563, 1, 563, 5, 563, 9280, 8, 563, 10, 563, 12, 563, 9283, 9, 563, 1, 564, 1, 564, 3, 564, 9287, 8, 564, 1, 564, 3, 564, 9290, 8, 564, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 3, 565, 9298, 8, 565, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 567, 1, 567, 3, 567, 9307, 8, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 3, 567, 9315, 8, 567, 3, 567, 9317, 8, 567, 1, 568, 1, 568, 3, 568, 9321, 8, 568, 1, 569, 1, 569, 1, 569, 5, 569, 9326, 8, 569, 10, 569, 12, 569, 9329, 9, 569, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 571, 1, 571, 1, 571, 1, 572, 1, 572, 1, 572, 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, 3, 573, 9347, 8, 573, 1, 574, 1, 574, 1, 575, 1, 575, 1, 575, 5, 575, 9354, 8, 575, 10, 575, 12, 575, 9357, 9, 575, 1, 576, 1, 576, 1, 576, 3, 576, 9362, 8, 576, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 3, 577, 9381, 8, 577, 1, 577, 1, 577, 1, 578, 1, 578, 1, 578, 5, 578, 9388, 8, 578, 10, 578, 12, 578, 9391, 9, 578, 1, 579, 1, 579, 1, 579, 3, 579, 9396, 8, 579, 1, 579, 1, 579, 3, 579, 9400, 8, 579, 1, 580, 4, 580, 9403, 8, 580, 11, 580, 12, 580, 9404, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 3, 581, 9415, 8, 581, 1, 582, 1, 582, 1, 582, 5, 582, 9420, 8, 582, 10, 582, 12, 582, 9423, 9, 582, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 3, 583, 9431, 8, 583, 1, 584, 3, 584, 9434, 8, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 3, 584, 9443, 8, 584, 3, 584, 9445, 8, 584, 1, 584, 1, 584, 1, 584, 1, 584, 3, 584, 9451, 8, 584, 1, 585, 1, 585, 3, 585, 9455, 8, 585, 1, 585, 5, 585, 9458, 8, 585, 10, 585, 12, 585, 9461, 9, 585, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 3, 586, 9470, 8, 586, 1, 586, 1, 586, 1, 586, 1, 586, 3, 586, 9476, 8, 586, 3, 586, 9478, 8, 586, 1, 587, 1, 587, 1, 587, 1, 587, 3, 587, 9484, 8, 587, 1, 588, 1, 588, 3, 588, 9488, 8, 588, 1, 588, 3, 588, 9491, 8, 588, 1, 589, 1, 589, 1, 589, 1, 589, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 1, 590, 3, 590, 9504, 8, 590, 1, 590, 1, 590, 1, 590, 1, 590, 3, 590, 9510, 8, 590, 1, 590, 1, 590, 3, 590, 9514, 8, 590, 1, 590, 1, 590, 3, 590, 9518, 8, 590, 1, 590, 3, 590, 9521, 8, 590, 1, 591, 1, 591, 1, 591, 1, 591, 1, 592, 1, 592, 3, 592, 9529, 8, 592, 1, 593, 1, 593, 3, 593, 9533, 8, 593, 1, 594, 1, 594, 3, 594, 9537, 8, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 595, 1, 595, 3, 595, 9545, 8, 595, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 3, 596, 9552, 8, 596, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 3, 597, 9559, 8, 597, 1, 598, 1, 598, 3, 598, 9563, 8, 598, 1, 598, 1, 598, 1, 598, 1, 598, 3, 598, 9569, 8, 598, 3, 598, 9571, 8, 598, 1, 599, 1, 599, 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, 3, 600, 9580, 8, 600, 1, 600, 3, 600, 9583, 8, 600, 1, 601, 1, 601, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 3, 602, 9593, 8, 602, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 9609, 8, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 9615, 8, 603, 1, 603, 1, 603, 1, 603, 3, 603, 9620, 8, 603, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 3, 604, 9627, 8, 604, 1, 605, 1, 605, 1, 605, 1, 606, 1, 606, 1, 607, 1, 607, 3, 607, 9636, 8, 607, 1, 608, 1, 608, 1, 608, 5, 608, 9641, 8, 608, 10, 608, 12, 608, 9644, 9, 608, 1, 609, 1, 609, 1, 609, 5, 609, 9649, 8, 609, 10, 609, 12, 609, 9652, 9, 609, 1, 610, 1, 610, 1, 610, 5, 610, 9657, 8, 610, 10, 610, 12, 610, 9660, 9, 610, 1, 611, 1, 611, 3, 611, 9664, 8, 611, 1, 611, 1, 611, 3, 611, 9668, 8, 611, 1, 612, 3, 612, 9671, 8, 612, 1, 612, 1, 612, 1, 613, 1, 613, 3, 613, 9677, 8, 613, 1, 614, 1, 614, 1, 614, 3, 614, 9682, 8, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 3, 614, 9698, 8, 614, 1, 614, 3, 614, 9701, 8, 614, 3, 614, 9703, 8, 614, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 3, 615, 9715, 8, 615, 3, 615, 9717, 8, 615, 1, 616, 1, 616, 3, 616, 9721, 8, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 3, 616, 9729, 8, 616, 3, 616, 9731, 8, 616, 1, 616, 1, 616, 3, 616, 9735, 8, 616, 3, 616, 9737, 8, 616, 1, 617, 1, 617, 1, 617, 1, 617, 5, 617, 9743, 8, 617, 10, 617, 12, 617, 9746, 9, 617, 1, 618, 3, 618, 9749, 8, 618, 1, 618, 1, 618, 1, 619, 1, 619, 1, 619, 5, 619, 9756, 8, 619, 10, 619, 12, 619, 9759, 9, 619, 1, 620, 1, 620, 1, 620, 5, 620, 9764, 8, 620, 10, 620, 12, 620, 9767, 9, 620, 1, 621, 1, 621, 1, 621, 3, 621, 9772, 8, 621, 1, 622, 3, 622, 9775, 8, 622, 1, 622, 1, 622, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 3, 623, 9784, 8, 623, 1, 624, 1, 624, 1, 624, 3, 624, 9789, 8, 624, 1, 625, 1, 625, 1, 625, 5, 625, 9794, 8, 625, 10, 625, 12, 625, 9797, 9, 625, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 3, 626, 9806, 8, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 3, 626, 9832, 8, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 3, 626, 9843, 8, 626, 5, 626, 9845, 8, 626, 10, 626, 12, 626, 9848, 9, 626, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 3, 627, 9855, 8, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 3, 627, 9877, 8, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 3, 627, 9886, 8, 627, 1, 628, 1, 628, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 3, 629, 9896, 8, 629, 1, 629, 3, 629, 9899, 8, 629, 1, 629, 1, 629, 1, 629, 3, 629, 9904, 8, 629, 1, 629, 1, 629, 1, 629, 3, 629, 9909, 8, 629, 1, 629, 1, 629, 3, 629, 9913, 8, 629, 1, 629, 3, 629, 9916, 8, 629, 1, 630, 1, 630, 3, 630, 9920, 8, 630, 1, 630, 3, 630, 9923, 8, 630, 1, 630, 3, 630, 9926, 8, 630, 1, 630, 3, 630, 9929, 8, 630, 1, 631, 1, 631, 3, 631, 9933, 8, 631, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 9947, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 9954, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 9961, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 9968, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 9986, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 9994, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 10006, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 10012, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 10025, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 10064, 8, 632, 3, 632, 10066, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 10086, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 10096, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 10107, 8, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 10119, 8, 632, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 3, 633, 10126, 8, 633, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 3, 634, 10138, 8, 634, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 636, 1, 636, 1, 636, 5, 636, 10148, 8, 636, 10, 636, 12, 636, 10151, 9, 636, 1, 637, 1, 637, 1, 637, 3, 637, 10156, 8, 637, 1, 638, 1, 638, 1, 639, 1, 639, 1, 639, 1, 639, 3, 639, 10164, 8, 639, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 3, 640, 10181, 8, 640, 1, 641, 1, 641, 1, 641, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 644, 1, 644, 1, 644, 1, 645, 1, 645, 1, 645, 5, 645, 10204, 8, 645, 10, 645, 12, 645, 10207, 9, 645, 1, 646, 1, 646, 1, 646, 1, 646, 1, 647, 1, 647, 1, 647, 3, 647, 10216, 8, 647, 1, 648, 1, 648, 3, 648, 10220, 8, 648, 1, 648, 3, 648, 10223, 8, 648, 1, 648, 3, 648, 10226, 8, 648, 1, 648, 3, 648, 10229, 8, 648, 1, 648, 1, 648, 1, 649, 1, 649, 1, 650, 1, 650, 1, 650, 1, 650, 1, 651, 1, 651, 1, 651, 3, 651, 10242, 8, 651, 1, 651, 1, 651, 1, 651, 3, 651, 10247, 8, 651, 1, 651, 1, 651, 1, 651, 3, 651, 10252, 8, 651, 3, 651, 10254, 8, 651, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 3, 652, 10262, 8, 652, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 3, 653, 10271, 8, 653, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 3, 654, 10280, 8, 654, 1, 655, 1, 655, 1, 655, 3, 655, 10285, 8, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 3, 655, 10294, 8, 655, 1, 656, 1, 656, 1, 656, 3, 656, 10299, 8, 656, 1, 656, 1, 656, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 658, 1, 658, 1, 659, 1, 659, 3, 659, 10313, 8, 659, 1, 660, 1, 660, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 3, 661, 10323, 8, 661, 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, 3, 662, 10331, 8, 662, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 3, 663, 10345, 8, 663, 1, 664, 1, 664, 1, 664, 5, 664, 10350, 8, 664, 10, 664, 12, 664, 10353, 9, 664, 1, 665, 1, 665, 1, 665, 5, 665, 10358, 8, 665, 10, 665, 12, 665, 10361, 9, 665, 1, 666, 1, 666, 1, 666, 5, 666, 10366, 8, 666, 10, 666, 12, 666, 10369, 9, 666, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, 3, 667, 10376, 8, 667, 1, 668, 1, 668, 3, 668, 10380, 8, 668, 1, 669, 1, 669, 1, 669, 5, 669, 10385, 8, 669, 10, 669, 12, 669, 10388, 9, 669, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, 3, 670, 10395, 8, 670, 1, 671, 1, 671, 1, 671, 5, 671, 10400, 8, 671, 10, 671, 12, 671, 10403, 9, 671, 1, 672, 1, 672, 1, 672, 3, 672, 10408, 8, 672, 1, 672, 1, 672, 1, 673, 1, 673, 1, 673, 5, 673, 10415, 8, 673, 10, 673, 12, 673, 10418, 9, 673, 1, 674, 1, 674, 1, 674, 1, 674, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 3, 675, 10432, 8, 675, 1, 676, 1, 676, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 3, 677, 10443, 8, 677, 1, 678, 1, 678, 1, 678, 1, 678, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 3, 679, 10476, 8, 679, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 3, 680, 10485, 8, 680, 1, 681, 1, 681, 1, 681, 1, 681, 1, 681, 3, 681, 10492, 8, 681, 1, 682, 1, 682, 3, 682, 10496, 8, 682, 1, 682, 1, 682, 3, 682, 10500, 8, 682, 1, 682, 1, 682, 1, 683, 4, 683, 10505, 8, 683, 11, 683, 12, 683, 10506, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 685, 1, 685, 1, 685, 1, 686, 1, 686, 1, 687, 1, 687, 3, 687, 10521, 8, 687, 1, 688, 1, 688, 1, 688, 3, 688, 10526, 8, 688, 1, 688, 1, 688, 1, 688, 3, 688, 10531, 8, 688, 1, 688, 1, 688, 3, 688, 10535, 8, 688, 3, 688, 10537, 8, 688, 1, 688, 3, 688, 10540, 8, 688, 1, 689, 1, 689, 1, 690, 4, 690, 10545, 8, 690, 11, 690, 12, 690, 10546, 1, 691, 5, 691, 10550, 8, 691, 10, 691, 12, 691, 10553, 9, 691, 1, 692, 1, 692, 1, 693, 1, 693, 1, 693, 5, 693, 10560, 8, 693, 10, 693, 12, 693, 10563, 9, 693, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 3, 694, 10570, 8, 694, 1, 694, 3, 694, 10573, 8, 694, 1, 695, 1, 695, 1, 695, 5, 695, 10578, 8, 695, 10, 695, 12, 695, 10581, 9, 695, 1, 696, 1, 696, 1, 696, 5, 696, 10586, 8, 696, 10, 696, 12, 696, 10589, 9, 696, 1, 697, 1, 697, 1, 697, 5, 697, 10594, 8, 697, 10, 697, 12, 697, 10597, 9, 697, 1, 698, 1, 698, 1, 698, 5, 698, 10602, 8, 698, 10, 698, 12, 698, 10605, 9, 698, 1, 699, 1, 699, 1, 699, 5, 699, 10610, 8, 699, 10, 699, 12, 699, 10613, 9, 699, 1, 700, 1, 700, 3, 700, 10617, 8, 700, 1, 701, 1, 701, 3, 701, 10621, 8, 701, 1, 702, 1, 702, 3, 702, 10625, 8, 702, 1, 703, 1, 703, 3, 703, 10629, 8, 703, 1, 704, 1, 704, 3, 704, 10633, 8, 704, 1, 705, 1, 705, 3, 705, 10637, 8, 705, 1, 706, 1, 706, 3, 706, 10641, 8, 706, 1, 707, 1, 707, 1, 707, 5, 707, 10646, 8, 707, 10, 707, 12, 707, 10649, 9, 707, 1, 708, 1, 708, 1, 708, 5, 708, 10654, 8, 708, 10, 708, 12, 708, 10657, 9, 708, 1, 709, 1, 709, 3, 709, 10661, 8, 709, 1, 710, 1, 710, 3, 710, 10665, 8, 710, 1, 711, 1, 711, 3, 711, 10669, 8, 711, 1, 712, 1, 712, 1, 713, 1, 713, 1, 714, 1, 714, 1, 714, 1, 714, 3, 714, 10679, 8, 714, 1, 715, 1, 715, 1, 715, 1, 715, 3, 715, 10685, 8, 715, 1, 716, 1, 716, 5, 716, 10689, 8, 716, 10, 716, 12, 716, 10692, 9, 716, 1, 716, 3, 716, 10695, 8, 716, 1, 717, 1, 717, 1, 718, 1, 718, 1, 719, 1, 719, 1, 720, 1, 720, 1, 721, 1, 721, 1, 721, 1, 721, 3, 721, 10709, 8, 721, 1, 722, 1, 722, 1, 722, 1, 722, 3, 722, 10715, 8, 722, 1, 723, 1, 723, 1, 723, 1, 723, 3, 723, 10721, 8, 723, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 3, 724, 10733, 8, 724, 1, 724, 1, 724, 1, 724, 3, 724, 10738, 8, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 3, 724, 10746, 8, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 3, 724, 10753, 8, 724, 1, 724, 1, 724, 1, 724, 3, 724, 10758, 8, 724, 1, 725, 1, 725, 1, 726, 1, 726, 1, 727, 1, 727, 1, 728, 1, 728, 1, 729, 1, 729, 3, 729, 10770, 8, 729, 1, 730, 1, 730, 1, 730, 1, 730, 5, 730, 10776, 8, 730, 10, 730, 12, 730, 10779, 9, 730, 1, 730, 1, 730, 3, 730, 10783, 8, 730, 1, 731, 1, 731, 1, 731, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 3, 732, 10793, 8, 732, 1, 733, 1, 733, 1, 734, 1, 734, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 3, 735, 10804, 8, 735, 1, 736, 1, 736, 1, 736, 5, 736, 10809, 8, 736, 10, 736, 12, 736, 10812, 9, 736, 1, 737, 1, 737, 1, 737, 1, 737, 3, 737, 10818, 8, 737, 1, 738, 1, 738, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 3, 739, 10829, 8, 739, 1, 739, 3, 739, 10832, 8, 739, 3, 739, 10834, 8, 739, 1, 740, 1, 740, 3, 740, 10838, 8, 740, 1, 740, 3, 740, 10841, 8, 740, 1, 741, 1, 741, 1, 741, 1, 741, 3, 741, 10847, 8, 741, 1, 742, 1, 742, 1, 742, 1, 742, 3, 742, 10853, 8, 742, 1, 743, 1, 743, 3, 743, 10857, 8, 743, 1, 744, 1, 744, 1, 744, 1, 744, 3, 744, 10863, 8, 744, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 3, 745, 10871, 8, 745, 1, 746, 1, 746, 3, 746, 10875, 8, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 3, 746, 10883, 8, 746, 1, 747, 1, 747, 1, 748, 1, 748, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 3, 749, 10940, 8, 749, 1, 750, 1, 750, 1, 751, 1, 751, 1, 752, 1, 752, 1, 752, 1, 752, 1, 753, 5, 753, 10951, 8, 753, 10, 753, 12, 753, 10954, 9, 753, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 3, 754, 10976, 8, 754, 1, 755, 1, 755, 1, 756, 1, 756, 1, 756, 1, 756, 3, 756, 10984, 8, 756, 1, 757, 1, 757, 3, 757, 10988, 8, 757, 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, 759, 1, 759, 1, 759, 3, 759, 11000, 8, 759, 3, 759, 11002, 8, 759, 1, 760, 1, 760, 1, 761, 4, 761, 11007, 8, 761, 11, 761, 12, 761, 11008, 1, 762, 1, 762, 1, 762, 1, 762, 1, 763, 1, 763, 1, 763, 3, 763, 11018, 8, 763, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 3, 764, 11036, 8, 764, 1, 764, 1, 764, 1, 765, 1, 765, 1, 765, 1, 765, 3, 765, 11044, 8, 765, 1, 766, 1, 766, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 3, 767, 11053, 8, 767, 1, 768, 1, 768, 1, 768, 5, 768, 11058, 8, 768, 10, 768, 12, 768, 11061, 9, 768, 1, 769, 1, 769, 1, 769, 1, 770, 1, 770, 1, 771, 1, 771, 3, 771, 11070, 8, 771, 1, 772, 1, 772, 1, 773, 1, 773, 3, 773, 11076, 8, 773, 1, 774, 1, 774, 1, 775, 1, 775, 1, 775, 3, 775, 11083, 8, 775, 1, 776, 1, 776, 1, 776, 3, 776, 11088, 8, 776, 1, 777, 1, 777, 1, 777, 1, 777, 3, 777, 11094, 8, 777, 1, 778, 1, 778, 3, 778, 11098, 8, 778, 1, 779, 1, 779, 1, 780, 5, 780, 11103, 8, 780, 10, 780, 12, 780, 11106, 9, 780, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 3, 781, 11135, 8, 781, 1, 782, 1, 782, 1, 782, 1, 782, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 3, 783, 11148, 8, 783, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 3, 783, 11157, 8, 783, 1, 784, 1, 784, 3, 784, 11161, 8, 784, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 787, 1, 787, 1, 787, 3, 787, 11177, 8, 787, 1, 788, 1, 788, 1, 788, 5, 788, 11182, 8, 788, 10, 788, 12, 788, 11185, 9, 788, 1, 789, 1, 789, 1, 789, 1, 789, 1, 790, 1, 790, 1, 791, 1, 791, 1, 792, 1, 792, 3, 792, 11197, 8, 792, 1, 792, 1, 792, 1, 792, 1, 792, 5, 792, 11203, 8, 792, 10, 792, 12, 792, 11206, 9, 792, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 5, 794, 11223, 8, 794, 10, 794, 12, 794, 11226, 9, 794, 1, 795, 1, 795, 1, 795, 3, 795, 11231, 8, 795, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 797, 1, 797, 3, 797, 11243, 8, 797, 1, 798, 4, 798, 11246, 8, 798, 11, 798, 12, 798, 11247, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 800, 1, 800, 1, 800, 3, 800, 11258, 8, 800, 1, 801, 1, 801, 1, 801, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 3, 804, 11290, 8, 804, 1, 805, 1, 805, 1, 805, 3, 805, 11295, 8, 805, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 5, 806, 11302, 8, 806, 10, 806, 12, 806, 11305, 9, 806, 1, 806, 1, 806, 3, 806, 11309, 8, 806, 1, 807, 1, 807, 3, 807, 11313, 8, 807, 1, 808, 1, 808, 1, 808, 3, 808, 11318, 8, 808, 1, 809, 1, 809, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 811, 1, 811, 1, 811, 3, 811, 11334, 8, 811, 1, 812, 1, 812, 1, 812, 3, 812, 11339, 8, 812, 1, 812, 1, 812, 1, 813, 1, 813, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 3, 814, 11354, 8, 814, 1, 814, 3, 814, 11357, 8, 814, 1, 814, 1, 814, 1, 815, 1, 815, 3, 815, 11363, 8, 815, 1, 816, 1, 816, 3, 816, 11367, 8, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 3, 816, 11376, 8, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 3, 816, 11384, 8, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 3, 816, 11393, 8, 816, 1, 816, 1, 816, 1, 816, 1, 816, 3, 816, 11399, 8, 816, 1, 817, 1, 817, 1, 818, 1, 818, 1, 818, 4, 818, 11406, 8, 818, 11, 818, 12, 818, 11407, 3, 818, 11410, 8, 818, 1, 819, 1, 819, 1, 819, 3, 819, 11415, 8, 819, 1, 820, 1, 820, 1, 820, 1, 820, 1, 821, 1, 821, 1, 821, 5, 821, 11424, 8, 821, 10, 821, 12, 821, 11427, 9, 821, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 823, 1, 823, 1, 823, 3, 823, 11437, 8, 823, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 825, 1, 825, 1, 825, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 3, 826, 11458, 8, 826, 1, 826, 1, 826, 1, 827, 1, 827, 1, 827, 3, 827, 11465, 8, 827, 1, 828, 1, 828, 1, 828, 5, 828, 11470, 8, 828, 10, 828, 12, 828, 11473, 9, 828, 1, 829, 1, 829, 1, 829, 3, 829, 11478, 8, 829, 1, 829, 3, 829, 11481, 8, 829, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 3, 830, 11492, 8, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 3, 830, 11499, 8, 830, 3, 830, 11501, 8, 830, 1, 830, 1, 830, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 3, 831, 11510, 8, 831, 1, 832, 1, 832, 1, 832, 5, 832, 11515, 8, 832, 10, 832, 12, 832, 11518, 9, 832, 1, 833, 1, 833, 1, 833, 3, 833, 11523, 8, 833, 1, 834, 1, 834, 1, 834, 1, 834, 3, 834, 11529, 8, 834, 1, 835, 1, 835, 3, 835, 11533, 8, 835, 1, 836, 1, 836, 3, 836, 11537, 8, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 837, 1, 837, 1, 838, 1, 838, 1, 838, 3, 838, 11550, 8, 838, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 3, 839, 11565, 8, 839, 3, 839, 11567, 8, 839, 1, 840, 1, 840, 3, 840, 11571, 8, 840, 1, 840, 1, 840, 1, 840, 1, 841, 3, 841, 11577, 8, 841, 1, 841, 1, 841, 1, 841, 3, 841, 11582, 8, 841, 1, 841, 1, 841, 3, 841, 11586, 8, 841, 1, 841, 3, 841, 11589, 8, 841, 1, 841, 3, 841, 11592, 8, 841, 1, 841, 1, 841, 1, 841, 1, 841, 1, 841, 4, 841, 11599, 8, 841, 11, 841, 12, 841, 11600, 1, 842, 3, 842, 11604, 8, 842, 1, 842, 1, 842, 3, 842, 11608, 8, 842, 1, 842, 1, 842, 3, 842, 11612, 8, 842, 3, 842, 11614, 8, 842, 1, 842, 3, 842, 11617, 8, 842, 1, 842, 3, 842, 11620, 8, 842, 1, 843, 1, 843, 1, 844, 1, 844, 1, 844, 1, 844, 3, 844, 11628, 8, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 3, 844, 11635, 8, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 3, 844, 11642, 8, 844, 1, 844, 1, 844, 1, 844, 1, 844, 3, 844, 11648, 8, 844, 3, 844, 11650, 8, 844, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 3, 845, 11657, 8, 845, 1, 845, 1, 845, 1, 845, 3, 845, 11662, 8, 845, 1, 845, 1, 845, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 4, 846, 11680, 8, 846, 11, 846, 12, 846, 11681, 1, 847, 1, 847, 1, 847, 1, 847, 3, 847, 11688, 8, 847, 1, 848, 1, 848, 1, 848, 1, 848, 5, 848, 11694, 8, 848, 10, 848, 12, 848, 11697, 9, 848, 1, 848, 1, 848, 1, 849, 1, 849, 3, 849, 11703, 8, 849, 1, 850, 1, 850, 1, 850, 1, 850, 1, 851, 1, 851, 1, 851, 1, 852, 1, 852, 3, 852, 11714, 8, 852, 1, 852, 1, 852, 1, 853, 1, 853, 3, 853, 11720, 8, 853, 1, 853, 1, 853, 1, 854, 1, 854, 3, 854, 11726, 8, 854, 1, 854, 1, 854, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 3, 855, 11739, 8, 855, 1, 855, 3, 855, 11742, 8, 855, 1, 856, 1, 856, 3, 856, 11746, 8, 856, 1, 857, 1, 857, 1, 857, 3, 857, 11751, 8, 857, 1, 858, 4, 858, 11754, 8, 858, 11, 858, 12, 858, 11755, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 860, 1, 860, 1, 860, 5, 860, 11766, 8, 860, 10, 860, 12, 860, 11769, 9, 860, 1, 861, 1, 861, 1, 861, 3, 861, 11774, 8, 861, 1, 862, 1, 862, 3, 862, 11778, 8, 862, 1, 863, 1, 863, 3, 863, 11782, 8, 863, 1, 864, 1, 864, 3, 864, 11786, 8, 864, 1, 865, 1, 865, 1, 865, 1, 866, 1, 866, 3, 866, 11793, 8, 866, 1, 867, 1, 867, 1, 868, 3, 868, 11798, 8, 868, 1, 868, 3, 868, 11801, 8, 868, 1, 868, 3, 868, 11804, 8, 868, 1, 868, 3, 868, 11807, 8, 868, 1, 868, 3, 868, 11810, 8, 868, 1, 868, 3, 868, 11813, 8, 868, 1, 868, 3, 868, 11816, 8, 868, 1, 869, 1, 869, 1, 870, 1, 870, 1, 871, 1, 871, 1, 872, 1, 872, 1, 873, 1, 873, 3, 873, 11828, 8, 873, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 0, 1, 1252, 875, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, 748, 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, 780, 782, 784, 786, 788, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810, 812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, 870, 872, 874, 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, 924, 926, 928, 930, 932, 934, 936, 938, 940, 942, 944, 946, 948, 950, 952, 954, 956, 958, 960, 962, 964, 966, 968, 970, 972, 974, 976, 978, 980, 982, 984, 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, 1016, 1018, 1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 1038, 1040, 1042, 1044, 1046, 1048, 1050, 1052, 1054, 1056, 1058, 1060, 1062, 1064, 1066, 1068, 1070, 1072, 1074, 1076, 1078, 1080, 1082, 1084, 1086, 1088, 1090, 1092, 1094, 1096, 1098, 1100, 1102, 1104, 1106, 1108, 1110, 1112, 1114, 1116, 1118, 1120, 1122, 1124, 1126, 1128, 1130, 1132, 1134, 1136, 1138, 1140, 1142, 1144, 1146, 1148, 1150, 1152, 1154, 1156, 1158, 1160, 1162, 1164, 1166, 1168, 1170, 1172, 1174, 1176, 1178, 1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 1196, 1198, 1200, 1202, 1204, 1206, 1208, 1210, 1212, 1214, 1216, 1218, 1220, 1222, 1224, 1226, 1228, 1230, 1232, 1234, 1236, 1238, 1240, 1242, 1244, 1246, 1248, 1250, 1252, 1254, 1256, 1258, 1260, 1262, 1264, 1266, 1268, 1270, 1272, 1274, 1276, 1278, 1280, 1282, 1284, 1286, 1288, 1290, 1292, 1294, 1296, 1298, 1300, 1302, 1304, 1306, 1308, 1310, 1312, 1314, 1316, 1318, 1320, 1322, 1324, 1326, 1328, 1330, 1332, 1334, 1336, 1338, 1340, 1342, 1344, 1346, 1348, 1350, 1352, 1354, 1356, 1358, 1360, 1362, 1364, 1366, 1368, 1370, 1372, 1374, 1376, 1378, 1380, 1382, 1384, 1386, 1388, 1390, 1392, 1394, 1396, 1398, 1400, 1402, 1404, 1406, 1408, 1410, 1412, 1414, 1416, 1418, 1420, 1422, 1424, 1426, 1428, 1430, 1432, 1434, 1436, 1438, 1440, 1442, 1444, 1446, 1448, 1450, 1452, 1454, 1456, 1458, 1460, 1462, 1464, 1466, 1468, 1470, 1472, 1474, 1476, 1478, 1480, 1482, 1484, 1486, 1488, 1490, 1492, 1494, 1496, 1498, 1500, 1502, 1504, 1506, 1508, 1510, 1512, 1514, 1516, 1518, 1520, 1522, 1524, 1526, 1528, 1530, 1532, 1534, 1536, 1538, 1540, 1542, 1544, 1546, 1548, 1550, 1552, 1554, 1556, 1558, 1560, 1562, 1564, 1566, 1568, 1570, 1572, 1574, 1576, 1578, 1580, 1582, 1584, 1586, 1588, 1590, 1592, 1594, 1596, 1598, 1600, 1602, 1604, 1606, 1608, 1610, 1612, 1614, 1616, 1618, 1620, 1622, 1624, 1626, 1628, 1630, 1632, 1634, 1636, 1638, 1640, 1642, 1644, 1646, 1648, 1650, 1652, 1654, 1656, 1658, 1660, 1662, 1664, 1666, 1668, 1670, 1672, 1674, 1676, 1678, 1680, 1682, 1684, 1686, 1688, 1690, 1692, 1694, 1696, 1698, 1700, 1702, 1704, 1706, 1708, 1710, 1712, 1714, 1716, 1718, 1720, 1722, 1724, 1726, 1728, 1730, 1732, 1734, 1736, 1738, 1740, 1742, 1744, 1746, 1748, 0, 87, 2, 0, 195, 195, 364, 364, 1, 0, 228, 229, 1, 0, 236, 237, 1, 0, 234, 235, 1, 0, 232, 233, 1, 0, 230, 231, 1, 0, 535, 536, 1, 0, 537, 538, 1, 0, 539, 540, 2, 0, 66, 66, 318, 318, 2, 0, 99, 99, 318, 318, 1, 0, 529, 531, 2, 0, 10, 10, 94, 94, 2, 0, 133, 133, 191, 191, 2, 0, 254, 254, 332, 332, 2, 0, 162, 162, 363, 363, 2, 0, 180, 180, 221, 221, 5, 0, 30, 30, 288, 288, 329, 329, 352, 352, 354, 354, 2, 0, 109, 109, 532, 532, 2, 0, 367, 367, 439, 439, 2, 0, 139, 139, 312, 312, 2, 0, 191, 191, 333, 333, 2, 0, 313, 313, 333, 333, 2, 0, 150, 150, 315, 315, 2, 0, 64, 64, 94, 94, 2, 0, 352, 352, 354, 354, 2, 0, 200, 200, 224, 224, 9, 0, 30, 30, 160, 160, 165, 165, 179, 179, 219, 219, 227, 227, 342, 342, 345, 345, 438, 438, 3, 0, 113, 113, 284, 284, 336, 336, 2, 0, 53, 53, 78, 78, 3, 0, 173, 173, 260, 260, 262, 262, 2, 0, 9, 9, 94, 94, 5, 0, 30, 30, 88, 88, 182, 182, 241, 241, 369, 369, 2, 0, 92, 92, 226, 226, 2, 0, 341, 341, 414, 414, 1, 0, 448, 449, 2, 0, 92, 92, 414, 414, 2, 0, 135, 135, 145, 145, 3, 0, 66, 66, 99, 99, 318, 318, 4, 0, 163, 163, 185, 185, 283, 283, 353, 353, 3, 0, 321, 321, 357, 357, 445, 445, 2, 0, 167, 167, 314, 314, 2, 0, 64, 64, 68, 68, 10, 0, 46, 46, 88, 88, 182, 182, 202, 202, 241, 241, 352, 352, 354, 354, 357, 358, 369, 369, 521, 523, 5, 0, 212, 212, 329, 329, 350, 350, 361, 361, 455, 456, 2, 0, 37, 37, 55, 55, 2, 0, 10, 10, 53, 53, 4, 0, 88, 88, 182, 182, 241, 241, 369, 369, 2, 0, 137, 137, 242, 242, 2, 0, 356, 356, 380, 380, 2, 0, 151, 151, 254, 254, 1, 0, 31, 32, 2, 0, 60, 60, 96, 96, 2, 0, 99, 99, 349, 349, 2, 0, 201, 201, 334, 334, 1, 0, 527, 528, 2, 0, 213, 213, 254, 254, 2, 0, 30, 30, 56, 56, 2, 0, 320, 320, 414, 414, 2, 0, 207, 207, 268, 268, 4, 0, 113, 113, 115, 115, 119, 119, 126, 126, 2, 0, 360, 360, 477, 477, 2, 0, 391, 392, 406, 406, 1, 0, 391, 392, 1, 0, 418, 419, 1, 0, 18, 19, 2, 0, 117, 117, 122, 122, 5, 0, 10, 10, 16, 17, 21, 21, 23, 23, 25, 25, 1, 0, 12, 13, 3, 0, 9, 9, 14, 14, 27, 27, 3, 0, 39, 39, 73, 73, 95, 95, 2, 0, 166, 166, 188, 188, 2, 0, 304, 304, 450, 450, 2, 0, 208, 208, 289, 289, 3, 0, 30, 30, 34, 34, 90, 90, 6, 0, 9, 10, 12, 17, 21, 21, 23, 23, 25, 25, 27, 27, 2, 0, 20, 20, 22, 22, 1, 0, 483, 486, 10, 0, 124, 124, 129, 228, 238, 386, 433, 452, 455, 469, 471, 471, 473, 473, 475, 475, 478, 488, 547, 548, 3, 0, 106, 123, 125, 128, 472, 472, 4, 0, 30, 52, 54, 70, 72, 105, 454, 454, 2, 0, 62, 62, 116, 116, 2, 0, 10, 10, 20, 20, 2, 0, 167, 167, 507, 507, 1, 0, 512, 517, 2, 0, 144, 144, 210, 210, 36, 0, 33, 33, 35, 35, 43, 43, 45, 45, 53, 53, 57, 57, 61, 61, 116, 116, 123, 123, 130, 130, 144, 144, 153, 153, 157, 157, 161, 161, 167, 167, 172, 172, 207, 207, 210, 210, 241, 241, 249, 249, 265, 265, 268, 269, 279, 279, 293, 293, 307, 307, 313, 313, 319, 319, 323, 324, 333, 333, 360, 360, 433, 434, 477, 477, 490, 502, 504, 504, 506, 518, 520, 520, 13157, 0, 1753, 1, 0, 0, 0, 2, 1758, 1, 0, 0, 0, 4, 1760, 1, 0, 0, 0, 6, 1881, 1, 0, 0, 0, 8, 1883, 1, 0, 0, 0, 10, 1887, 1, 0, 0, 0, 12, 1890, 1, 0, 0, 0, 14, 1898, 1, 0, 0, 0, 16, 1903, 1, 0, 0, 0, 18, 1909, 1, 0, 0, 0, 20, 1947, 1, 0, 0, 0, 22, 1959, 1, 0, 0, 0, 24, 1961, 1, 0, 0, 0, 26, 1969, 1, 0, 0, 0, 28, 1981, 1, 0, 0, 0, 30, 1983, 1, 0, 0, 0, 32, 1992, 1, 0, 0, 0, 34, 2020, 1, 0, 0, 0, 36, 2022, 1, 0, 0, 0, 38, 2070, 1, 0, 0, 0, 40, 2072, 1, 0, 0, 0, 42, 2080, 1, 0, 0, 0, 44, 2087, 1, 0, 0, 0, 46, 2089, 1, 0, 0, 0, 48, 2104, 1, 0, 0, 0, 50, 2111, 1, 0, 0, 0, 52, 2120, 1, 0, 0, 0, 54, 2122, 1, 0, 0, 0, 56, 2136, 1, 0, 0, 0, 58, 2140, 1, 0, 0, 0, 60, 2176, 1, 0, 0, 0, 62, 2178, 1, 0, 0, 0, 64, 2186, 1, 0, 0, 0, 66, 2196, 1, 0, 0, 0, 68, 2203, 1, 0, 0, 0, 70, 2209, 1, 0, 0, 0, 72, 2215, 1, 0, 0, 0, 74, 2233, 1, 0, 0, 0, 76, 2237, 1, 0, 0, 0, 78, 2241, 1, 0, 0, 0, 80, 2245, 1, 0, 0, 0, 82, 2247, 1, 0, 0, 0, 84, 2258, 1, 0, 0, 0, 86, 2262, 1, 0, 0, 0, 88, 2267, 1, 0, 0, 0, 90, 2272, 1, 0, 0, 0, 92, 2274, 1, 0, 0, 0, 94, 2286, 1, 0, 0, 0, 96, 2293, 1, 0, 0, 0, 98, 2295, 1, 0, 0, 0, 100, 2297, 1, 0, 0, 0, 102, 2299, 1, 0, 0, 0, 104, 2435, 1, 0, 0, 0, 106, 2437, 1, 0, 0, 0, 108, 2454, 1, 0, 0, 0, 110, 2456, 1, 0, 0, 0, 112, 2470, 1, 0, 0, 0, 114, 2472, 1, 0, 0, 0, 116, 2488, 1, 0, 0, 0, 118, 2490, 1, 0, 0, 0, 120, 2711, 1, 0, 0, 0, 122, 2718, 1, 0, 0, 0, 124, 2720, 1, 0, 0, 0, 126, 2722, 1, 0, 0, 0, 128, 2725, 1, 0, 0, 0, 130, 2734, 1, 0, 0, 0, 132, 2736, 1, 0, 0, 0, 134, 2740, 1, 0, 0, 0, 136, 2743, 1, 0, 0, 0, 138, 2751, 1, 0, 0, 0, 140, 2763, 1, 0, 0, 0, 142, 2780, 1, 0, 0, 0, 144, 2808, 1, 0, 0, 0, 146, 2810, 1, 0, 0, 0, 148, 2813, 1, 0, 0, 0, 150, 2821, 1, 0, 0, 0, 152, 2826, 1, 0, 0, 0, 154, 2863, 1, 0, 0, 0, 156, 2865, 1, 0, 0, 0, 158, 2907, 1, 0, 0, 0, 160, 2909, 1, 0, 0, 0, 162, 2911, 1, 0, 0, 0, 164, 2916, 1, 0, 0, 0, 166, 2923, 1, 0, 0, 0, 168, 2928, 1, 0, 0, 0, 170, 2970, 1, 0, 0, 0, 172, 2972, 1, 0, 0, 0, 174, 2975, 1, 0, 0, 0, 176, 2980, 1, 0, 0, 0, 178, 2982, 1, 0, 0, 0, 180, 2990, 1, 0, 0, 0, 182, 3001, 1, 0, 0, 0, 184, 3003, 1, 0, 0, 0, 186, 3011, 1, 0, 0, 0, 188, 3013, 1, 0, 0, 0, 190, 3096, 1, 0, 0, 0, 192, 3098, 1, 0, 0, 0, 194, 3100, 1, 0, 0, 0, 196, 3102, 1, 0, 0, 0, 198, 3106, 1, 0, 0, 0, 200, 3114, 1, 0, 0, 0, 202, 3125, 1, 0, 0, 0, 204, 3129, 1, 0, 0, 0, 206, 3131, 1, 0, 0, 0, 208, 3152, 1, 0, 0, 0, 210, 3155, 1, 0, 0, 0, 212, 3164, 1, 0, 0, 0, 214, 3174, 1, 0, 0, 0, 216, 3195, 1, 0, 0, 0, 218, 3255, 1, 0, 0, 0, 220, 3257, 1, 0, 0, 0, 222, 3266, 1, 0, 0, 0, 224, 3271, 1, 0, 0, 0, 226, 3273, 1, 0, 0, 0, 228, 3276, 1, 0, 0, 0, 230, 3284, 1, 0, 0, 0, 232, 3287, 1, 0, 0, 0, 234, 3294, 1, 0, 0, 0, 236, 3382, 1, 0, 0, 0, 238, 3384, 1, 0, 0, 0, 240, 3387, 1, 0, 0, 0, 242, 3391, 1, 0, 0, 0, 244, 3395, 1, 0, 0, 0, 246, 3403, 1, 0, 0, 0, 248, 3411, 1, 0, 0, 0, 250, 3416, 1, 0, 0, 0, 252, 3419, 1, 0, 0, 0, 254, 3427, 1, 0, 0, 0, 256, 3437, 1, 0, 0, 0, 258, 3450, 1, 0, 0, 0, 260, 3452, 1, 0, 0, 0, 262, 3456, 1, 0, 0, 0, 264, 3469, 1, 0, 0, 0, 266, 3471, 1, 0, 0, 0, 268, 3476, 1, 0, 0, 0, 270, 3478, 1, 0, 0, 0, 272, 3485, 1, 0, 0, 0, 274, 3516, 1, 0, 0, 0, 276, 3518, 1, 0, 0, 0, 278, 3527, 1, 0, 0, 0, 280, 3529, 1, 0, 0, 0, 282, 3538, 1, 0, 0, 0, 284, 3542, 1, 0, 0, 0, 286, 3550, 1, 0, 0, 0, 288, 3555, 1, 0, 0, 0, 290, 3559, 1, 0, 0, 0, 292, 3578, 1, 0, 0, 0, 294, 3588, 1, 0, 0, 0, 296, 3602, 1, 0, 0, 0, 298, 3618, 1, 0, 0, 0, 300, 3624, 1, 0, 0, 0, 302, 3639, 1, 0, 0, 0, 304, 3652, 1, 0, 0, 0, 306, 3654, 1, 0, 0, 0, 308, 3664, 1, 0, 0, 0, 310, 3676, 1, 0, 0, 0, 312, 3684, 1, 0, 0, 0, 314, 3686, 1, 0, 0, 0, 316, 3691, 1, 0, 0, 0, 318, 3729, 1, 0, 0, 0, 320, 3731, 1, 0, 0, 0, 322, 3739, 1, 0, 0, 0, 324, 3741, 1, 0, 0, 0, 326, 3749, 1, 0, 0, 0, 328, 3771, 1, 0, 0, 0, 330, 3773, 1, 0, 0, 0, 332, 3777, 1, 0, 0, 0, 334, 3784, 1, 0, 0, 0, 336, 3786, 1, 0, 0, 0, 338, 3788, 1, 0, 0, 0, 340, 3790, 1, 0, 0, 0, 342, 3801, 1, 0, 0, 0, 344, 3804, 1, 0, 0, 0, 346, 3818, 1, 0, 0, 0, 348, 3828, 1, 0, 0, 0, 350, 3830, 1, 0, 0, 0, 352, 3839, 1, 0, 0, 0, 354, 3842, 1, 0, 0, 0, 356, 3947, 1, 0, 0, 0, 358, 3949, 1, 0, 0, 0, 360, 3968, 1, 0, 0, 0, 362, 3971, 1, 0, 0, 0, 364, 3975, 1, 0, 0, 0, 366, 3994, 1, 0, 0, 0, 368, 3996, 1, 0, 0, 0, 370, 4001, 1, 0, 0, 0, 372, 4009, 1, 0, 0, 0, 374, 4014, 1, 0, 0, 0, 376, 4029, 1, 0, 0, 0, 378, 4031, 1, 0, 0, 0, 380, 4034, 1, 0, 0, 0, 382, 4036, 1, 0, 0, 0, 384, 4038, 1, 0, 0, 0, 386, 4057, 1, 0, 0, 0, 388, 4060, 1, 0, 0, 0, 390, 4065, 1, 0, 0, 0, 392, 4067, 1, 0, 0, 0, 394, 4116, 1, 0, 0, 0, 396, 4118, 1, 0, 0, 0, 398, 4136, 1, 0, 0, 0, 400, 4138, 1, 0, 0, 0, 402, 4143, 1, 0, 0, 0, 404, 4158, 1, 0, 0, 0, 406, 4160, 1, 0, 0, 0, 408, 4169, 1, 0, 0, 0, 410, 4189, 1, 0, 0, 0, 412, 4203, 1, 0, 0, 0, 414, 4237, 1, 0, 0, 0, 416, 4267, 1, 0, 0, 0, 418, 4269, 1, 0, 0, 0, 420, 4274, 1, 0, 0, 0, 422, 4280, 1, 0, 0, 0, 424, 4283, 1, 0, 0, 0, 426, 4286, 1, 0, 0, 0, 428, 4292, 1, 0, 0, 0, 430, 4295, 1, 0, 0, 0, 432, 4297, 1, 0, 0, 0, 434, 4306, 1, 0, 0, 0, 436, 4362, 1, 0, 0, 0, 438, 4368, 1, 0, 0, 0, 440, 4370, 1, 0, 0, 0, 442, 4376, 1, 0, 0, 0, 444, 4378, 1, 0, 0, 0, 446, 4393, 1, 0, 0, 0, 448, 4395, 1, 0, 0, 0, 450, 4399, 1, 0, 0, 0, 452, 4403, 1, 0, 0, 0, 454, 4410, 1, 0, 0, 0, 456, 4412, 1, 0, 0, 0, 458, 4414, 1, 0, 0, 0, 460, 4416, 1, 0, 0, 0, 462, 4422, 1, 0, 0, 0, 464, 4424, 1, 0, 0, 0, 466, 4426, 1, 0, 0, 0, 468, 4435, 1, 0, 0, 0, 470, 4439, 1, 0, 0, 0, 472, 4452, 1, 0, 0, 0, 474, 4454, 1, 0, 0, 0, 476, 4460, 1, 0, 0, 0, 478, 4474, 1, 0, 0, 0, 480, 4500, 1, 0, 0, 0, 482, 4502, 1, 0, 0, 0, 484, 4510, 1, 0, 0, 0, 486, 4516, 1, 0, 0, 0, 488, 4524, 1, 0, 0, 0, 490, 4535, 1, 0, 0, 0, 492, 4537, 1, 0, 0, 0, 494, 4649, 1, 0, 0, 0, 496, 4651, 1, 0, 0, 0, 498, 4655, 1, 0, 0, 0, 500, 4663, 1, 0, 0, 0, 502, 4674, 1, 0, 0, 0, 504, 4676, 1, 0, 0, 0, 506, 4680, 1, 0, 0, 0, 508, 4688, 1, 0, 0, 0, 510, 4692, 1, 0, 0, 0, 512, 4694, 1, 0, 0, 0, 514, 4724, 1, 0, 0, 0, 516, 4726, 1, 0, 0, 0, 518, 4730, 1, 0, 0, 0, 520, 4748, 1, 0, 0, 0, 522, 4787, 1, 0, 0, 0, 524, 4789, 1, 0, 0, 0, 526, 4791, 1, 0, 0, 0, 528, 4800, 1, 0, 0, 0, 530, 4802, 1, 0, 0, 0, 532, 4804, 1, 0, 0, 0, 534, 4829, 1, 0, 0, 0, 536, 4831, 1, 0, 0, 0, 538, 4851, 1, 0, 0, 0, 540, 4853, 1, 0, 0, 0, 542, 5239, 1, 0, 0, 0, 544, 5241, 1, 0, 0, 0, 546, 5273, 1, 0, 0, 0, 548, 5306, 1, 0, 0, 0, 550, 5308, 1, 0, 0, 0, 552, 5310, 1, 0, 0, 0, 554, 5318, 1, 0, 0, 0, 556, 5322, 1, 0, 0, 0, 558, 5326, 1, 0, 0, 0, 560, 5332, 1, 0, 0, 0, 562, 5336, 1, 0, 0, 0, 564, 5344, 1, 0, 0, 0, 566, 5364, 1, 0, 0, 0, 568, 5535, 1, 0, 0, 0, 570, 5539, 1, 0, 0, 0, 572, 5650, 1, 0, 0, 0, 574, 5652, 1, 0, 0, 0, 576, 5657, 1, 0, 0, 0, 578, 5663, 1, 0, 0, 0, 580, 5750, 1, 0, 0, 0, 582, 5752, 1, 0, 0, 0, 584, 5754, 1, 0, 0, 0, 586, 5756, 1, 0, 0, 0, 588, 5786, 1, 0, 0, 0, 590, 5804, 1, 0, 0, 0, 592, 5806, 1, 0, 0, 0, 594, 5814, 1, 0, 0, 0, 596, 5816, 1, 0, 0, 0, 598, 5840, 1, 0, 0, 0, 600, 5900, 1, 0, 0, 0, 602, 5902, 1, 0, 0, 0, 604, 5913, 1, 0, 0, 0, 606, 5915, 1, 0, 0, 0, 608, 5919, 1, 0, 0, 0, 610, 5952, 1, 0, 0, 0, 612, 5954, 1, 0, 0, 0, 614, 5958, 1, 0, 0, 0, 616, 5962, 1, 0, 0, 0, 618, 5971, 1, 0, 0, 0, 620, 5983, 1, 0, 0, 0, 622, 6015, 1, 0, 0, 0, 624, 6017, 1, 0, 0, 0, 626, 6019, 1, 0, 0, 0, 628, 6056, 1, 0, 0, 0, 630, 6058, 1, 0, 0, 0, 632, 6060, 1, 0, 0, 0, 634, 6062, 1, 0, 0, 0, 636, 6065, 1, 0, 0, 0, 638, 6096, 1, 0, 0, 0, 640, 6109, 1, 0, 0, 0, 642, 6111, 1, 0, 0, 0, 644, 6116, 1, 0, 0, 0, 646, 6124, 1, 0, 0, 0, 648, 6127, 1, 0, 0, 0, 650, 6129, 1, 0, 0, 0, 652, 6135, 1, 0, 0, 0, 654, 6137, 1, 0, 0, 0, 656, 6164, 1, 0, 0, 0, 658, 6175, 1, 0, 0, 0, 660, 6178, 1, 0, 0, 0, 662, 6184, 1, 0, 0, 0, 664, 6192, 1, 0, 0, 0, 666, 6208, 1, 0, 0, 0, 668, 6210, 1, 0, 0, 0, 670, 6226, 1, 0, 0, 0, 672, 6228, 1, 0, 0, 0, 674, 6244, 1, 0, 0, 0, 676, 6246, 1, 0, 0, 0, 678, 6252, 1, 0, 0, 0, 680, 6273, 1, 0, 0, 0, 682, 6282, 1, 0, 0, 0, 684, 6284, 1, 0, 0, 0, 686, 6286, 1, 0, 0, 0, 688, 6300, 1, 0, 0, 0, 690, 6302, 1, 0, 0, 0, 692, 6307, 1, 0, 0, 0, 694, 6309, 1, 0, 0, 0, 696, 6324, 1, 0, 0, 0, 698, 6332, 1, 0, 0, 0, 700, 6335, 1, 0, 0, 0, 702, 6344, 1, 0, 0, 0, 704, 6383, 1, 0, 0, 0, 706, 6410, 1, 0, 0, 0, 708, 6412, 1, 0, 0, 0, 710, 6424, 1, 0, 0, 0, 712, 6427, 1, 0, 0, 0, 714, 6430, 1, 0, 0, 0, 716, 6438, 1, 0, 0, 0, 718, 6450, 1, 0, 0, 0, 720, 6453, 1, 0, 0, 0, 722, 6457, 1, 0, 0, 0, 724, 6486, 1, 0, 0, 0, 726, 6488, 1, 0, 0, 0, 728, 6497, 1, 0, 0, 0, 730, 6528, 1, 0, 0, 0, 732, 6535, 1, 0, 0, 0, 734, 6540, 1, 0, 0, 0, 736, 6548, 1, 0, 0, 0, 738, 6551, 1, 0, 0, 0, 740, 6555, 1, 0, 0, 0, 742, 6562, 1, 0, 0, 0, 744, 6601, 1, 0, 0, 0, 746, 6607, 1, 0, 0, 0, 748, 6609, 1, 0, 0, 0, 750, 6612, 1, 0, 0, 0, 752, 6659, 1, 0, 0, 0, 754, 6677, 1, 0, 0, 0, 756, 6689, 1, 0, 0, 0, 758, 6706, 1, 0, 0, 0, 760, 6708, 1, 0, 0, 0, 762, 6716, 1, 0, 0, 0, 764, 6730, 1, 0, 0, 0, 766, 7123, 1, 0, 0, 0, 768, 7125, 1, 0, 0, 0, 770, 7197, 1, 0, 0, 0, 772, 7199, 1, 0, 0, 0, 774, 7386, 1, 0, 0, 0, 776, 7388, 1, 0, 0, 0, 778, 7396, 1, 0, 0, 0, 780, 7412, 1, 0, 0, 0, 782, 7419, 1, 0, 0, 0, 784, 7421, 1, 0, 0, 0, 786, 7614, 1, 0, 0, 0, 788, 7616, 1, 0, 0, 0, 790, 7625, 1, 0, 0, 0, 792, 7633, 1, 0, 0, 0, 794, 7673, 1, 0, 0, 0, 796, 7675, 1, 0, 0, 0, 798, 7685, 1, 0, 0, 0, 800, 7693, 1, 0, 0, 0, 802, 7773, 1, 0, 0, 0, 804, 7775, 1, 0, 0, 0, 806, 7801, 1, 0, 0, 0, 808, 7804, 1, 0, 0, 0, 810, 7820, 1, 0, 0, 0, 812, 7822, 1, 0, 0, 0, 814, 7824, 1, 0, 0, 0, 816, 7826, 1, 0, 0, 0, 818, 7828, 1, 0, 0, 0, 820, 7833, 1, 0, 0, 0, 822, 7836, 1, 0, 0, 0, 824, 7843, 1, 0, 0, 0, 826, 7910, 1, 0, 0, 0, 828, 7912, 1, 0, 0, 0, 830, 7924, 1, 0, 0, 0, 832, 7926, 1, 0, 0, 0, 834, 7936, 1, 0, 0, 0, 836, 7938, 1, 0, 0, 0, 838, 7944, 1, 0, 0, 0, 840, 7976, 1, 0, 0, 0, 842, 7983, 1, 0, 0, 0, 844, 7986, 1, 0, 0, 0, 846, 7995, 1, 0, 0, 0, 848, 7998, 1, 0, 0, 0, 850, 8002, 1, 0, 0, 0, 852, 8019, 1, 0, 0, 0, 854, 8021, 1, 0, 0, 0, 856, 8023, 1, 0, 0, 0, 858, 8039, 1, 0, 0, 0, 860, 8045, 1, 0, 0, 0, 862, 8053, 1, 0, 0, 0, 864, 8055, 1, 0, 0, 0, 866, 8061, 1, 0, 0, 0, 868, 8066, 1, 0, 0, 0, 870, 8075, 1, 0, 0, 0, 872, 8101, 1, 0, 0, 0, 874, 8103, 1, 0, 0, 0, 876, 8173, 1, 0, 0, 0, 878, 8175, 1, 0, 0, 0, 880, 8177, 1, 0, 0, 0, 882, 8208, 1, 0, 0, 0, 884, 8210, 1, 0, 0, 0, 886, 8221, 1, 0, 0, 0, 888, 8250, 1, 0, 0, 0, 890, 8266, 1, 0, 0, 0, 892, 8268, 1, 0, 0, 0, 894, 8276, 1, 0, 0, 0, 896, 8278, 1, 0, 0, 0, 898, 8284, 1, 0, 0, 0, 900, 8288, 1, 0, 0, 0, 902, 8290, 1, 0, 0, 0, 904, 8292, 1, 0, 0, 0, 906, 8303, 1, 0, 0, 0, 908, 8305, 1, 0, 0, 0, 910, 8309, 1, 0, 0, 0, 912, 8313, 1, 0, 0, 0, 914, 8318, 1, 0, 0, 0, 916, 8320, 1, 0, 0, 0, 918, 8322, 1, 0, 0, 0, 920, 8326, 1, 0, 0, 0, 922, 8330, 1, 0, 0, 0, 924, 8338, 1, 0, 0, 0, 926, 8358, 1, 0, 0, 0, 928, 8369, 1, 0, 0, 0, 930, 8371, 1, 0, 0, 0, 932, 8379, 1, 0, 0, 0, 934, 8385, 1, 0, 0, 0, 936, 8389, 1, 0, 0, 0, 938, 8391, 1, 0, 0, 0, 940, 8399, 1, 0, 0, 0, 942, 8407, 1, 0, 0, 0, 944, 8432, 1, 0, 0, 0, 946, 8434, 1, 0, 0, 0, 948, 8438, 1, 0, 0, 0, 950, 8447, 1, 0, 0, 0, 952, 8459, 1, 0, 0, 0, 954, 8468, 1, 0, 0, 0, 956, 8480, 1, 0, 0, 0, 958, 8482, 1, 0, 0, 0, 960, 8490, 1, 0, 0, 0, 962, 8493, 1, 0, 0, 0, 964, 8517, 1, 0, 0, 0, 966, 8519, 1, 0, 0, 0, 968, 8523, 1, 0, 0, 0, 970, 8537, 1, 0, 0, 0, 972, 8540, 1, 0, 0, 0, 974, 8551, 1, 0, 0, 0, 976, 8567, 1, 0, 0, 0, 978, 8569, 1, 0, 0, 0, 980, 8574, 1, 0, 0, 0, 982, 8577, 1, 0, 0, 0, 984, 8592, 1, 0, 0, 0, 986, 8618, 1, 0, 0, 0, 988, 8620, 1, 0, 0, 0, 990, 8623, 1, 0, 0, 0, 992, 8631, 1, 0, 0, 0, 994, 8639, 1, 0, 0, 0, 996, 8648, 1, 0, 0, 0, 998, 8656, 1, 0, 0, 0, 1000, 8660, 1, 0, 0, 0, 1002, 8670, 1, 0, 0, 0, 1004, 8701, 1, 0, 0, 0, 1006, 8705, 1, 0, 0, 0, 1008, 8752, 1, 0, 0, 0, 1010, 8767, 1, 0, 0, 0, 1012, 8769, 1, 0, 0, 0, 1014, 8773, 1, 0, 0, 0, 1016, 8779, 1, 0, 0, 0, 1018, 8787, 1, 0, 0, 0, 1020, 8804, 1, 0, 0, 0, 1022, 8812, 1, 0, 0, 0, 1024, 8829, 1, 0, 0, 0, 1026, 8831, 1, 0, 0, 0, 1028, 8833, 1, 0, 0, 0, 1030, 8842, 1, 0, 0, 0, 1032, 8860, 1, 0, 0, 0, 1034, 8862, 1, 0, 0, 0, 1036, 8864, 1, 0, 0, 0, 1038, 8866, 1, 0, 0, 0, 1040, 8874, 1, 0, 0, 0, 1042, 8876, 1, 0, 0, 0, 1044, 8878, 1, 0, 0, 0, 1046, 8882, 1, 0, 0, 0, 1048, 8890, 1, 0, 0, 0, 1050, 8911, 1, 0, 0, 0, 1052, 8913, 1, 0, 0, 0, 1054, 8915, 1, 0, 0, 0, 1056, 8921, 1, 0, 0, 0, 1058, 8938, 1, 0, 0, 0, 1060, 8947, 1, 0, 0, 0, 1062, 8949, 1, 0, 0, 0, 1064, 8956, 1, 0, 0, 0, 1066, 8960, 1, 0, 0, 0, 1068, 8962, 1, 0, 0, 0, 1070, 8964, 1, 0, 0, 0, 1072, 8966, 1, 0, 0, 0, 1074, 8973, 1, 0, 0, 0, 1076, 8990, 1, 0, 0, 0, 1078, 8992, 1, 0, 0, 0, 1080, 8995, 1, 0, 0, 0, 1082, 9000, 1, 0, 0, 0, 1084, 9005, 1, 0, 0, 0, 1086, 9011, 1, 0, 0, 0, 1088, 9018, 1, 0, 0, 0, 1090, 9020, 1, 0, 0, 0, 1092, 9023, 1, 0, 0, 0, 1094, 9027, 1, 0, 0, 0, 1096, 9034, 1, 0, 0, 0, 1098, 9046, 1, 0, 0, 0, 1100, 9049, 1, 0, 0, 0, 1102, 9063, 1, 0, 0, 0, 1104, 9066, 1, 0, 0, 0, 1106, 9135, 1, 0, 0, 0, 1108, 9159, 1, 0, 0, 0, 1110, 9168, 1, 0, 0, 0, 1112, 9182, 1, 0, 0, 0, 1114, 9184, 1, 0, 0, 0, 1116, 9195, 1, 0, 0, 0, 1118, 9218, 1, 0, 0, 0, 1120, 9221, 1, 0, 0, 0, 1122, 9266, 1, 0, 0, 0, 1124, 9268, 1, 0, 0, 0, 1126, 9276, 1, 0, 0, 0, 1128, 9284, 1, 0, 0, 0, 1130, 9291, 1, 0, 0, 0, 1132, 9299, 1, 0, 0, 0, 1134, 9316, 1, 0, 0, 0, 1136, 9318, 1, 0, 0, 0, 1138, 9322, 1, 0, 0, 0, 1140, 9330, 1, 0, 0, 0, 1142, 9335, 1, 0, 0, 0, 1144, 9338, 1, 0, 0, 0, 1146, 9341, 1, 0, 0, 0, 1148, 9348, 1, 0, 0, 0, 1150, 9350, 1, 0, 0, 0, 1152, 9358, 1, 0, 0, 0, 1154, 9363, 1, 0, 0, 0, 1156, 9384, 1, 0, 0, 0, 1158, 9392, 1, 0, 0, 0, 1160, 9402, 1, 0, 0, 0, 1162, 9414, 1, 0, 0, 0, 1164, 9416, 1, 0, 0, 0, 1166, 9430, 1, 0, 0, 0, 1168, 9450, 1, 0, 0, 0, 1170, 9459, 1, 0, 0, 0, 1172, 9477, 1, 0, 0, 0, 1174, 9483, 1, 0, 0, 0, 1176, 9485, 1, 0, 0, 0, 1178, 9492, 1, 0, 0, 0, 1180, 9520, 1, 0, 0, 0, 1182, 9522, 1, 0, 0, 0, 1184, 9528, 1, 0, 0, 0, 1186, 9532, 1, 0, 0, 0, 1188, 9534, 1, 0, 0, 0, 1190, 9542, 1, 0, 0, 0, 1192, 9546, 1, 0, 0, 0, 1194, 9553, 1, 0, 0, 0, 1196, 9570, 1, 0, 0, 0, 1198, 9572, 1, 0, 0, 0, 1200, 9574, 1, 0, 0, 0, 1202, 9584, 1, 0, 0, 0, 1204, 9592, 1, 0, 0, 0, 1206, 9619, 1, 0, 0, 0, 1208, 9621, 1, 0, 0, 0, 1210, 9628, 1, 0, 0, 0, 1212, 9631, 1, 0, 0, 0, 1214, 9633, 1, 0, 0, 0, 1216, 9637, 1, 0, 0, 0, 1218, 9645, 1, 0, 0, 0, 1220, 9653, 1, 0, 0, 0, 1222, 9661, 1, 0, 0, 0, 1224, 9670, 1, 0, 0, 0, 1226, 9674, 1, 0, 0, 0, 1228, 9678, 1, 0, 0, 0, 1230, 9704, 1, 0, 0, 0, 1232, 9718, 1, 0, 0, 0, 1234, 9738, 1, 0, 0, 0, 1236, 9748, 1, 0, 0, 0, 1238, 9752, 1, 0, 0, 0, 1240, 9760, 1, 0, 0, 0, 1242, 9768, 1, 0, 0, 0, 1244, 9774, 1, 0, 0, 0, 1246, 9778, 1, 0, 0, 0, 1248, 9785, 1, 0, 0, 0, 1250, 9790, 1, 0, 0, 0, 1252, 9805, 1, 0, 0, 0, 1254, 9885, 1, 0, 0, 0, 1256, 9887, 1, 0, 0, 0, 1258, 9889, 1, 0, 0, 0, 1260, 9928, 1, 0, 0, 0, 1262, 9932, 1, 0, 0, 0, 1264, 10118, 1, 0, 0, 0, 1266, 10125, 1, 0, 0, 0, 1268, 10137, 1, 0, 0, 0, 1270, 10139, 1, 0, 0, 0, 1272, 10144, 1, 0, 0, 0, 1274, 10152, 1, 0, 0, 0, 1276, 10157, 1, 0, 0, 0, 1278, 10163, 1, 0, 0, 0, 1280, 10180, 1, 0, 0, 0, 1282, 10182, 1, 0, 0, 0, 1284, 10185, 1, 0, 0, 0, 1286, 10191, 1, 0, 0, 0, 1288, 10197, 1, 0, 0, 0, 1290, 10200, 1, 0, 0, 0, 1292, 10208, 1, 0, 0, 0, 1294, 10212, 1, 0, 0, 0, 1296, 10217, 1, 0, 0, 0, 1298, 10232, 1, 0, 0, 0, 1300, 10234, 1, 0, 0, 0, 1302, 10253, 1, 0, 0, 0, 1304, 10261, 1, 0, 0, 0, 1306, 10270, 1, 0, 0, 0, 1308, 10272, 1, 0, 0, 0, 1310, 10293, 1, 0, 0, 0, 1312, 10295, 1, 0, 0, 0, 1314, 10302, 1, 0, 0, 0, 1316, 10308, 1, 0, 0, 0, 1318, 10312, 1, 0, 0, 0, 1320, 10314, 1, 0, 0, 0, 1322, 10322, 1, 0, 0, 0, 1324, 10330, 1, 0, 0, 0, 1326, 10344, 1, 0, 0, 0, 1328, 10346, 1, 0, 0, 0, 1330, 10354, 1, 0, 0, 0, 1332, 10362, 1, 0, 0, 0, 1334, 10375, 1, 0, 0, 0, 1336, 10379, 1, 0, 0, 0, 1338, 10381, 1, 0, 0, 0, 1340, 10394, 1, 0, 0, 0, 1342, 10396, 1, 0, 0, 0, 1344, 10404, 1, 0, 0, 0, 1346, 10411, 1, 0, 0, 0, 1348, 10419, 1, 0, 0, 0, 1350, 10431, 1, 0, 0, 0, 1352, 10433, 1, 0, 0, 0, 1354, 10435, 1, 0, 0, 0, 1356, 10444, 1, 0, 0, 0, 1358, 10475, 1, 0, 0, 0, 1360, 10484, 1, 0, 0, 0, 1362, 10491, 1, 0, 0, 0, 1364, 10493, 1, 0, 0, 0, 1366, 10504, 1, 0, 0, 0, 1368, 10508, 1, 0, 0, 0, 1370, 10513, 1, 0, 0, 0, 1372, 10516, 1, 0, 0, 0, 1374, 10518, 1, 0, 0, 0, 1376, 10539, 1, 0, 0, 0, 1378, 10541, 1, 0, 0, 0, 1380, 10544, 1, 0, 0, 0, 1382, 10551, 1, 0, 0, 0, 1384, 10554, 1, 0, 0, 0, 1386, 10556, 1, 0, 0, 0, 1388, 10572, 1, 0, 0, 0, 1390, 10574, 1, 0, 0, 0, 1392, 10582, 1, 0, 0, 0, 1394, 10590, 1, 0, 0, 0, 1396, 10598, 1, 0, 0, 0, 1398, 10606, 1, 0, 0, 0, 1400, 10614, 1, 0, 0, 0, 1402, 10618, 1, 0, 0, 0, 1404, 10622, 1, 0, 0, 0, 1406, 10626, 1, 0, 0, 0, 1408, 10630, 1, 0, 0, 0, 1410, 10634, 1, 0, 0, 0, 1412, 10638, 1, 0, 0, 0, 1414, 10642, 1, 0, 0, 0, 1416, 10650, 1, 0, 0, 0, 1418, 10658, 1, 0, 0, 0, 1420, 10662, 1, 0, 0, 0, 1422, 10666, 1, 0, 0, 0, 1424, 10670, 1, 0, 0, 0, 1426, 10672, 1, 0, 0, 0, 1428, 10678, 1, 0, 0, 0, 1430, 10684, 1, 0, 0, 0, 1432, 10694, 1, 0, 0, 0, 1434, 10696, 1, 0, 0, 0, 1436, 10698, 1, 0, 0, 0, 1438, 10700, 1, 0, 0, 0, 1440, 10702, 1, 0, 0, 0, 1442, 10708, 1, 0, 0, 0, 1444, 10714, 1, 0, 0, 0, 1446, 10720, 1, 0, 0, 0, 1448, 10757, 1, 0, 0, 0, 1450, 10759, 1, 0, 0, 0, 1452, 10761, 1, 0, 0, 0, 1454, 10763, 1, 0, 0, 0, 1456, 10765, 1, 0, 0, 0, 1458, 10767, 1, 0, 0, 0, 1460, 10782, 1, 0, 0, 0, 1462, 10784, 1, 0, 0, 0, 1464, 10792, 1, 0, 0, 0, 1466, 10794, 1, 0, 0, 0, 1468, 10796, 1, 0, 0, 0, 1470, 10803, 1, 0, 0, 0, 1472, 10805, 1, 0, 0, 0, 1474, 10817, 1, 0, 0, 0, 1476, 10819, 1, 0, 0, 0, 1478, 10833, 1, 0, 0, 0, 1480, 10837, 1, 0, 0, 0, 1482, 10846, 1, 0, 0, 0, 1484, 10852, 1, 0, 0, 0, 1486, 10856, 1, 0, 0, 0, 1488, 10862, 1, 0, 0, 0, 1490, 10870, 1, 0, 0, 0, 1492, 10882, 1, 0, 0, 0, 1494, 10884, 1, 0, 0, 0, 1496, 10886, 1, 0, 0, 0, 1498, 10939, 1, 0, 0, 0, 1500, 10941, 1, 0, 0, 0, 1502, 10943, 1, 0, 0, 0, 1504, 10945, 1, 0, 0, 0, 1506, 10952, 1, 0, 0, 0, 1508, 10975, 1, 0, 0, 0, 1510, 10977, 1, 0, 0, 0, 1512, 10983, 1, 0, 0, 0, 1514, 10987, 1, 0, 0, 0, 1516, 10989, 1, 0, 0, 0, 1518, 10996, 1, 0, 0, 0, 1520, 11003, 1, 0, 0, 0, 1522, 11006, 1, 0, 0, 0, 1524, 11010, 1, 0, 0, 0, 1526, 11017, 1, 0, 0, 0, 1528, 11019, 1, 0, 0, 0, 1530, 11043, 1, 0, 0, 0, 1532, 11045, 1, 0, 0, 0, 1534, 11052, 1, 0, 0, 0, 1536, 11054, 1, 0, 0, 0, 1538, 11062, 1, 0, 0, 0, 1540, 11065, 1, 0, 0, 0, 1542, 11069, 1, 0, 0, 0, 1544, 11071, 1, 0, 0, 0, 1546, 11075, 1, 0, 0, 0, 1548, 11077, 1, 0, 0, 0, 1550, 11082, 1, 0, 0, 0, 1552, 11087, 1, 0, 0, 0, 1554, 11093, 1, 0, 0, 0, 1556, 11097, 1, 0, 0, 0, 1558, 11099, 1, 0, 0, 0, 1560, 11104, 1, 0, 0, 0, 1562, 11134, 1, 0, 0, 0, 1564, 11136, 1, 0, 0, 0, 1566, 11156, 1, 0, 0, 0, 1568, 11160, 1, 0, 0, 0, 1570, 11162, 1, 0, 0, 0, 1572, 11167, 1, 0, 0, 0, 1574, 11176, 1, 0, 0, 0, 1576, 11178, 1, 0, 0, 0, 1578, 11186, 1, 0, 0, 0, 1580, 11190, 1, 0, 0, 0, 1582, 11192, 1, 0, 0, 0, 1584, 11196, 1, 0, 0, 0, 1586, 11207, 1, 0, 0, 0, 1588, 11224, 1, 0, 0, 0, 1590, 11230, 1, 0, 0, 0, 1592, 11232, 1, 0, 0, 0, 1594, 11242, 1, 0, 0, 0, 1596, 11245, 1, 0, 0, 0, 1598, 11249, 1, 0, 0, 0, 1600, 11257, 1, 0, 0, 0, 1602, 11259, 1, 0, 0, 0, 1604, 11262, 1, 0, 0, 0, 1606, 11267, 1, 0, 0, 0, 1608, 11272, 1, 0, 0, 0, 1610, 11294, 1, 0, 0, 0, 1612, 11308, 1, 0, 0, 0, 1614, 11312, 1, 0, 0, 0, 1616, 11317, 1, 0, 0, 0, 1618, 11319, 1, 0, 0, 0, 1620, 11321, 1, 0, 0, 0, 1622, 11333, 1, 0, 0, 0, 1624, 11335, 1, 0, 0, 0, 1626, 11342, 1, 0, 0, 0, 1628, 11344, 1, 0, 0, 0, 1630, 11362, 1, 0, 0, 0, 1632, 11398, 1, 0, 0, 0, 1634, 11400, 1, 0, 0, 0, 1636, 11409, 1, 0, 0, 0, 1638, 11414, 1, 0, 0, 0, 1640, 11416, 1, 0, 0, 0, 1642, 11420, 1, 0, 0, 0, 1644, 11428, 1, 0, 0, 0, 1646, 11436, 1, 0, 0, 0, 1648, 11438, 1, 0, 0, 0, 1650, 11445, 1, 0, 0, 0, 1652, 11448, 1, 0, 0, 0, 1654, 11464, 1, 0, 0, 0, 1656, 11466, 1, 0, 0, 0, 1658, 11480, 1, 0, 0, 0, 1660, 11482, 1, 0, 0, 0, 1662, 11509, 1, 0, 0, 0, 1664, 11511, 1, 0, 0, 0, 1666, 11522, 1, 0, 0, 0, 1668, 11528, 1, 0, 0, 0, 1670, 11532, 1, 0, 0, 0, 1672, 11534, 1, 0, 0, 0, 1674, 11544, 1, 0, 0, 0, 1676, 11549, 1, 0, 0, 0, 1678, 11566, 1, 0, 0, 0, 1680, 11568, 1, 0, 0, 0, 1682, 11576, 1, 0, 0, 0, 1684, 11613, 1, 0, 0, 0, 1686, 11621, 1, 0, 0, 0, 1688, 11649, 1, 0, 0, 0, 1690, 11651, 1, 0, 0, 0, 1692, 11665, 1, 0, 0, 0, 1694, 11687, 1, 0, 0, 0, 1696, 11689, 1, 0, 0, 0, 1698, 11702, 1, 0, 0, 0, 1700, 11704, 1, 0, 0, 0, 1702, 11708, 1, 0, 0, 0, 1704, 11711, 1, 0, 0, 0, 1706, 11717, 1, 0, 0, 0, 1708, 11723, 1, 0, 0, 0, 1710, 11741, 1, 0, 0, 0, 1712, 11745, 1, 0, 0, 0, 1714, 11750, 1, 0, 0, 0, 1716, 11753, 1, 0, 0, 0, 1718, 11757, 1, 0, 0, 0, 1720, 11762, 1, 0, 0, 0, 1722, 11773, 1, 0, 0, 0, 1724, 11777, 1, 0, 0, 0, 1726, 11781, 1, 0, 0, 0, 1728, 11785, 1, 0, 0, 0, 1730, 11787, 1, 0, 0, 0, 1732, 11792, 1, 0, 0, 0, 1734, 11794, 1, 0, 0, 0, 1736, 11797, 1, 0, 0, 0, 1738, 11817, 1, 0, 0, 0, 1740, 11819, 1, 0, 0, 0, 1742, 11821, 1, 0, 0, 0, 1744, 11823, 1, 0, 0, 0, 1746, 11825, 1, 0, 0, 0, 1748, 11829, 1, 0, 0, 0, 1750, 1752, 3, 4, 2, 0, 1751, 1750, 1, 0, 0, 0, 1752, 1755, 1, 0, 0, 0, 1753, 1751, 1, 0, 0, 0, 1753, 1754, 1, 0, 0, 0, 1754, 1756, 1, 0, 0, 0, 1755, 1753, 1, 0, 0, 0, 1756, 1757, 5, 0, 0, 1, 1757, 1, 1, 0, 0, 0, 1758, 1759, 3, 1504, 752, 0, 1759, 3, 1, 0, 0, 0, 1760, 1762, 3, 6, 3, 0, 1761, 1763, 5, 7, 0, 0, 1762, 1761, 1, 0, 0, 0, 1762, 1763, 1, 0, 0, 0, 1763, 5, 1, 0, 0, 0, 1764, 1882, 3, 488, 244, 0, 1765, 1882, 3, 864, 432, 0, 1766, 1882, 3, 856, 428, 0, 1767, 1882, 3, 858, 429, 0, 1768, 1882, 3, 616, 308, 0, 1769, 1882, 3, 870, 435, 0, 1770, 1882, 3, 514, 257, 0, 1771, 1882, 3, 350, 175, 0, 1772, 1882, 3, 356, 178, 0, 1773, 1882, 3, 366, 183, 0, 1774, 1882, 3, 392, 196, 0, 1775, 1882, 3, 716, 358, 0, 1776, 1882, 3, 42, 21, 0, 1777, 1882, 3, 770, 385, 0, 1778, 1882, 3, 774, 387, 0, 1779, 1882, 3, 786, 393, 0, 1780, 1882, 3, 776, 388, 0, 1781, 1882, 3, 784, 392, 0, 1782, 1882, 3, 410, 205, 0, 1783, 1882, 3, 412, 206, 0, 1784, 1882, 3, 310, 155, 0, 1785, 1882, 3, 866, 433, 0, 1786, 1882, 3, 104, 52, 0, 1787, 1882, 3, 764, 382, 0, 1788, 1882, 3, 150, 75, 0, 1789, 1882, 3, 794, 397, 0, 1790, 1882, 3, 30, 15, 0, 1791, 1882, 3, 32, 16, 0, 1792, 1882, 3, 26, 13, 0, 1793, 1882, 3, 802, 401, 0, 1794, 1882, 3, 292, 146, 0, 1795, 1882, 3, 876, 438, 0, 1796, 1882, 3, 874, 437, 0, 1797, 1882, 3, 406, 203, 0, 1798, 1882, 3, 890, 445, 0, 1799, 1882, 3, 10, 5, 0, 1800, 1882, 3, 100, 50, 0, 1801, 1882, 3, 156, 78, 0, 1802, 1882, 3, 882, 441, 0, 1803, 1882, 3, 568, 284, 0, 1804, 1882, 3, 94, 47, 0, 1805, 1882, 3, 158, 79, 0, 1806, 1882, 3, 432, 216, 0, 1807, 1882, 3, 294, 147, 0, 1808, 1882, 3, 492, 246, 0, 1809, 1882, 3, 744, 372, 0, 1810, 1882, 3, 880, 440, 0, 1811, 1882, 3, 868, 434, 0, 1812, 1882, 3, 344, 172, 0, 1813, 1882, 3, 358, 179, 0, 1814, 1882, 3, 384, 192, 0, 1815, 1882, 3, 394, 197, 0, 1816, 1882, 3, 654, 327, 0, 1817, 1882, 3, 40, 20, 0, 1818, 1882, 3, 300, 150, 0, 1819, 1882, 3, 518, 259, 0, 1820, 1882, 3, 532, 266, 0, 1821, 1882, 3, 788, 394, 0, 1822, 1882, 3, 534, 267, 0, 1823, 1882, 3, 408, 204, 0, 1824, 1882, 3, 326, 163, 0, 1825, 1882, 3, 46, 23, 0, 1826, 1882, 3, 308, 154, 0, 1827, 1882, 3, 188, 94, 0, 1828, 1882, 3, 796, 398, 0, 1829, 1882, 3, 290, 145, 0, 1830, 1882, 3, 340, 170, 0, 1831, 1882, 3, 750, 375, 0, 1832, 1882, 3, 436, 218, 0, 1833, 1882, 3, 480, 240, 0, 1834, 1882, 3, 12, 6, 0, 1835, 1882, 3, 24, 12, 0, 1836, 1882, 3, 402, 201, 0, 1837, 1882, 3, 844, 422, 0, 1838, 1882, 3, 948, 474, 0, 1839, 1882, 3, 992, 496, 0, 1840, 1882, 3, 494, 247, 0, 1841, 1882, 3, 968, 484, 0, 1842, 1882, 3, 102, 51, 0, 1843, 1882, 3, 738, 369, 0, 1844, 1882, 3, 542, 271, 0, 1845, 1882, 3, 944, 472, 0, 1846, 1882, 3, 926, 463, 0, 1847, 1882, 3, 578, 289, 0, 1848, 1882, 3, 586, 293, 0, 1849, 1882, 3, 608, 304, 0, 1850, 1882, 3, 1682, 841, 0, 1851, 1882, 3, 396, 198, 0, 1852, 1882, 3, 626, 313, 0, 1853, 1882, 3, 950, 475, 0, 1854, 1882, 3, 822, 411, 0, 1855, 1882, 3, 306, 153, 0, 1856, 1882, 3, 842, 421, 0, 1857, 1882, 3, 972, 486, 0, 1858, 1882, 3, 818, 409, 0, 1859, 1882, 3, 938, 469, 0, 1860, 1882, 3, 540, 270, 0, 1861, 1882, 3, 754, 377, 0, 1862, 1882, 3, 726, 363, 0, 1863, 1882, 3, 724, 362, 0, 1864, 1882, 3, 728, 364, 0, 1865, 1882, 3, 766, 383, 0, 1866, 1882, 3, 588, 294, 0, 1867, 1882, 3, 610, 305, 0, 1868, 1882, 3, 804, 402, 0, 1869, 1882, 3, 572, 286, 0, 1870, 1882, 3, 1000, 500, 0, 1871, 1882, 3, 826, 413, 0, 1872, 1882, 3, 564, 282, 0, 1873, 1882, 3, 824, 412, 0, 1874, 1882, 3, 982, 491, 0, 1875, 1882, 3, 888, 444, 0, 1876, 1882, 3, 82, 41, 0, 1877, 1882, 3, 54, 27, 0, 1878, 1882, 3, 92, 46, 0, 1879, 1882, 3, 838, 419, 0, 1880, 1882, 3, 8, 4, 0, 1881, 1764, 1, 0, 0, 0, 1881, 1765, 1, 0, 0, 0, 1881, 1766, 1, 0, 0, 0, 1881, 1767, 1, 0, 0, 0, 1881, 1768, 1, 0, 0, 0, 1881, 1769, 1, 0, 0, 0, 1881, 1770, 1, 0, 0, 0, 1881, 1771, 1, 0, 0, 0, 1881, 1772, 1, 0, 0, 0, 1881, 1773, 1, 0, 0, 0, 1881, 1774, 1, 0, 0, 0, 1881, 1775, 1, 0, 0, 0, 1881, 1776, 1, 0, 0, 0, 1881, 1777, 1, 0, 0, 0, 1881, 1778, 1, 0, 0, 0, 1881, 1779, 1, 0, 0, 0, 1881, 1780, 1, 0, 0, 0, 1881, 1781, 1, 0, 0, 0, 1881, 1782, 1, 0, 0, 0, 1881, 1783, 1, 0, 0, 0, 1881, 1784, 1, 0, 0, 0, 1881, 1785, 1, 0, 0, 0, 1881, 1786, 1, 0, 0, 0, 1881, 1787, 1, 0, 0, 0, 1881, 1788, 1, 0, 0, 0, 1881, 1789, 1, 0, 0, 0, 1881, 1790, 1, 0, 0, 0, 1881, 1791, 1, 0, 0, 0, 1881, 1792, 1, 0, 0, 0, 1881, 1793, 1, 0, 0, 0, 1881, 1794, 1, 0, 0, 0, 1881, 1795, 1, 0, 0, 0, 1881, 1796, 1, 0, 0, 0, 1881, 1797, 1, 0, 0, 0, 1881, 1798, 1, 0, 0, 0, 1881, 1799, 1, 0, 0, 0, 1881, 1800, 1, 0, 0, 0, 1881, 1801, 1, 0, 0, 0, 1881, 1802, 1, 0, 0, 0, 1881, 1803, 1, 0, 0, 0, 1881, 1804, 1, 0, 0, 0, 1881, 1805, 1, 0, 0, 0, 1881, 1806, 1, 0, 0, 0, 1881, 1807, 1, 0, 0, 0, 1881, 1808, 1, 0, 0, 0, 1881, 1809, 1, 0, 0, 0, 1881, 1810, 1, 0, 0, 0, 1881, 1811, 1, 0, 0, 0, 1881, 1812, 1, 0, 0, 0, 1881, 1813, 1, 0, 0, 0, 1881, 1814, 1, 0, 0, 0, 1881, 1815, 1, 0, 0, 0, 1881, 1816, 1, 0, 0, 0, 1881, 1817, 1, 0, 0, 0, 1881, 1818, 1, 0, 0, 0, 1881, 1819, 1, 0, 0, 0, 1881, 1820, 1, 0, 0, 0, 1881, 1821, 1, 0, 0, 0, 1881, 1822, 1, 0, 0, 0, 1881, 1823, 1, 0, 0, 0, 1881, 1824, 1, 0, 0, 0, 1881, 1825, 1, 0, 0, 0, 1881, 1826, 1, 0, 0, 0, 1881, 1827, 1, 0, 0, 0, 1881, 1828, 1, 0, 0, 0, 1881, 1829, 1, 0, 0, 0, 1881, 1830, 1, 0, 0, 0, 1881, 1831, 1, 0, 0, 0, 1881, 1832, 1, 0, 0, 0, 1881, 1833, 1, 0, 0, 0, 1881, 1834, 1, 0, 0, 0, 1881, 1835, 1, 0, 0, 0, 1881, 1836, 1, 0, 0, 0, 1881, 1837, 1, 0, 0, 0, 1881, 1838, 1, 0, 0, 0, 1881, 1839, 1, 0, 0, 0, 1881, 1840, 1, 0, 0, 0, 1881, 1841, 1, 0, 0, 0, 1881, 1842, 1, 0, 0, 0, 1881, 1843, 1, 0, 0, 0, 1881, 1844, 1, 0, 0, 0, 1881, 1845, 1, 0, 0, 0, 1881, 1846, 1, 0, 0, 0, 1881, 1847, 1, 0, 0, 0, 1881, 1848, 1, 0, 0, 0, 1881, 1849, 1, 0, 0, 0, 1881, 1850, 1, 0, 0, 0, 1881, 1851, 1, 0, 0, 0, 1881, 1852, 1, 0, 0, 0, 1881, 1853, 1, 0, 0, 0, 1881, 1854, 1, 0, 0, 0, 1881, 1855, 1, 0, 0, 0, 1881, 1856, 1, 0, 0, 0, 1881, 1857, 1, 0, 0, 0, 1881, 1858, 1, 0, 0, 0, 1881, 1859, 1, 0, 0, 0, 1881, 1860, 1, 0, 0, 0, 1881, 1861, 1, 0, 0, 0, 1881, 1862, 1, 0, 0, 0, 1881, 1863, 1, 0, 0, 0, 1881, 1864, 1, 0, 0, 0, 1881, 1865, 1, 0, 0, 0, 1881, 1866, 1, 0, 0, 0, 1881, 1867, 1, 0, 0, 0, 1881, 1868, 1, 0, 0, 0, 1881, 1869, 1, 0, 0, 0, 1881, 1870, 1, 0, 0, 0, 1881, 1871, 1, 0, 0, 0, 1881, 1872, 1, 0, 0, 0, 1881, 1873, 1, 0, 0, 0, 1881, 1874, 1, 0, 0, 0, 1881, 1875, 1, 0, 0, 0, 1881, 1876, 1, 0, 0, 0, 1881, 1877, 1, 0, 0, 0, 1881, 1878, 1, 0, 0, 0, 1881, 1879, 1, 0, 0, 0, 1881, 1880, 1, 0, 0, 0, 1882, 7, 1, 0, 0, 0, 1883, 1885, 5, 581, 0, 0, 1884, 1886, 5, 582, 0, 0, 1885, 1884, 1, 0, 0, 0, 1885, 1886, 1, 0, 0, 0, 1886, 9, 1, 0, 0, 0, 1887, 1888, 5, 433, 0, 0, 1888, 1889, 3, 1258, 629, 0, 1889, 11, 1, 0, 0, 0, 1890, 1891, 5, 46, 0, 0, 1891, 1892, 5, 318, 0, 0, 1892, 1894, 3, 1468, 734, 0, 1893, 1895, 3, 14, 7, 0, 1894, 1893, 1, 0, 0, 0, 1894, 1895, 1, 0, 0, 0, 1895, 1896, 1, 0, 0, 0, 1896, 1897, 3, 16, 8, 0, 1897, 13, 1, 0, 0, 0, 1898, 1899, 5, 105, 0, 0, 1899, 15, 1, 0, 0, 0, 1900, 1902, 3, 22, 11, 0, 1901, 1900, 1, 0, 0, 0, 1902, 1905, 1, 0, 0, 0, 1903, 1901, 1, 0, 0, 0, 1903, 1904, 1, 0, 0, 0, 1904, 17, 1, 0, 0, 0, 1905, 1903, 1, 0, 0, 0, 1906, 1908, 3, 20, 10, 0, 1907, 1906, 1, 0, 0, 0, 1908, 1911, 1, 0, 0, 0, 1909, 1907, 1, 0, 0, 0, 1909, 1910, 1, 0, 0, 0, 1910, 19, 1, 0, 0, 0, 1911, 1909, 1, 0, 0, 0, 1912, 1915, 5, 287, 0, 0, 1913, 1916, 3, 1458, 729, 0, 1914, 1916, 5, 78, 0, 0, 1915, 1913, 1, 0, 0, 0, 1915, 1914, 1, 0, 0, 0, 1916, 1948, 1, 0, 0, 0, 1917, 1918, 7, 0, 0, 0, 1918, 1919, 5, 287, 0, 0, 1919, 1948, 3, 1458, 729, 0, 1920, 1948, 7, 1, 0, 0, 1921, 1948, 7, 2, 0, 0, 1922, 1948, 7, 3, 0, 0, 1923, 1948, 7, 4, 0, 0, 1924, 1948, 7, 5, 0, 0, 1925, 1948, 7, 6, 0, 0, 1926, 1948, 7, 7, 0, 0, 1927, 1948, 7, 8, 0, 0, 1928, 1929, 5, 164, 0, 0, 1929, 1930, 5, 74, 0, 0, 1930, 1948, 3, 1464, 732, 0, 1931, 1932, 5, 371, 0, 0, 1932, 1933, 5, 368, 0, 0, 1933, 1948, 3, 1458, 729, 0, 1934, 1935, 5, 68, 0, 0, 1935, 1936, 5, 318, 0, 0, 1936, 1948, 3, 1416, 708, 0, 1937, 1938, 5, 68, 0, 0, 1938, 1939, 5, 66, 0, 0, 1939, 1948, 3, 1416, 708, 0, 1940, 1941, 5, 318, 0, 0, 1941, 1948, 3, 1472, 736, 0, 1942, 1943, 5, 134, 0, 0, 1943, 1948, 3, 1416, 708, 0, 1944, 1945, 5, 99, 0, 0, 1945, 1948, 3, 1472, 736, 0, 1946, 1948, 3, 1492, 746, 0, 1947, 1912, 1, 0, 0, 0, 1947, 1917, 1, 0, 0, 0, 1947, 1920, 1, 0, 0, 0, 1947, 1921, 1, 0, 0, 0, 1947, 1922, 1, 0, 0, 0, 1947, 1923, 1, 0, 0, 0, 1947, 1924, 1, 0, 0, 0, 1947, 1925, 1, 0, 0, 0, 1947, 1926, 1, 0, 0, 0, 1947, 1927, 1, 0, 0, 0, 1947, 1928, 1, 0, 0, 0, 1947, 1931, 1, 0, 0, 0, 1947, 1934, 1, 0, 0, 0, 1947, 1937, 1, 0, 0, 0, 1947, 1940, 1, 0, 0, 0, 1947, 1942, 1, 0, 0, 0, 1947, 1944, 1, 0, 0, 0, 1947, 1946, 1, 0, 0, 0, 1948, 21, 1, 0, 0, 0, 1949, 1960, 3, 20, 10, 0, 1950, 1951, 5, 348, 0, 0, 1951, 1960, 3, 1456, 728, 0, 1952, 1953, 5, 134, 0, 0, 1953, 1960, 3, 1472, 736, 0, 1954, 1955, 5, 318, 0, 0, 1955, 1960, 3, 1472, 736, 0, 1956, 1957, 5, 68, 0, 0, 1957, 1958, 7, 9, 0, 0, 1958, 1960, 3, 1472, 736, 0, 1959, 1949, 1, 0, 0, 0, 1959, 1950, 1, 0, 0, 0, 1959, 1952, 1, 0, 0, 0, 1959, 1954, 1, 0, 0, 0, 1959, 1956, 1, 0, 0, 0, 1960, 23, 1, 0, 0, 0, 1961, 1962, 5, 46, 0, 0, 1962, 1963, 5, 99, 0, 0, 1963, 1965, 3, 1468, 734, 0, 1964, 1966, 3, 14, 7, 0, 1965, 1964, 1, 0, 0, 0, 1965, 1966, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968, 3, 16, 8, 0, 1968, 25, 1, 0, 0, 0, 1969, 1970, 5, 138, 0, 0, 1970, 1971, 7, 10, 0, 0, 1971, 1973, 3, 1470, 735, 0, 1972, 1974, 3, 14, 7, 0, 1973, 1972, 1, 0, 0, 0, 1973, 1974, 1, 0, 0, 0, 1974, 1975, 1, 0, 0, 0, 1975, 1976, 3, 18, 9, 0, 1976, 27, 1, 0, 0, 0, 1977, 1982, 1, 0, 0, 0, 1978, 1979, 5, 68, 0, 0, 1979, 1980, 5, 175, 0, 0, 1980, 1982, 3, 1420, 710, 0, 1981, 1977, 1, 0, 0, 0, 1981, 1978, 1, 0, 0, 0, 1982, 29, 1, 0, 0, 0, 1983, 1984, 5, 138, 0, 0, 1984, 1987, 7, 10, 0, 0, 1985, 1988, 5, 30, 0, 0, 1986, 1988, 3, 1470, 735, 0, 1987, 1985, 1, 0, 0, 0, 1987, 1986, 1, 0, 0, 0, 1988, 1989, 1, 0, 0, 0, 1989, 1990, 3, 28, 14, 0, 1990, 1991, 3, 88, 44, 0, 1991, 31, 1, 0, 0, 0, 1992, 1993, 5, 138, 0, 0, 1993, 1994, 5, 442, 0, 0, 1994, 1996, 3, 1426, 713, 0, 1995, 1997, 3, 660, 330, 0, 1996, 1995, 1, 0, 0, 0, 1996, 1997, 1, 0, 0, 0, 1997, 1998, 1, 0, 0, 0, 1998, 1999, 3, 34, 17, 0, 1999, 33, 1, 0, 0, 0, 2000, 2002, 3, 36, 18, 0, 2001, 2003, 5, 315, 0, 0, 2002, 2001, 1, 0, 0, 0, 2002, 2003, 1, 0, 0, 0, 2003, 2021, 1, 0, 0, 0, 2004, 2005, 5, 309, 0, 0, 2005, 2006, 5, 94, 0, 0, 2006, 2021, 3, 1424, 712, 0, 2007, 2008, 5, 282, 0, 0, 2008, 2009, 5, 94, 0, 0, 2009, 2021, 3, 1470, 735, 0, 2010, 2011, 5, 333, 0, 0, 2011, 2012, 5, 323, 0, 0, 2012, 2021, 3, 48, 24, 0, 2013, 2015, 5, 269, 0, 0, 2014, 2013, 1, 0, 0, 0, 2014, 2015, 1, 0, 0, 0, 2015, 2016, 1, 0, 0, 0, 2016, 2017, 5, 462, 0, 0, 2017, 2018, 5, 80, 0, 0, 2018, 2019, 5, 204, 0, 0, 2019, 2021, 3, 1436, 718, 0, 2020, 2000, 1, 0, 0, 0, 2020, 2004, 1, 0, 0, 0, 2020, 2007, 1, 0, 0, 0, 2020, 2010, 1, 0, 0, 0, 2020, 2014, 1, 0, 0, 0, 2021, 35, 1, 0, 0, 0, 2022, 2026, 3, 38, 19, 0, 2023, 2025, 3, 38, 19, 0, 2024, 2023, 1, 0, 0, 0, 2025, 2028, 1, 0, 0, 0, 2026, 2024, 1, 0, 0, 0, 2026, 2027, 1, 0, 0, 0, 2027, 37, 1, 0, 0, 0, 2028, 2026, 1, 0, 0, 0, 2029, 2071, 5, 222, 0, 0, 2030, 2071, 5, 338, 0, 0, 2031, 2071, 5, 377, 0, 0, 2032, 2034, 5, 77, 0, 0, 2033, 2032, 1, 0, 0, 0, 2033, 2034, 1, 0, 0, 0, 2034, 2035, 1, 0, 0, 0, 2035, 2071, 5, 250, 0, 0, 2036, 2038, 5, 205, 0, 0, 2037, 2036, 1, 0, 0, 0, 2037, 2038, 1, 0, 0, 0, 2038, 2039, 1, 0, 0, 0, 2039, 2040, 5, 327, 0, 0, 2040, 2047, 5, 243, 0, 0, 2041, 2043, 5, 205, 0, 0, 2042, 2041, 1, 0, 0, 0, 2042, 2043, 1, 0, 0, 0, 2043, 2044, 1, 0, 0, 0, 2044, 2045, 5, 327, 0, 0, 2045, 2047, 5, 181, 0, 0, 2046, 2037, 1, 0, 0, 0, 2046, 2042, 1, 0, 0, 0, 2047, 2071, 1, 0, 0, 0, 2048, 2049, 5, 460, 0, 0, 2049, 2071, 7, 11, 0, 0, 2050, 2051, 5, 170, 0, 0, 2051, 2071, 3, 1438, 719, 0, 2052, 2053, 5, 320, 0, 0, 2053, 2071, 3, 1436, 718, 0, 2054, 2055, 5, 333, 0, 0, 2055, 2056, 3, 1436, 718, 0, 2056, 2059, 7, 12, 0, 0, 2057, 2060, 3, 1436, 718, 0, 2058, 2060, 5, 53, 0, 0, 2059, 2057, 1, 0, 0, 0, 2059, 2058, 1, 0, 0, 0, 2060, 2071, 1, 0, 0, 0, 2061, 2062, 5, 333, 0, 0, 2062, 2063, 3, 1436, 718, 0, 2063, 2064, 5, 64, 0, 0, 2064, 2065, 5, 434, 0, 0, 2065, 2071, 1, 0, 0, 0, 2066, 2067, 5, 313, 0, 0, 2067, 2071, 3, 1436, 718, 0, 2068, 2069, 5, 313, 0, 0, 2069, 2071, 5, 30, 0, 0, 2070, 2029, 1, 0, 0, 0, 2070, 2030, 1, 0, 0, 0, 2070, 2031, 1, 0, 0, 0, 2070, 2033, 1, 0, 0, 0, 2070, 2046, 1, 0, 0, 0, 2070, 2048, 1, 0, 0, 0, 2070, 2050, 1, 0, 0, 0, 2070, 2052, 1, 0, 0, 0, 2070, 2054, 1, 0, 0, 0, 2070, 2061, 1, 0, 0, 0, 2070, 2066, 1, 0, 0, 0, 2070, 2068, 1, 0, 0, 0, 2071, 39, 1, 0, 0, 0, 2072, 2073, 5, 46, 0, 0, 2073, 2074, 5, 66, 0, 0, 2074, 2076, 3, 1466, 733, 0, 2075, 2077, 3, 14, 7, 0, 2076, 2075, 1, 0, 0, 0, 2076, 2077, 1, 0, 0, 0, 2077, 2078, 1, 0, 0, 0, 2078, 2079, 3, 16, 8, 0, 2079, 41, 1, 0, 0, 0, 2080, 2081, 5, 138, 0, 0, 2081, 2082, 5, 66, 0, 0, 2082, 2083, 3, 1470, 735, 0, 2083, 2084, 3, 44, 22, 0, 2084, 2085, 5, 99, 0, 0, 2085, 2086, 3, 1472, 736, 0, 2086, 43, 1, 0, 0, 0, 2087, 2088, 7, 13, 0, 0, 2088, 45, 1, 0, 0, 0, 2089, 2090, 5, 46, 0, 0, 2090, 2092, 5, 323, 0, 0, 2091, 2093, 3, 516, 258, 0, 2092, 2091, 1, 0, 0, 0, 2092, 2093, 1, 0, 0, 0, 2093, 2100, 1, 0, 0, 0, 2094, 2096, 3, 48, 24, 0, 2095, 2094, 1, 0, 0, 0, 2095, 2096, 1, 0, 0, 0, 2096, 2097, 1, 0, 0, 0, 2097, 2098, 5, 106, 0, 0, 2098, 2101, 3, 1470, 735, 0, 2099, 2101, 3, 48, 24, 0, 2100, 2095, 1, 0, 0, 0, 2100, 2099, 1, 0, 0, 0, 2101, 2102, 1, 0, 0, 0, 2102, 2103, 3, 50, 25, 0, 2103, 47, 1, 0, 0, 0, 2104, 2106, 3, 1474, 737, 0, 2105, 2107, 3, 560, 280, 0, 2106, 2105, 1, 0, 0, 0, 2106, 2107, 1, 0, 0, 0, 2107, 49, 1, 0, 0, 0, 2108, 2110, 3, 52, 26, 0, 2109, 2108, 1, 0, 0, 0, 2110, 2113, 1, 0, 0, 0, 2111, 2109, 1, 0, 0, 0, 2111, 2112, 1, 0, 0, 0, 2112, 51, 1, 0, 0, 0, 2113, 2111, 1, 0, 0, 0, 2114, 2121, 3, 188, 94, 0, 2115, 2121, 3, 626, 313, 0, 2116, 2121, 3, 308, 154, 0, 2117, 2121, 3, 436, 218, 0, 2118, 2121, 3, 586, 293, 0, 2119, 2121, 3, 838, 419, 0, 2120, 2114, 1, 0, 0, 0, 2120, 2115, 1, 0, 0, 0, 2120, 2116, 1, 0, 0, 0, 2120, 2117, 1, 0, 0, 0, 2120, 2118, 1, 0, 0, 0, 2120, 2119, 1, 0, 0, 0, 2121, 53, 1, 0, 0, 0, 2122, 2124, 5, 333, 0, 0, 2123, 2125, 7, 14, 0, 0, 2124, 2123, 1, 0, 0, 0, 2124, 2125, 1, 0, 0, 0, 2125, 2126, 1, 0, 0, 0, 2126, 2127, 3, 56, 28, 0, 2127, 55, 1, 0, 0, 0, 2128, 2129, 5, 356, 0, 0, 2129, 2137, 3, 832, 416, 0, 2130, 2131, 5, 332, 0, 0, 2131, 2132, 5, 154, 0, 0, 2132, 2133, 5, 36, 0, 0, 2133, 2134, 5, 356, 0, 0, 2134, 2137, 3, 832, 416, 0, 2135, 2137, 3, 60, 30, 0, 2136, 2128, 1, 0, 0, 0, 2136, 2130, 1, 0, 0, 0, 2136, 2135, 1, 0, 0, 0, 2137, 57, 1, 0, 0, 0, 2138, 2141, 5, 30, 0, 0, 2139, 2141, 3, 62, 31, 0, 2140, 2138, 1, 0, 0, 0, 2140, 2139, 1, 0, 0, 0, 2141, 2143, 1, 0, 0, 0, 2142, 2144, 7, 12, 0, 0, 2143, 2142, 1, 0, 0, 0, 2143, 2144, 1, 0, 0, 0, 2144, 2147, 1, 0, 0, 0, 2145, 2148, 5, 53, 0, 0, 2146, 2148, 3, 64, 32, 0, 2147, 2145, 1, 0, 0, 0, 2147, 2146, 1, 0, 0, 0, 2147, 2148, 1, 0, 0, 0, 2148, 59, 1, 0, 0, 0, 2149, 2150, 5, 418, 0, 0, 2150, 2151, 5, 386, 0, 0, 2151, 2177, 3, 74, 37, 0, 2152, 2153, 5, 152, 0, 0, 2153, 2177, 3, 1458, 729, 0, 2154, 2155, 5, 323, 0, 0, 2155, 2177, 3, 1422, 711, 0, 2156, 2158, 5, 267, 0, 0, 2157, 2159, 3, 76, 38, 0, 2158, 2157, 1, 0, 0, 0, 2158, 2159, 1, 0, 0, 0, 2159, 2177, 1, 0, 0, 0, 2160, 2161, 5, 318, 0, 0, 2161, 2177, 3, 80, 40, 0, 2162, 2163, 5, 332, 0, 0, 2163, 2164, 5, 106, 0, 0, 2164, 2177, 3, 80, 40, 0, 2165, 2166, 5, 383, 0, 0, 2166, 2167, 5, 279, 0, 0, 2167, 2177, 3, 1276, 638, 0, 2168, 2169, 5, 356, 0, 0, 2169, 2170, 5, 337, 0, 0, 2170, 2177, 3, 1458, 729, 0, 2171, 2172, 3, 62, 31, 0, 2172, 2173, 5, 64, 0, 0, 2173, 2174, 5, 434, 0, 0, 2174, 2177, 1, 0, 0, 0, 2175, 2177, 3, 58, 29, 0, 2176, 2149, 1, 0, 0, 0, 2176, 2152, 1, 0, 0, 0, 2176, 2154, 1, 0, 0, 0, 2176, 2156, 1, 0, 0, 0, 2176, 2160, 1, 0, 0, 0, 2176, 2162, 1, 0, 0, 0, 2176, 2165, 1, 0, 0, 0, 2176, 2168, 1, 0, 0, 0, 2176, 2171, 1, 0, 0, 0, 2176, 2175, 1, 0, 0, 0, 2177, 61, 1, 0, 0, 0, 2178, 2183, 3, 1474, 737, 0, 2179, 2180, 5, 11, 0, 0, 2180, 2182, 3, 1474, 737, 0, 2181, 2179, 1, 0, 0, 0, 2182, 2185, 1, 0, 0, 0, 2183, 2181, 1, 0, 0, 0, 2183, 2184, 1, 0, 0, 0, 2184, 63, 1, 0, 0, 0, 2185, 2183, 1, 0, 0, 0, 2186, 2191, 3, 66, 33, 0, 2187, 2188, 5, 6, 0, 0, 2188, 2190, 3, 66, 33, 0, 2189, 2187, 1, 0, 0, 0, 2190, 2193, 1, 0, 0, 0, 2191, 2189, 1, 0, 0, 0, 2191, 2192, 1, 0, 0, 0, 2192, 65, 1, 0, 0, 0, 2193, 2191, 1, 0, 0, 0, 2194, 2197, 3, 72, 36, 0, 2195, 2197, 3, 322, 161, 0, 2196, 2194, 1, 0, 0, 0, 2196, 2195, 1, 0, 0, 0, 2197, 67, 1, 0, 0, 0, 2198, 2199, 5, 300, 0, 0, 2199, 2204, 7, 15, 0, 0, 2200, 2201, 5, 310, 0, 0, 2201, 2204, 5, 300, 0, 0, 2202, 2204, 5, 330, 0, 0, 2203, 2198, 1, 0, 0, 0, 2203, 2200, 1, 0, 0, 0, 2203, 2202, 1, 0, 0, 0, 2204, 69, 1, 0, 0, 0, 2205, 2210, 5, 96, 0, 0, 2206, 2210, 5, 60, 0, 0, 2207, 2210, 5, 80, 0, 0, 2208, 2210, 3, 78, 39, 0, 2209, 2205, 1, 0, 0, 0, 2209, 2206, 1, 0, 0, 0, 2209, 2207, 1, 0, 0, 0, 2209, 2208, 1, 0, 0, 0, 2210, 71, 1, 0, 0, 0, 2211, 2216, 5, 96, 0, 0, 2212, 2216, 5, 60, 0, 0, 2213, 2216, 5, 80, 0, 0, 2214, 2216, 3, 80, 40, 0, 2215, 2211, 1, 0, 0, 0, 2215, 2212, 1, 0, 0, 0, 2215, 2213, 1, 0, 0, 0, 2215, 2214, 1, 0, 0, 0, 2216, 73, 1, 0, 0, 0, 2217, 2234, 3, 1458, 729, 0, 2218, 2234, 3, 1492, 746, 0, 2219, 2220, 3, 1202, 601, 0, 2220, 2222, 3, 1458, 729, 0, 2221, 2223, 3, 1206, 603, 0, 2222, 2221, 1, 0, 0, 0, 2222, 2223, 1, 0, 0, 0, 2223, 2234, 1, 0, 0, 0, 2224, 2225, 3, 1202, 601, 0, 2225, 2226, 5, 2, 0, 0, 2226, 2227, 3, 1456, 728, 0, 2227, 2228, 5, 3, 0, 0, 2228, 2229, 3, 1458, 729, 0, 2229, 2234, 1, 0, 0, 0, 2230, 2234, 3, 322, 161, 0, 2231, 2234, 5, 53, 0, 0, 2232, 2234, 5, 254, 0, 0, 2233, 2217, 1, 0, 0, 0, 2233, 2218, 1, 0, 0, 0, 2233, 2219, 1, 0, 0, 0, 2233, 2224, 1, 0, 0, 0, 2233, 2230, 1, 0, 0, 0, 2233, 2231, 1, 0, 0, 0, 2233, 2232, 1, 0, 0, 0, 2234, 75, 1, 0, 0, 0, 2235, 2238, 3, 1458, 729, 0, 2236, 2238, 5, 53, 0, 0, 2237, 2235, 1, 0, 0, 0, 2237, 2236, 1, 0, 0, 0, 2238, 77, 1, 0, 0, 0, 2239, 2242, 3, 1486, 743, 0, 2240, 2242, 3, 1458, 729, 0, 2241, 2239, 1, 0, 0, 0, 2241, 2240, 1, 0, 0, 0, 2242, 79, 1, 0, 0, 0, 2243, 2246, 3, 1488, 744, 0, 2244, 2246, 3, 1458, 729, 0, 2245, 2243, 1, 0, 0, 0, 2245, 2244, 1, 0, 0, 0, 2246, 81, 1, 0, 0, 0, 2247, 2248, 5, 313, 0, 0, 2248, 2249, 3, 84, 42, 0, 2249, 83, 1, 0, 0, 0, 2250, 2251, 5, 418, 0, 0, 2251, 2259, 5, 386, 0, 0, 2252, 2253, 5, 356, 0, 0, 2253, 2254, 5, 244, 0, 0, 2254, 2259, 5, 251, 0, 0, 2255, 2256, 5, 332, 0, 0, 2256, 2259, 5, 106, 0, 0, 2257, 2259, 3, 86, 43, 0, 2258, 2250, 1, 0, 0, 0, 2258, 2252, 1, 0, 0, 0, 2258, 2255, 1, 0, 0, 0, 2258, 2257, 1, 0, 0, 0, 2259, 85, 1, 0, 0, 0, 2260, 2263, 5, 30, 0, 0, 2261, 2263, 3, 62, 31, 0, 2262, 2260, 1, 0, 0, 0, 2262, 2261, 1, 0, 0, 0, 2263, 87, 1, 0, 0, 0, 2264, 2265, 5, 333, 0, 0, 2265, 2268, 3, 56, 28, 0, 2266, 2268, 3, 82, 41, 0, 2267, 2264, 1, 0, 0, 0, 2267, 2266, 1, 0, 0, 0, 2268, 89, 1, 0, 0, 0, 2269, 2270, 5, 333, 0, 0, 2270, 2273, 3, 60, 30, 0, 2271, 2273, 3, 82, 41, 0, 2272, 2269, 1, 0, 0, 0, 2272, 2271, 1, 0, 0, 0, 2273, 91, 1, 0, 0, 0, 2274, 2284, 5, 335, 0, 0, 2275, 2285, 3, 62, 31, 0, 2276, 2277, 5, 418, 0, 0, 2277, 2285, 5, 386, 0, 0, 2278, 2279, 5, 356, 0, 0, 2279, 2280, 5, 244, 0, 0, 2280, 2285, 5, 251, 0, 0, 2281, 2282, 5, 332, 0, 0, 2282, 2285, 5, 106, 0, 0, 2283, 2285, 5, 30, 0, 0, 2284, 2275, 1, 0, 0, 0, 2284, 2276, 1, 0, 0, 0, 2284, 2278, 1, 0, 0, 0, 2284, 2281, 1, 0, 0, 0, 2284, 2283, 1, 0, 0, 0, 2285, 93, 1, 0, 0, 0, 2286, 2287, 5, 333, 0, 0, 2287, 2288, 5, 165, 0, 0, 2288, 2289, 3, 96, 48, 0, 2289, 2290, 3, 98, 49, 0, 2290, 95, 1, 0, 0, 0, 2291, 2294, 5, 30, 0, 0, 2292, 2294, 3, 1390, 695, 0, 2293, 2291, 1, 0, 0, 0, 2293, 2292, 1, 0, 0, 0, 2294, 97, 1, 0, 0, 0, 2295, 2296, 7, 16, 0, 0, 2296, 99, 1, 0, 0, 0, 2297, 2298, 5, 155, 0, 0, 2298, 101, 1, 0, 0, 0, 2299, 2300, 5, 187, 0, 0, 2300, 2301, 7, 17, 0, 0, 2301, 103, 1, 0, 0, 0, 2302, 2303, 5, 138, 0, 0, 2303, 2305, 5, 92, 0, 0, 2304, 2306, 3, 748, 374, 0, 2305, 2304, 1, 0, 0, 0, 2305, 2306, 1, 0, 0, 0, 2306, 2307, 1, 0, 0, 0, 2307, 2310, 3, 1118, 559, 0, 2308, 2311, 3, 106, 53, 0, 2309, 2311, 3, 116, 58, 0, 2310, 2308, 1, 0, 0, 0, 2310, 2309, 1, 0, 0, 0, 2311, 2436, 1, 0, 0, 0, 2312, 2313, 5, 138, 0, 0, 2313, 2314, 5, 92, 0, 0, 2314, 2315, 5, 30, 0, 0, 2315, 2316, 5, 68, 0, 0, 2316, 2317, 5, 351, 0, 0, 2317, 2321, 3, 1402, 701, 0, 2318, 2319, 5, 281, 0, 0, 2319, 2320, 5, 147, 0, 0, 2320, 2322, 3, 1472, 736, 0, 2321, 2318, 1, 0, 0, 0, 2321, 2322, 1, 0, 0, 0, 2322, 2323, 1, 0, 0, 0, 2323, 2324, 5, 333, 0, 0, 2324, 2325, 5, 351, 0, 0, 2325, 2327, 3, 1400, 700, 0, 2326, 2328, 3, 978, 489, 0, 2327, 2326, 1, 0, 0, 0, 2327, 2328, 1, 0, 0, 0, 2328, 2436, 1, 0, 0, 0, 2329, 2330, 5, 138, 0, 0, 2330, 2332, 5, 92, 0, 0, 2331, 2333, 3, 748, 374, 0, 2332, 2331, 1, 0, 0, 0, 2332, 2333, 1, 0, 0, 0, 2333, 2334, 1, 0, 0, 0, 2334, 2335, 3, 1406, 703, 0, 2335, 2336, 5, 435, 0, 0, 2336, 2337, 5, 285, 0, 0, 2337, 2342, 3, 1412, 706, 0, 2338, 2339, 5, 62, 0, 0, 2339, 2340, 5, 422, 0, 0, 2340, 2343, 3, 108, 54, 0, 2341, 2343, 5, 53, 0, 0, 2342, 2338, 1, 0, 0, 0, 2342, 2341, 1, 0, 0, 0, 2343, 2436, 1, 0, 0, 0, 2344, 2345, 5, 138, 0, 0, 2345, 2347, 5, 92, 0, 0, 2346, 2348, 3, 748, 374, 0, 2347, 2346, 1, 0, 0, 0, 2347, 2348, 1, 0, 0, 0, 2348, 2349, 1, 0, 0, 0, 2349, 2350, 3, 1406, 703, 0, 2350, 2351, 5, 436, 0, 0, 2351, 2352, 5, 285, 0, 0, 2352, 2354, 3, 1412, 706, 0, 2353, 2355, 7, 18, 0, 0, 2354, 2353, 1, 0, 0, 0, 2354, 2355, 1, 0, 0, 0, 2355, 2436, 1, 0, 0, 0, 2356, 2357, 5, 138, 0, 0, 2357, 2359, 5, 226, 0, 0, 2358, 2360, 3, 748, 374, 0, 2359, 2358, 1, 0, 0, 0, 2359, 2360, 1, 0, 0, 0, 2360, 2361, 1, 0, 0, 0, 2361, 2364, 3, 1412, 706, 0, 2362, 2365, 3, 106, 53, 0, 2363, 2365, 3, 118, 59, 0, 2364, 2362, 1, 0, 0, 0, 2364, 2363, 1, 0, 0, 0, 2365, 2436, 1, 0, 0, 0, 2366, 2367, 5, 138, 0, 0, 2367, 2368, 5, 226, 0, 0, 2368, 2369, 5, 30, 0, 0, 2369, 2370, 5, 68, 0, 0, 2370, 2371, 5, 351, 0, 0, 2371, 2375, 3, 1402, 701, 0, 2372, 2373, 5, 281, 0, 0, 2373, 2374, 5, 147, 0, 0, 2374, 2376, 3, 1472, 736, 0, 2375, 2372, 1, 0, 0, 0, 2375, 2376, 1, 0, 0, 0, 2376, 2377, 1, 0, 0, 0, 2377, 2378, 5, 333, 0, 0, 2378, 2379, 5, 351, 0, 0, 2379, 2381, 3, 1402, 701, 0, 2380, 2382, 3, 978, 489, 0, 2381, 2380, 1, 0, 0, 0, 2381, 2382, 1, 0, 0, 0, 2382, 2436, 1, 0, 0, 0, 2383, 2384, 5, 138, 0, 0, 2384, 2386, 5, 328, 0, 0, 2385, 2387, 3, 748, 374, 0, 2386, 2385, 1, 0, 0, 0, 2386, 2387, 1, 0, 0, 0, 2387, 2388, 1, 0, 0, 0, 2388, 2389, 3, 1412, 706, 0, 2389, 2390, 3, 106, 53, 0, 2390, 2436, 1, 0, 0, 0, 2391, 2392, 5, 138, 0, 0, 2392, 2394, 5, 376, 0, 0, 2393, 2395, 3, 748, 374, 0, 2394, 2393, 1, 0, 0, 0, 2394, 2395, 1, 0, 0, 0, 2395, 2396, 1, 0, 0, 0, 2396, 2397, 3, 1410, 705, 0, 2397, 2398, 3, 106, 53, 0, 2398, 2436, 1, 0, 0, 0, 2399, 2400, 5, 138, 0, 0, 2400, 2401, 5, 259, 0, 0, 2401, 2403, 5, 376, 0, 0, 2402, 2404, 3, 748, 374, 0, 2403, 2402, 1, 0, 0, 0, 2403, 2404, 1, 0, 0, 0, 2404, 2405, 1, 0, 0, 0, 2405, 2406, 3, 1410, 705, 0, 2406, 2407, 3, 106, 53, 0, 2407, 2436, 1, 0, 0, 0, 2408, 2409, 5, 138, 0, 0, 2409, 2410, 5, 259, 0, 0, 2410, 2411, 5, 376, 0, 0, 2411, 2412, 5, 30, 0, 0, 2412, 2413, 5, 68, 0, 0, 2413, 2414, 5, 351, 0, 0, 2414, 2418, 3, 1402, 701, 0, 2415, 2416, 5, 281, 0, 0, 2416, 2417, 5, 147, 0, 0, 2417, 2419, 3, 1472, 736, 0, 2418, 2415, 1, 0, 0, 0, 2418, 2419, 1, 0, 0, 0, 2419, 2420, 1, 0, 0, 0, 2420, 2421, 5, 333, 0, 0, 2421, 2422, 5, 351, 0, 0, 2422, 2424, 3, 1400, 700, 0, 2423, 2425, 3, 978, 489, 0, 2424, 2423, 1, 0, 0, 0, 2424, 2425, 1, 0, 0, 0, 2425, 2436, 1, 0, 0, 0, 2426, 2427, 5, 138, 0, 0, 2427, 2428, 5, 63, 0, 0, 2428, 2430, 5, 92, 0, 0, 2429, 2431, 3, 748, 374, 0, 2430, 2429, 1, 0, 0, 0, 2430, 2431, 1, 0, 0, 0, 2431, 2432, 1, 0, 0, 0, 2432, 2433, 3, 1118, 559, 0, 2433, 2434, 3, 106, 53, 0, 2434, 2436, 1, 0, 0, 0, 2435, 2302, 1, 0, 0, 0, 2435, 2312, 1, 0, 0, 0, 2435, 2329, 1, 0, 0, 0, 2435, 2344, 1, 0, 0, 0, 2435, 2356, 1, 0, 0, 0, 2435, 2366, 1, 0, 0, 0, 2435, 2383, 1, 0, 0, 0, 2435, 2391, 1, 0, 0, 0, 2435, 2399, 1, 0, 0, 0, 2435, 2408, 1, 0, 0, 0, 2435, 2426, 1, 0, 0, 0, 2436, 105, 1, 0, 0, 0, 2437, 2442, 3, 120, 60, 0, 2438, 2439, 5, 6, 0, 0, 2439, 2441, 3, 120, 60, 0, 2440, 2438, 1, 0, 0, 0, 2441, 2444, 1, 0, 0, 0, 2442, 2440, 1, 0, 0, 0, 2442, 2443, 1, 0, 0, 0, 2443, 107, 1, 0, 0, 0, 2444, 2442, 1, 0, 0, 0, 2445, 2446, 5, 68, 0, 0, 2446, 2455, 3, 1178, 589, 0, 2447, 2448, 5, 64, 0, 0, 2448, 2449, 3, 110, 55, 0, 2449, 2450, 5, 94, 0, 0, 2450, 2451, 3, 110, 55, 0, 2451, 2455, 1, 0, 0, 0, 2452, 2453, 5, 105, 0, 0, 2453, 2455, 3, 114, 57, 0, 2454, 2445, 1, 0, 0, 0, 2454, 2447, 1, 0, 0, 0, 2454, 2452, 1, 0, 0, 0, 2455, 109, 1, 0, 0, 0, 2456, 2457, 5, 2, 0, 0, 2457, 2462, 3, 112, 56, 0, 2458, 2459, 5, 6, 0, 0, 2459, 2461, 3, 112, 56, 0, 2460, 2458, 1, 0, 0, 0, 2461, 2464, 1, 0, 0, 0, 2462, 2460, 1, 0, 0, 0, 2462, 2463, 1, 0, 0, 0, 2463, 2465, 1, 0, 0, 0, 2464, 2462, 1, 0, 0, 0, 2465, 2466, 5, 3, 0, 0, 2466, 111, 1, 0, 0, 0, 2467, 2471, 3, 1178, 589, 0, 2468, 2471, 5, 262, 0, 0, 2469, 2471, 5, 260, 0, 0, 2470, 2467, 1, 0, 0, 0, 2470, 2468, 1, 0, 0, 0, 2470, 2469, 1, 0, 0, 0, 2471, 113, 1, 0, 0, 0, 2472, 2473, 5, 2, 0, 0, 2473, 2474, 5, 533, 0, 0, 2474, 2475, 3, 322, 161, 0, 2475, 2476, 5, 6, 0, 0, 2476, 2477, 5, 534, 0, 0, 2477, 2478, 3, 322, 161, 0, 2478, 2479, 5, 3, 0, 0, 2479, 115, 1, 0, 0, 0, 2480, 2481, 5, 435, 0, 0, 2481, 2482, 5, 285, 0, 0, 2482, 2483, 3, 1412, 706, 0, 2483, 2484, 3, 144, 72, 0, 2484, 2489, 1, 0, 0, 0, 2485, 2486, 5, 436, 0, 0, 2486, 2487, 5, 285, 0, 0, 2487, 2489, 3, 1412, 706, 0, 2488, 2480, 1, 0, 0, 0, 2488, 2485, 1, 0, 0, 0, 2489, 117, 1, 0, 0, 0, 2490, 2491, 5, 435, 0, 0, 2491, 2492, 5, 285, 0, 0, 2492, 2493, 3, 1412, 706, 0, 2493, 119, 1, 0, 0, 0, 2494, 2497, 5, 133, 0, 0, 2495, 2496, 5, 45, 0, 0, 2496, 2498, 3, 1436, 718, 0, 2497, 2495, 1, 0, 0, 0, 2497, 2498, 1, 0, 0, 0, 2498, 2499, 1, 0, 0, 0, 2499, 2712, 3, 236, 118, 0, 2500, 2501, 5, 138, 0, 0, 2501, 2502, 5, 45, 0, 0, 2502, 2503, 3, 1436, 718, 0, 2503, 2504, 3, 476, 238, 0, 2504, 2712, 1, 0, 0, 0, 2505, 2506, 5, 372, 0, 0, 2506, 2507, 5, 45, 0, 0, 2507, 2712, 3, 1436, 718, 0, 2508, 2509, 5, 191, 0, 0, 2509, 2511, 5, 45, 0, 0, 2510, 2512, 3, 748, 374, 0, 2511, 2510, 1, 0, 0, 0, 2511, 2512, 1, 0, 0, 0, 2512, 2513, 1, 0, 0, 0, 2513, 2515, 3, 1436, 718, 0, 2514, 2516, 3, 124, 62, 0, 2515, 2514, 1, 0, 0, 0, 2515, 2516, 1, 0, 0, 0, 2516, 2712, 1, 0, 0, 0, 2517, 2518, 5, 333, 0, 0, 2518, 2519, 5, 379, 0, 0, 2519, 2712, 5, 277, 0, 0, 2520, 2521, 5, 158, 0, 0, 2521, 2522, 5, 80, 0, 0, 2522, 2712, 3, 1436, 718, 0, 2523, 2524, 5, 333, 0, 0, 2524, 2525, 5, 379, 0, 0, 2525, 2712, 5, 158, 0, 0, 2526, 2527, 5, 333, 0, 0, 2527, 2712, 7, 19, 0, 0, 2528, 2530, 5, 193, 0, 0, 2529, 2531, 7, 20, 0, 0, 2530, 2529, 1, 0, 0, 0, 2530, 2531, 1, 0, 0, 0, 2531, 2532, 1, 0, 0, 0, 2532, 2712, 5, 357, 0, 0, 2533, 2534, 5, 186, 0, 0, 2534, 2538, 5, 357, 0, 0, 2535, 2539, 5, 30, 0, 0, 2536, 2539, 5, 99, 0, 0, 2537, 2539, 3, 1436, 718, 0, 2538, 2535, 1, 0, 0, 0, 2538, 2536, 1, 0, 0, 0, 2538, 2537, 1, 0, 0, 0, 2539, 2712, 1, 0, 0, 0, 2540, 2541, 5, 193, 0, 0, 2541, 2542, 7, 20, 0, 0, 2542, 2543, 5, 321, 0, 0, 2543, 2712, 3, 1436, 718, 0, 2544, 2545, 5, 186, 0, 0, 2545, 2546, 5, 321, 0, 0, 2546, 2712, 3, 1436, 718, 0, 2547, 2549, 5, 269, 0, 0, 2548, 2547, 1, 0, 0, 0, 2548, 2549, 1, 0, 0, 0, 2549, 2550, 1, 0, 0, 0, 2550, 2551, 5, 228, 0, 0, 2551, 2712, 3, 1412, 706, 0, 2552, 2553, 5, 275, 0, 0, 2553, 2712, 3, 558, 279, 0, 2554, 2555, 5, 77, 0, 0, 2555, 2712, 5, 275, 0, 0, 2556, 2557, 5, 282, 0, 0, 2557, 2558, 5, 94, 0, 0, 2558, 2712, 3, 1470, 735, 0, 2559, 2560, 5, 333, 0, 0, 2560, 2561, 5, 351, 0, 0, 2561, 2712, 3, 1400, 700, 0, 2562, 2563, 5, 333, 0, 0, 2563, 2712, 3, 132, 66, 0, 2564, 2565, 5, 313, 0, 0, 2565, 2712, 3, 132, 66, 0, 2566, 2567, 5, 312, 0, 0, 2567, 2568, 5, 219, 0, 0, 2568, 2712, 3, 130, 65, 0, 2569, 2570, 5, 193, 0, 0, 2570, 2571, 5, 414, 0, 0, 2571, 2572, 5, 251, 0, 0, 2572, 2712, 5, 327, 0, 0, 2573, 2574, 5, 186, 0, 0, 2574, 2575, 5, 414, 0, 0, 2575, 2576, 5, 251, 0, 0, 2576, 2712, 5, 327, 0, 0, 2577, 2578, 5, 209, 0, 0, 2578, 2579, 5, 414, 0, 0, 2579, 2580, 5, 251, 0, 0, 2580, 2712, 5, 327, 0, 0, 2581, 2582, 5, 269, 0, 0, 2582, 2583, 5, 209, 0, 0, 2583, 2584, 5, 414, 0, 0, 2584, 2585, 5, 251, 0, 0, 2585, 2712, 5, 327, 0, 0, 2586, 2588, 5, 191, 0, 0, 2587, 2589, 5, 44, 0, 0, 2588, 2587, 1, 0, 0, 0, 2588, 2589, 1, 0, 0, 0, 2589, 2591, 1, 0, 0, 0, 2590, 2592, 3, 748, 374, 0, 2591, 2590, 1, 0, 0, 0, 2591, 2592, 1, 0, 0, 0, 2592, 2593, 1, 0, 0, 0, 2593, 2595, 3, 1432, 716, 0, 2594, 2596, 3, 124, 62, 0, 2595, 2594, 1, 0, 0, 0, 2595, 2596, 1, 0, 0, 0, 2596, 2712, 1, 0, 0, 0, 2597, 2599, 5, 133, 0, 0, 2598, 2600, 5, 44, 0, 0, 2599, 2598, 1, 0, 0, 0, 2599, 2600, 1, 0, 0, 0, 2600, 2602, 1, 0, 0, 0, 2601, 2603, 3, 516, 258, 0, 2602, 2601, 1, 0, 0, 0, 2602, 2603, 1, 0, 0, 0, 2603, 2604, 1, 0, 0, 0, 2604, 2712, 3, 206, 103, 0, 2605, 2607, 5, 138, 0, 0, 2606, 2608, 5, 44, 0, 0, 2607, 2606, 1, 0, 0, 0, 2607, 2608, 1, 0, 0, 0, 2608, 2609, 1, 0, 0, 0, 2609, 2610, 3, 1432, 716, 0, 2610, 2611, 3, 122, 61, 0, 2611, 2712, 1, 0, 0, 0, 2612, 2614, 5, 138, 0, 0, 2613, 2615, 5, 44, 0, 0, 2614, 2613, 1, 0, 0, 0, 2614, 2615, 1, 0, 0, 0, 2615, 2616, 1, 0, 0, 0, 2616, 2617, 3, 1432, 716, 0, 2617, 2618, 7, 21, 0, 0, 2618, 2619, 5, 77, 0, 0, 2619, 2620, 5, 78, 0, 0, 2620, 2712, 1, 0, 0, 0, 2621, 2623, 5, 138, 0, 0, 2622, 2624, 5, 44, 0, 0, 2623, 2622, 1, 0, 0, 0, 2623, 2624, 1, 0, 0, 0, 2624, 2625, 1, 0, 0, 0, 2625, 2626, 3, 1432, 716, 0, 2626, 2627, 5, 191, 0, 0, 2627, 2629, 5, 437, 0, 0, 2628, 2630, 3, 748, 374, 0, 2629, 2628, 1, 0, 0, 0, 2629, 2630, 1, 0, 0, 0, 2630, 2712, 1, 0, 0, 0, 2631, 2633, 5, 138, 0, 0, 2632, 2634, 5, 44, 0, 0, 2633, 2632, 1, 0, 0, 0, 2633, 2634, 1, 0, 0, 0, 2634, 2635, 1, 0, 0, 0, 2635, 2636, 3, 1432, 716, 0, 2636, 2637, 5, 333, 0, 0, 2637, 2638, 5, 342, 0, 0, 2638, 2639, 3, 1464, 732, 0, 2639, 2712, 1, 0, 0, 0, 2640, 2642, 5, 138, 0, 0, 2641, 2643, 5, 44, 0, 0, 2642, 2641, 1, 0, 0, 0, 2642, 2643, 1, 0, 0, 0, 2643, 2644, 1, 0, 0, 0, 2644, 2645, 3, 1432, 716, 0, 2645, 2646, 7, 22, 0, 0, 2646, 2647, 3, 132, 66, 0, 2647, 2712, 1, 0, 0, 0, 2648, 2650, 5, 138, 0, 0, 2649, 2651, 5, 44, 0, 0, 2650, 2649, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 2652, 1, 0, 0, 0, 2652, 2653, 3, 1432, 716, 0, 2653, 2654, 5, 333, 0, 0, 2654, 2655, 5, 345, 0, 0, 2655, 2656, 3, 1474, 737, 0, 2656, 2712, 1, 0, 0, 0, 2657, 2659, 5, 138, 0, 0, 2658, 2660, 5, 44, 0, 0, 2659, 2658, 1, 0, 0, 0, 2659, 2660, 1, 0, 0, 0, 2660, 2661, 1, 0, 0, 0, 2661, 2662, 3, 1432, 716, 0, 2662, 2663, 5, 133, 0, 0, 2663, 2664, 5, 438, 0, 0, 2664, 2665, 3, 222, 111, 0, 2665, 2666, 5, 36, 0, 0, 2666, 2668, 5, 219, 0, 0, 2667, 2669, 3, 314, 157, 0, 2668, 2667, 1, 0, 0, 0, 2668, 2669, 1, 0, 0, 0, 2669, 2712, 1, 0, 0, 0, 2670, 2672, 5, 138, 0, 0, 2671, 2673, 5, 44, 0, 0, 2672, 2671, 1, 0, 0, 0, 2672, 2673, 1, 0, 0, 0, 2673, 2674, 1, 0, 0, 0, 2674, 2675, 3, 1432, 716, 0, 2675, 2676, 3, 140, 70, 0, 2676, 2712, 1, 0, 0, 0, 2677, 2679, 5, 138, 0, 0, 2678, 2680, 5, 44, 0, 0, 2679, 2678, 1, 0, 0, 0, 2679, 2680, 1, 0, 0, 0, 2680, 2681, 1, 0, 0, 0, 2681, 2682, 3, 1432, 716, 0, 2682, 2683, 5, 191, 0, 0, 2683, 2685, 5, 219, 0, 0, 2684, 2686, 3, 748, 374, 0, 2685, 2684, 1, 0, 0, 0, 2685, 2686, 1, 0, 0, 0, 2686, 2712, 1, 0, 0, 0, 2687, 2689, 5, 138, 0, 0, 2688, 2690, 5, 44, 0, 0, 2689, 2688, 1, 0, 0, 0, 2689, 2690, 1, 0, 0, 0, 2690, 2691, 1, 0, 0, 0, 2691, 2693, 3, 1432, 716, 0, 2692, 2694, 3, 768, 384, 0, 2693, 2692, 1, 0, 0, 0, 2693, 2694, 1, 0, 0, 0, 2694, 2695, 1, 0, 0, 0, 2695, 2696, 5, 360, 0, 0, 2696, 2698, 3, 1168, 584, 0, 2697, 2699, 3, 126, 63, 0, 2698, 2697, 1, 0, 0, 0, 2698, 2699, 1, 0, 0, 0, 2699, 2701, 1, 0, 0, 0, 2700, 2702, 3, 128, 64, 0, 2701, 2700, 1, 0, 0, 0, 2701, 2702, 1, 0, 0, 0, 2702, 2712, 1, 0, 0, 0, 2703, 2705, 5, 138, 0, 0, 2704, 2706, 5, 44, 0, 0, 2705, 2704, 1, 0, 0, 0, 2705, 2706, 1, 0, 0, 0, 2706, 2707, 1, 0, 0, 0, 2707, 2708, 3, 1432, 716, 0, 2708, 2709, 3, 372, 186, 0, 2709, 2712, 1, 0, 0, 0, 2710, 2712, 3, 372, 186, 0, 2711, 2494, 1, 0, 0, 0, 2711, 2500, 1, 0, 0, 0, 2711, 2505, 1, 0, 0, 0, 2711, 2508, 1, 0, 0, 0, 2711, 2517, 1, 0, 0, 0, 2711, 2520, 1, 0, 0, 0, 2711, 2523, 1, 0, 0, 0, 2711, 2526, 1, 0, 0, 0, 2711, 2528, 1, 0, 0, 0, 2711, 2533, 1, 0, 0, 0, 2711, 2540, 1, 0, 0, 0, 2711, 2544, 1, 0, 0, 0, 2711, 2548, 1, 0, 0, 0, 2711, 2552, 1, 0, 0, 0, 2711, 2554, 1, 0, 0, 0, 2711, 2556, 1, 0, 0, 0, 2711, 2559, 1, 0, 0, 0, 2711, 2562, 1, 0, 0, 0, 2711, 2564, 1, 0, 0, 0, 2711, 2566, 1, 0, 0, 0, 2711, 2569, 1, 0, 0, 0, 2711, 2573, 1, 0, 0, 0, 2711, 2577, 1, 0, 0, 0, 2711, 2581, 1, 0, 0, 0, 2711, 2586, 1, 0, 0, 0, 2711, 2597, 1, 0, 0, 0, 2711, 2605, 1, 0, 0, 0, 2711, 2612, 1, 0, 0, 0, 2711, 2621, 1, 0, 0, 0, 2711, 2631, 1, 0, 0, 0, 2711, 2640, 1, 0, 0, 0, 2711, 2648, 1, 0, 0, 0, 2711, 2657, 1, 0, 0, 0, 2711, 2670, 1, 0, 0, 0, 2711, 2677, 1, 0, 0, 0, 2711, 2687, 1, 0, 0, 0, 2711, 2703, 1, 0, 0, 0, 2711, 2710, 1, 0, 0, 0, 2712, 121, 1, 0, 0, 0, 2713, 2714, 5, 333, 0, 0, 2714, 2715, 5, 53, 0, 0, 2715, 2719, 3, 1212, 606, 0, 2716, 2717, 5, 191, 0, 0, 2717, 2719, 5, 53, 0, 0, 2718, 2713, 1, 0, 0, 0, 2718, 2716, 1, 0, 0, 0, 2719, 123, 1, 0, 0, 0, 2720, 2721, 7, 23, 0, 0, 2721, 125, 1, 0, 0, 0, 2722, 2723, 5, 43, 0, 0, 2723, 2724, 3, 558, 279, 0, 2724, 127, 1, 0, 0, 0, 2725, 2726, 5, 100, 0, 0, 2726, 2727, 3, 1212, 606, 0, 2727, 129, 1, 0, 0, 0, 2728, 2735, 5, 270, 0, 0, 2729, 2735, 5, 113, 0, 0, 2730, 2735, 5, 53, 0, 0, 2731, 2732, 5, 100, 0, 0, 2732, 2733, 5, 226, 0, 0, 2733, 2735, 3, 1436, 718, 0, 2734, 2728, 1, 0, 0, 0, 2734, 2729, 1, 0, 0, 0, 2734, 2730, 1, 0, 0, 0, 2734, 2731, 1, 0, 0, 0, 2735, 131, 1, 0, 0, 0, 2736, 2737, 5, 2, 0, 0, 2737, 2738, 3, 136, 68, 0, 2738, 2739, 5, 3, 0, 0, 2739, 133, 1, 0, 0, 0, 2740, 2741, 5, 105, 0, 0, 2741, 2742, 3, 132, 66, 0, 2742, 135, 1, 0, 0, 0, 2743, 2748, 3, 138, 69, 0, 2744, 2745, 5, 6, 0, 0, 2745, 2747, 3, 138, 69, 0, 2746, 2744, 1, 0, 0, 0, 2747, 2750, 1, 0, 0, 0, 2748, 2746, 1, 0, 0, 0, 2748, 2749, 1, 0, 0, 0, 2749, 137, 1, 0, 0, 0, 2750, 2748, 1, 0, 0, 0, 2751, 2760, 3, 1490, 745, 0, 2752, 2753, 5, 10, 0, 0, 2753, 2761, 3, 502, 251, 0, 2754, 2755, 5, 11, 0, 0, 2755, 2758, 3, 1490, 745, 0, 2756, 2757, 5, 10, 0, 0, 2757, 2759, 3, 502, 251, 0, 2758, 2756, 1, 0, 0, 0, 2758, 2759, 1, 0, 0, 0, 2759, 2761, 1, 0, 0, 0, 2760, 2752, 1, 0, 0, 0, 2760, 2754, 1, 0, 0, 0, 2760, 2761, 1, 0, 0, 0, 2761, 139, 1, 0, 0, 0, 2762, 2764, 3, 142, 71, 0, 2763, 2762, 1, 0, 0, 0, 2764, 2765, 1, 0, 0, 0, 2765, 2763, 1, 0, 0, 0, 2765, 2766, 1, 0, 0, 0, 2766, 141, 1, 0, 0, 0, 2767, 2772, 5, 314, 0, 0, 2768, 2770, 3, 14, 7, 0, 2769, 2768, 1, 0, 0, 0, 2769, 2770, 1, 0, 0, 0, 2770, 2771, 1, 0, 0, 0, 2771, 2773, 3, 322, 161, 0, 2772, 2769, 1, 0, 0, 0, 2772, 2773, 1, 0, 0, 0, 2773, 2781, 1, 0, 0, 0, 2774, 2778, 5, 333, 0, 0, 2775, 2779, 3, 318, 159, 0, 2776, 2777, 5, 438, 0, 0, 2777, 2779, 3, 222, 111, 0, 2778, 2775, 1, 0, 0, 0, 2778, 2776, 1, 0, 0, 0, 2779, 2781, 1, 0, 0, 0, 2780, 2767, 1, 0, 0, 0, 2780, 2774, 1, 0, 0, 0, 2781, 143, 1, 0, 0, 0, 2782, 2783, 5, 62, 0, 0, 2783, 2784, 5, 422, 0, 0, 2784, 2785, 5, 105, 0, 0, 2785, 2786, 5, 2, 0, 0, 2786, 2787, 3, 148, 74, 0, 2787, 2788, 5, 3, 0, 0, 2788, 2809, 1, 0, 0, 0, 2789, 2790, 5, 62, 0, 0, 2790, 2791, 5, 422, 0, 0, 2791, 2792, 5, 68, 0, 0, 2792, 2793, 5, 2, 0, 0, 2793, 2794, 3, 1328, 664, 0, 2794, 2795, 5, 3, 0, 0, 2795, 2809, 1, 0, 0, 0, 2796, 2797, 5, 62, 0, 0, 2797, 2798, 5, 422, 0, 0, 2798, 2799, 5, 64, 0, 0, 2799, 2800, 5, 2, 0, 0, 2800, 2801, 3, 1328, 664, 0, 2801, 2802, 5, 3, 0, 0, 2802, 2803, 5, 94, 0, 0, 2803, 2804, 5, 2, 0, 0, 2804, 2805, 3, 1328, 664, 0, 2805, 2806, 5, 3, 0, 0, 2806, 2809, 1, 0, 0, 0, 2807, 2809, 5, 53, 0, 0, 2808, 2782, 1, 0, 0, 0, 2808, 2789, 1, 0, 0, 0, 2808, 2796, 1, 0, 0, 0, 2808, 2807, 1, 0, 0, 0, 2809, 145, 1, 0, 0, 0, 2810, 2811, 3, 1488, 744, 0, 2811, 2812, 3, 1456, 728, 0, 2812, 147, 1, 0, 0, 0, 2813, 2818, 3, 146, 73, 0, 2814, 2815, 5, 6, 0, 0, 2815, 2817, 3, 146, 73, 0, 2816, 2814, 1, 0, 0, 0, 2817, 2820, 1, 0, 0, 0, 2818, 2816, 1, 0, 0, 0, 2818, 2819, 1, 0, 0, 0, 2819, 149, 1, 0, 0, 0, 2820, 2818, 1, 0, 0, 0, 2821, 2822, 5, 138, 0, 0, 2822, 2823, 5, 360, 0, 0, 2823, 2824, 3, 558, 279, 0, 2824, 2825, 3, 152, 76, 0, 2825, 151, 1, 0, 0, 0, 2826, 2831, 3, 154, 77, 0, 2827, 2828, 5, 6, 0, 0, 2828, 2830, 3, 154, 77, 0, 2829, 2827, 1, 0, 0, 0, 2830, 2833, 1, 0, 0, 0, 2831, 2829, 1, 0, 0, 0, 2831, 2832, 1, 0, 0, 0, 2832, 153, 1, 0, 0, 0, 2833, 2831, 1, 0, 0, 0, 2834, 2835, 5, 133, 0, 0, 2835, 2836, 5, 143, 0, 0, 2836, 2838, 3, 1152, 576, 0, 2837, 2839, 3, 124, 62, 0, 2838, 2837, 1, 0, 0, 0, 2838, 2839, 1, 0, 0, 0, 2839, 2864, 1, 0, 0, 0, 2840, 2841, 5, 191, 0, 0, 2841, 2843, 5, 143, 0, 0, 2842, 2844, 3, 748, 374, 0, 2843, 2842, 1, 0, 0, 0, 2843, 2844, 1, 0, 0, 0, 2844, 2845, 1, 0, 0, 0, 2845, 2847, 3, 1474, 737, 0, 2846, 2848, 3, 124, 62, 0, 2847, 2846, 1, 0, 0, 0, 2847, 2848, 1, 0, 0, 0, 2848, 2864, 1, 0, 0, 0, 2849, 2850, 5, 138, 0, 0, 2850, 2851, 5, 143, 0, 0, 2851, 2853, 3, 1474, 737, 0, 2852, 2854, 3, 768, 384, 0, 2853, 2852, 1, 0, 0, 0, 2853, 2854, 1, 0, 0, 0, 2854, 2855, 1, 0, 0, 0, 2855, 2856, 5, 360, 0, 0, 2856, 2858, 3, 1168, 584, 0, 2857, 2859, 3, 126, 63, 0, 2858, 2857, 1, 0, 0, 0, 2858, 2859, 1, 0, 0, 0, 2859, 2861, 1, 0, 0, 0, 2860, 2862, 3, 124, 62, 0, 2861, 2860, 1, 0, 0, 0, 2861, 2862, 1, 0, 0, 0, 2862, 2864, 1, 0, 0, 0, 2863, 2834, 1, 0, 0, 0, 2863, 2840, 1, 0, 0, 0, 2863, 2849, 1, 0, 0, 0, 2864, 155, 1, 0, 0, 0, 2865, 2868, 5, 157, 0, 0, 2866, 2869, 3, 994, 497, 0, 2867, 2869, 5, 30, 0, 0, 2868, 2866, 1, 0, 0, 0, 2868, 2867, 1, 0, 0, 0, 2869, 157, 1, 0, 0, 0, 2870, 2872, 5, 169, 0, 0, 2871, 2873, 3, 172, 86, 0, 2872, 2871, 1, 0, 0, 0, 2872, 2873, 1, 0, 0, 0, 2873, 2874, 1, 0, 0, 0, 2874, 2876, 3, 1406, 703, 0, 2875, 2877, 3, 240, 120, 0, 2876, 2875, 1, 0, 0, 0, 2876, 2877, 1, 0, 0, 0, 2877, 2878, 1, 0, 0, 0, 2878, 2880, 3, 160, 80, 0, 2879, 2881, 3, 162, 81, 0, 2880, 2879, 1, 0, 0, 0, 2880, 2881, 1, 0, 0, 0, 2881, 2882, 1, 0, 0, 0, 2882, 2884, 3, 164, 82, 0, 2883, 2885, 3, 174, 87, 0, 2884, 2883, 1, 0, 0, 0, 2884, 2885, 1, 0, 0, 0, 2885, 2887, 1, 0, 0, 0, 2886, 2888, 3, 14, 7, 0, 2887, 2886, 1, 0, 0, 0, 2887, 2888, 1, 0, 0, 0, 2888, 2889, 1, 0, 0, 0, 2889, 2891, 3, 166, 83, 0, 2890, 2892, 3, 1144, 572, 0, 2891, 2890, 1, 0, 0, 0, 2891, 2892, 1, 0, 0, 0, 2892, 2908, 1, 0, 0, 0, 2893, 2894, 5, 169, 0, 0, 2894, 2895, 5, 2, 0, 0, 2895, 2896, 3, 942, 471, 0, 2896, 2897, 5, 3, 0, 0, 2897, 2899, 5, 94, 0, 0, 2898, 2900, 3, 162, 81, 0, 2899, 2898, 1, 0, 0, 0, 2899, 2900, 1, 0, 0, 0, 2900, 2901, 1, 0, 0, 0, 2901, 2903, 3, 164, 82, 0, 2902, 2904, 3, 14, 7, 0, 2903, 2902, 1, 0, 0, 0, 2903, 2904, 1, 0, 0, 0, 2904, 2905, 1, 0, 0, 0, 2905, 2906, 3, 166, 83, 0, 2906, 2908, 1, 0, 0, 0, 2907, 2870, 1, 0, 0, 0, 2907, 2893, 1, 0, 0, 0, 2908, 159, 1, 0, 0, 0, 2909, 2910, 7, 24, 0, 0, 2910, 161, 1, 0, 0, 0, 2911, 2912, 5, 297, 0, 0, 2912, 163, 1, 0, 0, 0, 2913, 2917, 3, 1458, 729, 0, 2914, 2917, 5, 343, 0, 0, 2915, 2917, 5, 344, 0, 0, 2916, 2913, 1, 0, 0, 0, 2916, 2914, 1, 0, 0, 0, 2916, 2915, 1, 0, 0, 0, 2917, 165, 1, 0, 0, 0, 2918, 2924, 3, 168, 84, 0, 2919, 2920, 5, 2, 0, 0, 2920, 2921, 3, 178, 89, 0, 2921, 2922, 5, 3, 0, 0, 2922, 2924, 1, 0, 0, 0, 2923, 2918, 1, 0, 0, 0, 2923, 2919, 1, 0, 0, 0, 2924, 167, 1, 0, 0, 0, 2925, 2927, 3, 170, 85, 0, 2926, 2925, 1, 0, 0, 0, 2927, 2930, 1, 0, 0, 0, 2928, 2926, 1, 0, 0, 0, 2928, 2929, 1, 0, 0, 0, 2929, 169, 1, 0, 0, 0, 2930, 2928, 1, 0, 0, 0, 2931, 2971, 5, 107, 0, 0, 2932, 2971, 5, 112, 0, 0, 2933, 2935, 5, 183, 0, 0, 2934, 2936, 3, 872, 436, 0, 2935, 2934, 1, 0, 0, 0, 2935, 2936, 1, 0, 0, 0, 2936, 2937, 1, 0, 0, 0, 2937, 2971, 3, 1458, 729, 0, 2938, 2940, 5, 78, 0, 0, 2939, 2941, 3, 872, 436, 0, 2940, 2939, 1, 0, 0, 0, 2940, 2941, 1, 0, 0, 0, 2941, 2942, 1, 0, 0, 0, 2942, 2971, 3, 1458, 729, 0, 2943, 2971, 5, 171, 0, 0, 2944, 2971, 5, 216, 0, 0, 2945, 2947, 5, 298, 0, 0, 2946, 2948, 3, 872, 436, 0, 2947, 2946, 1, 0, 0, 0, 2947, 2948, 1, 0, 0, 0, 2948, 2949, 1, 0, 0, 0, 2949, 2971, 3, 1458, 729, 0, 2950, 2952, 5, 197, 0, 0, 2951, 2953, 3, 872, 436, 0, 2952, 2951, 1, 0, 0, 0, 2952, 2953, 1, 0, 0, 0, 2953, 2954, 1, 0, 0, 0, 2954, 2971, 3, 1458, 729, 0, 2955, 2956, 5, 209, 0, 0, 2956, 2957, 5, 298, 0, 0, 2957, 2971, 3, 244, 122, 0, 2958, 2959, 5, 209, 0, 0, 2959, 2960, 5, 298, 0, 0, 2960, 2971, 5, 9, 0, 0, 2961, 2962, 5, 209, 0, 0, 2962, 2963, 5, 77, 0, 0, 2963, 2964, 5, 78, 0, 0, 2964, 2971, 3, 244, 122, 0, 2965, 2966, 5, 209, 0, 0, 2966, 2967, 5, 78, 0, 0, 2967, 2971, 3, 244, 122, 0, 2968, 2969, 5, 194, 0, 0, 2969, 2971, 3, 1458, 729, 0, 2970, 2931, 1, 0, 0, 0, 2970, 2932, 1, 0, 0, 0, 2970, 2933, 1, 0, 0, 0, 2970, 2938, 1, 0, 0, 0, 2970, 2943, 1, 0, 0, 0, 2970, 2944, 1, 0, 0, 0, 2970, 2945, 1, 0, 0, 0, 2970, 2950, 1, 0, 0, 0, 2970, 2955, 1, 0, 0, 0, 2970, 2958, 1, 0, 0, 0, 2970, 2961, 1, 0, 0, 0, 2970, 2965, 1, 0, 0, 0, 2970, 2968, 1, 0, 0, 0, 2971, 171, 1, 0, 0, 0, 2972, 2973, 5, 107, 0, 0, 2973, 173, 1, 0, 0, 0, 2974, 2976, 3, 176, 88, 0, 2975, 2974, 1, 0, 0, 0, 2975, 2976, 1, 0, 0, 0, 2976, 2977, 1, 0, 0, 0, 2977, 2978, 5, 184, 0, 0, 2978, 2979, 3, 1458, 729, 0, 2979, 175, 1, 0, 0, 0, 2980, 2981, 5, 100, 0, 0, 2981, 177, 1, 0, 0, 0, 2982, 2987, 3, 180, 90, 0, 2983, 2984, 5, 6, 0, 0, 2984, 2986, 3, 180, 90, 0, 2985, 2983, 1, 0, 0, 0, 2986, 2989, 1, 0, 0, 0, 2987, 2985, 1, 0, 0, 0, 2987, 2988, 1, 0, 0, 0, 2988, 179, 1, 0, 0, 0, 2989, 2987, 1, 0, 0, 0, 2990, 2992, 3, 1490, 745, 0, 2991, 2993, 3, 182, 91, 0, 2992, 2991, 1, 0, 0, 0, 2992, 2993, 1, 0, 0, 0, 2993, 181, 1, 0, 0, 0, 2994, 3002, 3, 72, 36, 0, 2995, 3002, 3, 322, 161, 0, 2996, 3002, 5, 9, 0, 0, 2997, 2998, 5, 2, 0, 0, 2998, 2999, 3, 184, 92, 0, 2999, 3000, 5, 3, 0, 0, 3000, 3002, 1, 0, 0, 0, 3001, 2994, 1, 0, 0, 0, 3001, 2995, 1, 0, 0, 0, 3001, 2996, 1, 0, 0, 0, 3001, 2997, 1, 0, 0, 0, 3002, 183, 1, 0, 0, 0, 3003, 3008, 3, 186, 93, 0, 3004, 3005, 5, 6, 0, 0, 3005, 3007, 3, 186, 93, 0, 3006, 3004, 1, 0, 0, 0, 3007, 3010, 1, 0, 0, 0, 3008, 3006, 1, 0, 0, 0, 3008, 3009, 1, 0, 0, 0, 3009, 185, 1, 0, 0, 0, 3010, 3008, 1, 0, 0, 0, 3011, 3012, 3, 70, 35, 0, 3012, 187, 1, 0, 0, 0, 3013, 3015, 5, 46, 0, 0, 3014, 3016, 3, 190, 95, 0, 3015, 3014, 1, 0, 0, 0, 3015, 3016, 1, 0, 0, 0, 3016, 3017, 1, 0, 0, 0, 3017, 3019, 5, 92, 0, 0, 3018, 3020, 3, 516, 258, 0, 3019, 3018, 1, 0, 0, 0, 3019, 3020, 1, 0, 0, 0, 3020, 3021, 1, 0, 0, 0, 3021, 3087, 3, 1404, 702, 0, 3022, 3024, 5, 2, 0, 0, 3023, 3025, 3, 192, 96, 0, 3024, 3023, 1, 0, 0, 0, 3024, 3025, 1, 0, 0, 0, 3025, 3026, 1, 0, 0, 0, 3026, 3028, 5, 3, 0, 0, 3027, 3029, 3, 266, 133, 0, 3028, 3027, 1, 0, 0, 0, 3028, 3029, 1, 0, 0, 0, 3029, 3031, 1, 0, 0, 0, 3030, 3032, 3, 268, 134, 0, 3031, 3030, 1, 0, 0, 0, 3031, 3032, 1, 0, 0, 0, 3032, 3034, 1, 0, 0, 0, 3033, 3035, 3, 276, 138, 0, 3034, 3033, 1, 0, 0, 0, 3034, 3035, 1, 0, 0, 0, 3035, 3037, 1, 0, 0, 0, 3036, 3038, 3, 278, 139, 0, 3037, 3036, 1, 0, 0, 0, 3037, 3038, 1, 0, 0, 0, 3038, 3040, 1, 0, 0, 0, 3039, 3041, 3, 280, 140, 0, 3040, 3039, 1, 0, 0, 0, 3040, 3041, 1, 0, 0, 0, 3041, 3043, 1, 0, 0, 0, 3042, 3044, 3, 282, 141, 0, 3043, 3042, 1, 0, 0, 0, 3043, 3044, 1, 0, 0, 0, 3044, 3088, 1, 0, 0, 0, 3045, 3046, 5, 275, 0, 0, 3046, 3048, 3, 558, 279, 0, 3047, 3049, 3, 196, 98, 0, 3048, 3047, 1, 0, 0, 0, 3048, 3049, 1, 0, 0, 0, 3049, 3051, 1, 0, 0, 0, 3050, 3052, 3, 268, 134, 0, 3051, 3050, 1, 0, 0, 0, 3051, 3052, 1, 0, 0, 0, 3052, 3054, 1, 0, 0, 0, 3053, 3055, 3, 276, 138, 0, 3054, 3053, 1, 0, 0, 0, 3054, 3055, 1, 0, 0, 0, 3055, 3057, 1, 0, 0, 0, 3056, 3058, 3, 278, 139, 0, 3057, 3056, 1, 0, 0, 0, 3057, 3058, 1, 0, 0, 0, 3058, 3060, 1, 0, 0, 0, 3059, 3061, 3, 280, 140, 0, 3060, 3059, 1, 0, 0, 0, 3060, 3061, 1, 0, 0, 0, 3061, 3063, 1, 0, 0, 0, 3062, 3064, 3, 282, 141, 0, 3063, 3062, 1, 0, 0, 0, 3063, 3064, 1, 0, 0, 0, 3064, 3088, 1, 0, 0, 0, 3065, 3066, 5, 285, 0, 0, 3066, 3067, 5, 275, 0, 0, 3067, 3069, 3, 1412, 706, 0, 3068, 3070, 3, 196, 98, 0, 3069, 3068, 1, 0, 0, 0, 3069, 3070, 1, 0, 0, 0, 3070, 3071, 1, 0, 0, 0, 3071, 3073, 3, 144, 72, 0, 3072, 3074, 3, 268, 134, 0, 3073, 3072, 1, 0, 0, 0, 3073, 3074, 1, 0, 0, 0, 3074, 3076, 1, 0, 0, 0, 3075, 3077, 3, 276, 138, 0, 3076, 3075, 1, 0, 0, 0, 3076, 3077, 1, 0, 0, 0, 3077, 3079, 1, 0, 0, 0, 3078, 3080, 3, 278, 139, 0, 3079, 3078, 1, 0, 0, 0, 3079, 3080, 1, 0, 0, 0, 3080, 3082, 1, 0, 0, 0, 3081, 3083, 3, 280, 140, 0, 3082, 3081, 1, 0, 0, 0, 3082, 3083, 1, 0, 0, 0, 3083, 3085, 1, 0, 0, 0, 3084, 3086, 3, 282, 141, 0, 3085, 3084, 1, 0, 0, 0, 3085, 3086, 1, 0, 0, 0, 3086, 3088, 1, 0, 0, 0, 3087, 3022, 1, 0, 0, 0, 3087, 3045, 1, 0, 0, 0, 3087, 3065, 1, 0, 0, 0, 3088, 189, 1, 0, 0, 0, 3089, 3097, 5, 354, 0, 0, 3090, 3097, 5, 352, 0, 0, 3091, 3092, 5, 254, 0, 0, 3092, 3097, 7, 25, 0, 0, 3093, 3094, 5, 213, 0, 0, 3094, 3097, 7, 25, 0, 0, 3095, 3097, 5, 367, 0, 0, 3096, 3089, 1, 0, 0, 0, 3096, 3090, 1, 0, 0, 0, 3096, 3091, 1, 0, 0, 0, 3096, 3093, 1, 0, 0, 0, 3096, 3095, 1, 0, 0, 0, 3097, 191, 1, 0, 0, 0, 3098, 3099, 3, 198, 99, 0, 3099, 193, 1, 0, 0, 0, 3100, 3101, 3, 198, 99, 0, 3101, 195, 1, 0, 0, 0, 3102, 3103, 5, 2, 0, 0, 3103, 3104, 3, 200, 100, 0, 3104, 3105, 5, 3, 0, 0, 3105, 197, 1, 0, 0, 0, 3106, 3111, 3, 202, 101, 0, 3107, 3108, 5, 6, 0, 0, 3108, 3110, 3, 202, 101, 0, 3109, 3107, 1, 0, 0, 0, 3110, 3113, 1, 0, 0, 0, 3111, 3109, 1, 0, 0, 0, 3111, 3112, 1, 0, 0, 0, 3112, 199, 1, 0, 0, 0, 3113, 3111, 1, 0, 0, 0, 3114, 3119, 3, 204, 102, 0, 3115, 3116, 5, 6, 0, 0, 3116, 3118, 3, 204, 102, 0, 3117, 3115, 1, 0, 0, 0, 3118, 3121, 1, 0, 0, 0, 3119, 3117, 1, 0, 0, 0, 3119, 3120, 1, 0, 0, 0, 3120, 201, 1, 0, 0, 0, 3121, 3119, 1, 0, 0, 0, 3122, 3126, 3, 206, 103, 0, 3123, 3126, 3, 228, 114, 0, 3124, 3126, 3, 234, 117, 0, 3125, 3122, 1, 0, 0, 0, 3125, 3123, 1, 0, 0, 0, 3125, 3124, 1, 0, 0, 0, 3126, 203, 1, 0, 0, 0, 3127, 3130, 3, 212, 106, 0, 3128, 3130, 3, 234, 117, 0, 3129, 3127, 1, 0, 0, 0, 3129, 3128, 1, 0, 0, 0, 3130, 205, 1, 0, 0, 0, 3131, 3132, 3, 1434, 717, 0, 3132, 3134, 3, 1168, 584, 0, 3133, 3135, 3, 368, 184, 0, 3134, 3133, 1, 0, 0, 0, 3134, 3135, 1, 0, 0, 0, 3135, 3137, 1, 0, 0, 0, 3136, 3138, 3, 210, 105, 0, 3137, 3136, 1, 0, 0, 0, 3137, 3138, 1, 0, 0, 0, 3138, 3140, 1, 0, 0, 0, 3139, 3141, 3, 208, 104, 0, 3140, 3139, 1, 0, 0, 0, 3140, 3141, 1, 0, 0, 0, 3141, 3144, 1, 0, 0, 0, 3142, 3143, 5, 43, 0, 0, 3143, 3145, 3, 558, 279, 0, 3144, 3142, 1, 0, 0, 0, 3144, 3145, 1, 0, 0, 0, 3145, 3148, 1, 0, 0, 0, 3146, 3147, 5, 105, 0, 0, 3147, 3149, 5, 280, 0, 0, 3148, 3146, 1, 0, 0, 0, 3148, 3149, 1, 0, 0, 0, 3149, 3150, 1, 0, 0, 0, 3150, 3151, 3, 214, 107, 0, 3151, 207, 1, 0, 0, 0, 3152, 3153, 5, 543, 0, 0, 3153, 3154, 3, 1474, 737, 0, 3154, 209, 1, 0, 0, 0, 3155, 3162, 5, 345, 0, 0, 3156, 3163, 5, 544, 0, 0, 3157, 3163, 5, 205, 0, 0, 3158, 3163, 5, 545, 0, 0, 3159, 3163, 5, 546, 0, 0, 3160, 3163, 5, 53, 0, 0, 3161, 3163, 3, 1474, 737, 0, 3162, 3156, 1, 0, 0, 0, 3162, 3157, 1, 0, 0, 0, 3162, 3158, 1, 0, 0, 0, 3162, 3159, 1, 0, 0, 0, 3162, 3160, 1, 0, 0, 0, 3162, 3161, 1, 0, 0, 0, 3163, 211, 1, 0, 0, 0, 3164, 3167, 3, 1434, 717, 0, 3165, 3166, 5, 105, 0, 0, 3166, 3168, 5, 280, 0, 0, 3167, 3165, 1, 0, 0, 0, 3167, 3168, 1, 0, 0, 0, 3168, 3169, 1, 0, 0, 0, 3169, 3170, 3, 214, 107, 0, 3170, 213, 1, 0, 0, 0, 3171, 3173, 3, 216, 108, 0, 3172, 3171, 1, 0, 0, 0, 3173, 3176, 1, 0, 0, 0, 3174, 3172, 1, 0, 0, 0, 3174, 3175, 1, 0, 0, 0, 3175, 215, 1, 0, 0, 0, 3176, 3174, 1, 0, 0, 0, 3177, 3178, 5, 45, 0, 0, 3178, 3180, 3, 1436, 718, 0, 3179, 3177, 1, 0, 0, 0, 3179, 3180, 1, 0, 0, 0, 3180, 3181, 1, 0, 0, 0, 3181, 3183, 3, 218, 109, 0, 3182, 3184, 3, 224, 112, 0, 3183, 3182, 1, 0, 0, 0, 3183, 3184, 1, 0, 0, 0, 3184, 3186, 1, 0, 0, 0, 3185, 3187, 3, 226, 113, 0, 3186, 3185, 1, 0, 0, 0, 3186, 3187, 1, 0, 0, 0, 3187, 3196, 1, 0, 0, 0, 3188, 3190, 3, 218, 109, 0, 3189, 3191, 3, 224, 112, 0, 3190, 3189, 1, 0, 0, 0, 3190, 3191, 1, 0, 0, 0, 3191, 3193, 1, 0, 0, 0, 3192, 3194, 3, 226, 113, 0, 3193, 3192, 1, 0, 0, 0, 3193, 3194, 1, 0, 0, 0, 3194, 3196, 1, 0, 0, 0, 3195, 3179, 1, 0, 0, 0, 3195, 3188, 1, 0, 0, 0, 3196, 217, 1, 0, 0, 0, 3197, 3198, 5, 77, 0, 0, 3198, 3256, 5, 78, 0, 0, 3199, 3256, 5, 78, 0, 0, 3200, 3202, 5, 98, 0, 0, 3201, 3203, 3, 710, 355, 0, 3202, 3201, 1, 0, 0, 0, 3202, 3203, 1, 0, 0, 0, 3203, 3205, 1, 0, 0, 0, 3204, 3206, 3, 286, 143, 0, 3205, 3204, 1, 0, 0, 0, 3205, 3206, 1, 0, 0, 0, 3206, 3256, 1, 0, 0, 0, 3207, 3209, 5, 98, 0, 0, 3208, 3210, 3, 220, 110, 0, 3209, 3208, 1, 0, 0, 0, 3209, 3210, 1, 0, 0, 0, 3210, 3211, 1, 0, 0, 0, 3211, 3256, 3, 284, 142, 0, 3212, 3213, 5, 85, 0, 0, 3213, 3215, 5, 245, 0, 0, 3214, 3216, 3, 710, 355, 0, 3215, 3214, 1, 0, 0, 0, 3215, 3216, 1, 0, 0, 0, 3216, 3218, 1, 0, 0, 0, 3217, 3219, 3, 286, 143, 0, 3218, 3217, 1, 0, 0, 0, 3218, 3219, 1, 0, 0, 0, 3219, 3256, 1, 0, 0, 0, 3220, 3221, 5, 42, 0, 0, 3221, 3222, 5, 2, 0, 0, 3222, 3223, 3, 1212, 606, 0, 3223, 3225, 5, 3, 0, 0, 3224, 3226, 3, 238, 119, 0, 3225, 3224, 1, 0, 0, 0, 3225, 3226, 1, 0, 0, 0, 3226, 3256, 1, 0, 0, 0, 3227, 3228, 5, 53, 0, 0, 3228, 3256, 3, 1252, 626, 0, 3229, 3230, 5, 438, 0, 0, 3230, 3231, 3, 222, 111, 0, 3231, 3241, 5, 36, 0, 0, 3232, 3234, 5, 219, 0, 0, 3233, 3235, 3, 314, 157, 0, 3234, 3233, 1, 0, 0, 0, 3234, 3235, 1, 0, 0, 0, 3235, 3242, 1, 0, 0, 0, 3236, 3237, 5, 2, 0, 0, 3237, 3238, 3, 1212, 606, 0, 3238, 3239, 5, 3, 0, 0, 3239, 3240, 5, 440, 0, 0, 3240, 3242, 1, 0, 0, 0, 3241, 3232, 1, 0, 0, 0, 3241, 3236, 1, 0, 0, 0, 3242, 3256, 1, 0, 0, 0, 3243, 3244, 5, 86, 0, 0, 3244, 3246, 3, 1412, 706, 0, 3245, 3247, 3, 240, 120, 0, 3246, 3245, 1, 0, 0, 0, 3246, 3247, 1, 0, 0, 0, 3247, 3249, 1, 0, 0, 0, 3248, 3250, 3, 250, 125, 0, 3249, 3248, 1, 0, 0, 0, 3249, 3250, 1, 0, 0, 0, 3250, 3252, 1, 0, 0, 0, 3251, 3253, 3, 258, 129, 0, 3252, 3251, 1, 0, 0, 0, 3252, 3253, 1, 0, 0, 0, 3253, 3256, 1, 0, 0, 0, 3254, 3256, 3, 646, 323, 0, 3255, 3197, 1, 0, 0, 0, 3255, 3199, 1, 0, 0, 0, 3255, 3200, 1, 0, 0, 0, 3255, 3207, 1, 0, 0, 0, 3255, 3212, 1, 0, 0, 0, 3255, 3220, 1, 0, 0, 0, 3255, 3227, 1, 0, 0, 0, 3255, 3229, 1, 0, 0, 0, 3255, 3243, 1, 0, 0, 0, 3255, 3254, 1, 0, 0, 0, 3256, 219, 1, 0, 0, 0, 3257, 3259, 5, 273, 0, 0, 3258, 3260, 5, 77, 0, 0, 3259, 3258, 1, 0, 0, 0, 3259, 3260, 1, 0, 0, 0, 3260, 3261, 1, 0, 0, 0, 3261, 3262, 5, 56, 0, 0, 3262, 221, 1, 0, 0, 0, 3263, 3267, 5, 139, 0, 0, 3264, 3265, 5, 147, 0, 0, 3265, 3267, 5, 53, 0, 0, 3266, 3263, 1, 0, 0, 0, 3266, 3264, 1, 0, 0, 0, 3267, 223, 1, 0, 0, 0, 3268, 3272, 5, 54, 0, 0, 3269, 3270, 5, 77, 0, 0, 3270, 3272, 5, 54, 0, 0, 3271, 3268, 1, 0, 0, 0, 3271, 3269, 1, 0, 0, 0, 3272, 225, 1, 0, 0, 0, 3273, 3274, 5, 69, 0, 0, 3274, 3275, 7, 16, 0, 0, 3275, 227, 1, 0, 0, 0, 3276, 3277, 5, 120, 0, 0, 3277, 3278, 3, 1412, 706, 0, 3278, 3279, 3, 230, 115, 0, 3279, 229, 1, 0, 0, 0, 3280, 3281, 7, 26, 0, 0, 3281, 3283, 3, 232, 116, 0, 3282, 3280, 1, 0, 0, 0, 3283, 3286, 1, 0, 0, 0, 3284, 3282, 1, 0, 0, 0, 3284, 3285, 1, 0, 0, 0, 3285, 231, 1, 0, 0, 0, 3286, 3284, 1, 0, 0, 0, 3287, 3288, 7, 27, 0, 0, 3288, 233, 1, 0, 0, 0, 3289, 3290, 5, 45, 0, 0, 3290, 3291, 3, 1436, 718, 0, 3291, 3292, 3, 236, 118, 0, 3292, 3295, 1, 0, 0, 0, 3293, 3295, 3, 236, 118, 0, 3294, 3289, 1, 0, 0, 0, 3294, 3293, 1, 0, 0, 0, 3295, 235, 1, 0, 0, 0, 3296, 3297, 5, 42, 0, 0, 3297, 3298, 5, 2, 0, 0, 3298, 3299, 3, 1212, 606, 0, 3299, 3300, 5, 3, 0, 0, 3300, 3301, 3, 476, 238, 0, 3301, 3383, 1, 0, 0, 0, 3302, 3320, 5, 98, 0, 0, 3303, 3304, 5, 2, 0, 0, 3304, 3305, 3, 244, 122, 0, 3305, 3307, 5, 3, 0, 0, 3306, 3308, 3, 248, 124, 0, 3307, 3306, 1, 0, 0, 0, 3307, 3308, 1, 0, 0, 0, 3308, 3310, 1, 0, 0, 0, 3309, 3311, 3, 710, 355, 0, 3310, 3309, 1, 0, 0, 0, 3310, 3311, 1, 0, 0, 0, 3311, 3313, 1, 0, 0, 0, 3312, 3314, 3, 286, 143, 0, 3313, 3312, 1, 0, 0, 0, 3313, 3314, 1, 0, 0, 0, 3314, 3315, 1, 0, 0, 0, 3315, 3316, 3, 476, 238, 0, 3316, 3321, 1, 0, 0, 0, 3317, 3318, 3, 288, 144, 0, 3318, 3319, 3, 476, 238, 0, 3319, 3321, 1, 0, 0, 0, 3320, 3303, 1, 0, 0, 0, 3320, 3317, 1, 0, 0, 0, 3321, 3383, 1, 0, 0, 0, 3322, 3323, 5, 85, 0, 0, 3323, 3341, 5, 245, 0, 0, 3324, 3325, 5, 2, 0, 0, 3325, 3326, 3, 244, 122, 0, 3326, 3328, 5, 3, 0, 0, 3327, 3329, 3, 248, 124, 0, 3328, 3327, 1, 0, 0, 0, 3328, 3329, 1, 0, 0, 0, 3329, 3331, 1, 0, 0, 0, 3330, 3332, 3, 710, 355, 0, 3331, 3330, 1, 0, 0, 0, 3331, 3332, 1, 0, 0, 0, 3332, 3334, 1, 0, 0, 0, 3333, 3335, 3, 286, 143, 0, 3334, 3333, 1, 0, 0, 0, 3334, 3335, 1, 0, 0, 0, 3335, 3336, 1, 0, 0, 0, 3336, 3337, 3, 476, 238, 0, 3337, 3342, 1, 0, 0, 0, 3338, 3339, 3, 288, 144, 0, 3339, 3340, 3, 476, 238, 0, 3340, 3342, 1, 0, 0, 0, 3341, 3324, 1, 0, 0, 0, 3341, 3338, 1, 0, 0, 0, 3342, 3383, 1, 0, 0, 0, 3343, 3345, 5, 199, 0, 0, 3344, 3346, 3, 634, 317, 0, 3345, 3344, 1, 0, 0, 0, 3345, 3346, 1, 0, 0, 0, 3346, 3347, 1, 0, 0, 0, 3347, 3348, 5, 2, 0, 0, 3348, 3349, 3, 252, 126, 0, 3349, 3351, 5, 3, 0, 0, 3350, 3352, 3, 248, 124, 0, 3351, 3350, 1, 0, 0, 0, 3351, 3352, 1, 0, 0, 0, 3352, 3354, 1, 0, 0, 0, 3353, 3355, 3, 710, 355, 0, 3354, 3353, 1, 0, 0, 0, 3354, 3355, 1, 0, 0, 0, 3355, 3357, 1, 0, 0, 0, 3356, 3358, 3, 286, 143, 0, 3357, 3356, 1, 0, 0, 0, 3357, 3358, 1, 0, 0, 0, 3358, 3360, 1, 0, 0, 0, 3359, 3361, 3, 256, 128, 0, 3360, 3359, 1, 0, 0, 0, 3360, 3361, 1, 0, 0, 0, 3361, 3362, 1, 0, 0, 0, 3362, 3363, 3, 476, 238, 0, 3363, 3383, 1, 0, 0, 0, 3364, 3365, 5, 63, 0, 0, 3365, 3366, 5, 245, 0, 0, 3366, 3367, 5, 2, 0, 0, 3367, 3368, 3, 244, 122, 0, 3368, 3369, 5, 3, 0, 0, 3369, 3370, 5, 86, 0, 0, 3370, 3372, 3, 1412, 706, 0, 3371, 3373, 3, 240, 120, 0, 3372, 3371, 1, 0, 0, 0, 3372, 3373, 1, 0, 0, 0, 3373, 3375, 1, 0, 0, 0, 3374, 3376, 3, 250, 125, 0, 3375, 3374, 1, 0, 0, 0, 3375, 3376, 1, 0, 0, 0, 3376, 3378, 1, 0, 0, 0, 3377, 3379, 3, 258, 129, 0, 3378, 3377, 1, 0, 0, 0, 3378, 3379, 1, 0, 0, 0, 3379, 3380, 1, 0, 0, 0, 3380, 3381, 3, 476, 238, 0, 3381, 3383, 1, 0, 0, 0, 3382, 3296, 1, 0, 0, 0, 3382, 3302, 1, 0, 0, 0, 3382, 3322, 1, 0, 0, 0, 3382, 3343, 1, 0, 0, 0, 3382, 3364, 1, 0, 0, 0, 3383, 237, 1, 0, 0, 0, 3384, 3385, 5, 269, 0, 0, 3385, 3386, 5, 228, 0, 0, 3386, 239, 1, 0, 0, 0, 3387, 3388, 5, 2, 0, 0, 3388, 3389, 3, 244, 122, 0, 3389, 3390, 5, 3, 0, 0, 3390, 241, 1, 0, 0, 0, 3391, 3392, 5, 2, 0, 0, 3392, 3393, 3, 246, 123, 0, 3393, 3394, 5, 3, 0, 0, 3394, 243, 1, 0, 0, 0, 3395, 3400, 3, 1432, 716, 0, 3396, 3397, 5, 6, 0, 0, 3397, 3399, 3, 1432, 716, 0, 3398, 3396, 1, 0, 0, 0, 3399, 3402, 1, 0, 0, 0, 3400, 3398, 1, 0, 0, 0, 3400, 3401, 1, 0, 0, 0, 3401, 245, 1, 0, 0, 0, 3402, 3400, 1, 0, 0, 0, 3403, 3408, 3, 1434, 717, 0, 3404, 3405, 5, 6, 0, 0, 3405, 3407, 3, 1434, 717, 0, 3406, 3404, 1, 0, 0, 0, 3407, 3410, 1, 0, 0, 0, 3408, 3406, 1, 0, 0, 0, 3408, 3409, 1, 0, 0, 0, 3409, 247, 1, 0, 0, 0, 3410, 3408, 1, 0, 0, 0, 3411, 3412, 5, 441, 0, 0, 3412, 3413, 5, 2, 0, 0, 3413, 3414, 3, 244, 122, 0, 3414, 3415, 5, 3, 0, 0, 3415, 249, 1, 0, 0, 0, 3416, 3417, 5, 258, 0, 0, 3417, 3418, 7, 28, 0, 0, 3418, 251, 1, 0, 0, 0, 3419, 3424, 3, 254, 127, 0, 3420, 3421, 5, 6, 0, 0, 3421, 3423, 3, 254, 127, 0, 3422, 3420, 1, 0, 0, 0, 3423, 3426, 1, 0, 0, 0, 3424, 3422, 1, 0, 0, 0, 3424, 3425, 1, 0, 0, 0, 3425, 253, 1, 0, 0, 0, 3426, 3424, 1, 0, 0, 0, 3427, 3428, 3, 640, 320, 0, 3428, 3435, 5, 105, 0, 0, 3429, 3436, 3, 732, 366, 0, 3430, 3431, 5, 278, 0, 0, 3431, 3432, 5, 2, 0, 0, 3432, 3433, 3, 732, 366, 0, 3433, 3434, 5, 3, 0, 0, 3434, 3436, 1, 0, 0, 0, 3435, 3429, 1, 0, 0, 0, 3435, 3430, 1, 0, 0, 0, 3436, 255, 1, 0, 0, 0, 3437, 3438, 5, 103, 0, 0, 3438, 3439, 5, 2, 0, 0, 3439, 3440, 3, 1212, 606, 0, 3440, 3441, 5, 3, 0, 0, 3441, 257, 1, 0, 0, 0, 3442, 3451, 3, 260, 130, 0, 3443, 3451, 3, 262, 131, 0, 3444, 3445, 3, 260, 130, 0, 3445, 3446, 3, 262, 131, 0, 3446, 3451, 1, 0, 0, 0, 3447, 3448, 3, 262, 131, 0, 3448, 3449, 3, 260, 130, 0, 3449, 3451, 1, 0, 0, 0, 3450, 3442, 1, 0, 0, 0, 3450, 3443, 1, 0, 0, 0, 3450, 3444, 1, 0, 0, 0, 3450, 3447, 1, 0, 0, 0, 3451, 259, 1, 0, 0, 0, 3452, 3453, 5, 80, 0, 0, 3453, 3454, 5, 369, 0, 0, 3454, 3455, 3, 264, 132, 0, 3455, 261, 1, 0, 0, 0, 3456, 3457, 5, 80, 0, 0, 3457, 3458, 5, 182, 0, 0, 3458, 3459, 3, 264, 132, 0, 3459, 263, 1, 0, 0, 0, 3460, 3461, 5, 269, 0, 0, 3461, 3470, 5, 132, 0, 0, 3462, 3470, 5, 315, 0, 0, 3463, 3470, 5, 150, 0, 0, 3464, 3465, 5, 333, 0, 0, 3465, 3467, 7, 29, 0, 0, 3466, 3468, 3, 244, 122, 0, 3467, 3466, 1, 0, 0, 0, 3467, 3468, 1, 0, 0, 0, 3468, 3470, 1, 0, 0, 0, 3469, 3460, 1, 0, 0, 0, 3469, 3462, 1, 0, 0, 0, 3469, 3463, 1, 0, 0, 0, 3469, 3464, 1, 0, 0, 0, 3470, 265, 1, 0, 0, 0, 3471, 3472, 5, 238, 0, 0, 3472, 3473, 5, 2, 0, 0, 3473, 3474, 3, 1390, 695, 0, 3474, 3475, 5, 3, 0, 0, 3475, 267, 1, 0, 0, 0, 3476, 3477, 3, 270, 135, 0, 3477, 269, 1, 0, 0, 0, 3478, 3479, 5, 285, 0, 0, 3479, 3480, 5, 147, 0, 0, 3480, 3481, 3, 1474, 737, 0, 3481, 3482, 5, 2, 0, 0, 3482, 3483, 3, 272, 136, 0, 3483, 3484, 5, 3, 0, 0, 3484, 271, 1, 0, 0, 0, 3485, 3490, 3, 274, 137, 0, 3486, 3487, 5, 6, 0, 0, 3487, 3489, 3, 274, 137, 0, 3488, 3486, 1, 0, 0, 0, 3489, 3492, 1, 0, 0, 0, 3490, 3488, 1, 0, 0, 0, 3490, 3491, 1, 0, 0, 0, 3491, 273, 1, 0, 0, 0, 3492, 3490, 1, 0, 0, 0, 3493, 3495, 3, 1432, 716, 0, 3494, 3496, 3, 646, 323, 0, 3495, 3494, 1, 0, 0, 0, 3495, 3496, 1, 0, 0, 0, 3496, 3498, 1, 0, 0, 0, 3497, 3499, 3, 648, 324, 0, 3498, 3497, 1, 0, 0, 0, 3498, 3499, 1, 0, 0, 0, 3499, 3517, 1, 0, 0, 0, 3500, 3502, 3, 1262, 631, 0, 3501, 3503, 3, 646, 323, 0, 3502, 3501, 1, 0, 0, 0, 3502, 3503, 1, 0, 0, 0, 3503, 3505, 1, 0, 0, 0, 3504, 3506, 3, 648, 324, 0, 3505, 3504, 1, 0, 0, 0, 3505, 3506, 1, 0, 0, 0, 3506, 3517, 1, 0, 0, 0, 3507, 3508, 5, 2, 0, 0, 3508, 3509, 3, 1212, 606, 0, 3509, 3511, 5, 3, 0, 0, 3510, 3512, 3, 646, 323, 0, 3511, 3510, 1, 0, 0, 0, 3511, 3512, 1, 0, 0, 0, 3512, 3514, 1, 0, 0, 0, 3513, 3515, 3, 648, 324, 0, 3514, 3513, 1, 0, 0, 0, 3514, 3515, 1, 0, 0, 0, 3515, 3517, 1, 0, 0, 0, 3516, 3493, 1, 0, 0, 0, 3516, 3500, 1, 0, 0, 0, 3516, 3507, 1, 0, 0, 0, 3517, 275, 1, 0, 0, 0, 3518, 3519, 5, 100, 0, 0, 3519, 3520, 3, 1436, 718, 0, 3520, 277, 1, 0, 0, 0, 3521, 3522, 5, 105, 0, 0, 3522, 3528, 3, 132, 66, 0, 3523, 3524, 5, 379, 0, 0, 3524, 3528, 5, 277, 0, 0, 3525, 3526, 5, 105, 0, 0, 3526, 3528, 5, 277, 0, 0, 3527, 3521, 1, 0, 0, 0, 3527, 3523, 1, 0, 0, 0, 3527, 3525, 1, 0, 0, 0, 3528, 279, 1, 0, 0, 0, 3529, 3530, 5, 80, 0, 0, 3530, 3536, 5, 161, 0, 0, 3531, 3537, 5, 191, 0, 0, 3532, 3533, 5, 182, 0, 0, 3533, 3537, 5, 320, 0, 0, 3534, 3535, 5, 292, 0, 0, 3535, 3537, 5, 320, 0, 0, 3536, 3531, 1, 0, 0, 0, 3536, 3532, 1, 0, 0, 0, 3536, 3534, 1, 0, 0, 0, 3537, 281, 1, 0, 0, 0, 3538, 3539, 5, 351, 0, 0, 3539, 3540, 3, 1402, 701, 0, 3540, 283, 1, 0, 0, 0, 3541, 3543, 3, 642, 321, 0, 3542, 3541, 1, 0, 0, 0, 3542, 3543, 1, 0, 0, 0, 3543, 3545, 1, 0, 0, 0, 3544, 3546, 3, 1014, 507, 0, 3545, 3544, 1, 0, 0, 0, 3545, 3546, 1, 0, 0, 0, 3546, 3548, 1, 0, 0, 0, 3547, 3549, 3, 286, 143, 0, 3548, 3547, 1, 0, 0, 0, 3548, 3549, 1, 0, 0, 0, 3549, 285, 1, 0, 0, 0, 3550, 3551, 5, 100, 0, 0, 3551, 3552, 5, 226, 0, 0, 3552, 3553, 5, 351, 0, 0, 3553, 3554, 3, 1402, 701, 0, 3554, 287, 1, 0, 0, 0, 3555, 3556, 5, 100, 0, 0, 3556, 3557, 5, 226, 0, 0, 3557, 3558, 3, 1436, 718, 0, 3558, 289, 1, 0, 0, 0, 3559, 3560, 5, 46, 0, 0, 3560, 3565, 5, 342, 0, 0, 3561, 3563, 3, 516, 258, 0, 3562, 3561, 1, 0, 0, 0, 3562, 3563, 1, 0, 0, 0, 3563, 3564, 1, 0, 0, 0, 3564, 3566, 3, 558, 279, 0, 3565, 3562, 1, 0, 0, 0, 3565, 3566, 1, 0, 0, 0, 3566, 3568, 1, 0, 0, 0, 3567, 3569, 3, 918, 459, 0, 3568, 3567, 1, 0, 0, 0, 3568, 3569, 1, 0, 0, 0, 3569, 3570, 1, 0, 0, 0, 3570, 3573, 5, 80, 0, 0, 3571, 3574, 3, 1332, 666, 0, 3572, 3574, 3, 1328, 664, 0, 3573, 3571, 1, 0, 0, 0, 3573, 3572, 1, 0, 0, 0, 3574, 3575, 1, 0, 0, 0, 3575, 3576, 5, 64, 0, 0, 3576, 3577, 3, 1104, 552, 0, 3577, 291, 1, 0, 0, 0, 3578, 3579, 5, 138, 0, 0, 3579, 3581, 5, 342, 0, 0, 3580, 3582, 3, 748, 374, 0, 3581, 3580, 1, 0, 0, 0, 3581, 3582, 1, 0, 0, 0, 3582, 3583, 1, 0, 0, 0, 3583, 3584, 3, 558, 279, 0, 3584, 3585, 5, 333, 0, 0, 3585, 3586, 5, 342, 0, 0, 3586, 3587, 3, 1464, 732, 0, 3587, 293, 1, 0, 0, 0, 3588, 3590, 5, 46, 0, 0, 3589, 3591, 3, 190, 95, 0, 3590, 3589, 1, 0, 0, 0, 3590, 3591, 1, 0, 0, 0, 3591, 3592, 1, 0, 0, 0, 3592, 3594, 5, 92, 0, 0, 3593, 3595, 3, 516, 258, 0, 3594, 3593, 1, 0, 0, 0, 3594, 3595, 1, 0, 0, 0, 3595, 3596, 1, 0, 0, 0, 3596, 3597, 3, 296, 148, 0, 3597, 3598, 5, 36, 0, 0, 3598, 3600, 3, 1000, 500, 0, 3599, 3601, 3, 298, 149, 0, 3600, 3599, 1, 0, 0, 0, 3600, 3601, 1, 0, 0, 0, 3601, 295, 1, 0, 0, 0, 3602, 3604, 3, 1404, 702, 0, 3603, 3605, 3, 242, 121, 0, 3604, 3603, 1, 0, 0, 0, 3604, 3605, 1, 0, 0, 0, 3605, 3607, 1, 0, 0, 0, 3606, 3608, 3, 276, 138, 0, 3607, 3606, 1, 0, 0, 0, 3607, 3608, 1, 0, 0, 0, 3608, 3610, 1, 0, 0, 0, 3609, 3611, 3, 278, 139, 0, 3610, 3609, 1, 0, 0, 0, 3610, 3611, 1, 0, 0, 0, 3611, 3613, 1, 0, 0, 0, 3612, 3614, 3, 280, 140, 0, 3613, 3612, 1, 0, 0, 0, 3613, 3614, 1, 0, 0, 0, 3614, 3616, 1, 0, 0, 0, 3615, 3617, 3, 282, 141, 0, 3616, 3615, 1, 0, 0, 0, 3616, 3617, 1, 0, 0, 0, 3617, 297, 1, 0, 0, 0, 3618, 3622, 5, 105, 0, 0, 3619, 3623, 5, 174, 0, 0, 3620, 3621, 5, 269, 0, 0, 3621, 3623, 5, 174, 0, 0, 3622, 3619, 1, 0, 0, 0, 3622, 3620, 1, 0, 0, 0, 3623, 299, 1, 0, 0, 0, 3624, 3626, 5, 46, 0, 0, 3625, 3627, 3, 304, 152, 0, 3626, 3625, 1, 0, 0, 0, 3626, 3627, 1, 0, 0, 0, 3627, 3628, 1, 0, 0, 0, 3628, 3629, 5, 259, 0, 0, 3629, 3631, 5, 376, 0, 0, 3630, 3632, 3, 516, 258, 0, 3631, 3630, 1, 0, 0, 0, 3631, 3632, 1, 0, 0, 0, 3632, 3633, 1, 0, 0, 0, 3633, 3634, 3, 302, 151, 0, 3634, 3635, 5, 36, 0, 0, 3635, 3637, 3, 1000, 500, 0, 3636, 3638, 3, 298, 149, 0, 3637, 3636, 1, 0, 0, 0, 3637, 3638, 1, 0, 0, 0, 3638, 301, 1, 0, 0, 0, 3639, 3641, 3, 1408, 704, 0, 3640, 3642, 3, 242, 121, 0, 3641, 3640, 1, 0, 0, 0, 3641, 3642, 1, 0, 0, 0, 3642, 3644, 1, 0, 0, 0, 3643, 3645, 3, 276, 138, 0, 3644, 3643, 1, 0, 0, 0, 3644, 3645, 1, 0, 0, 0, 3645, 3647, 1, 0, 0, 0, 3646, 3648, 3, 134, 67, 0, 3647, 3646, 1, 0, 0, 0, 3647, 3648, 1, 0, 0, 0, 3648, 3650, 1, 0, 0, 0, 3649, 3651, 3, 282, 141, 0, 3650, 3649, 1, 0, 0, 0, 3650, 3651, 1, 0, 0, 0, 3651, 303, 1, 0, 0, 0, 3652, 3653, 5, 367, 0, 0, 3653, 305, 1, 0, 0, 0, 3654, 3655, 5, 305, 0, 0, 3655, 3656, 5, 259, 0, 0, 3656, 3658, 5, 376, 0, 0, 3657, 3659, 3, 630, 315, 0, 3658, 3657, 1, 0, 0, 0, 3658, 3659, 1, 0, 0, 0, 3659, 3660, 1, 0, 0, 0, 3660, 3662, 3, 1410, 705, 0, 3661, 3663, 3, 298, 149, 0, 3662, 3661, 1, 0, 0, 0, 3662, 3663, 1, 0, 0, 0, 3663, 307, 1, 0, 0, 0, 3664, 3666, 5, 46, 0, 0, 3665, 3667, 3, 190, 95, 0, 3666, 3665, 1, 0, 0, 0, 3666, 3667, 1, 0, 0, 0, 3667, 3668, 1, 0, 0, 0, 3668, 3670, 5, 328, 0, 0, 3669, 3671, 3, 516, 258, 0, 3670, 3669, 1, 0, 0, 0, 3670, 3671, 1, 0, 0, 0, 3671, 3672, 1, 0, 0, 0, 3672, 3674, 3, 1412, 706, 0, 3673, 3675, 3, 312, 156, 0, 3674, 3673, 1, 0, 0, 0, 3674, 3675, 1, 0, 0, 0, 3675, 309, 1, 0, 0, 0, 3676, 3677, 5, 138, 0, 0, 3677, 3679, 5, 328, 0, 0, 3678, 3680, 3, 748, 374, 0, 3679, 3678, 1, 0, 0, 0, 3679, 3680, 1, 0, 0, 0, 3680, 3681, 1, 0, 0, 0, 3681, 3682, 3, 1412, 706, 0, 3682, 3683, 3, 316, 158, 0, 3683, 311, 1, 0, 0, 0, 3684, 3685, 3, 316, 158, 0, 3685, 313, 1, 0, 0, 0, 3686, 3687, 5, 2, 0, 0, 3687, 3688, 3, 316, 158, 0, 3688, 3689, 5, 3, 0, 0, 3689, 315, 1, 0, 0, 0, 3690, 3692, 3, 318, 159, 0, 3691, 3690, 1, 0, 0, 0, 3692, 3693, 1, 0, 0, 0, 3693, 3691, 1, 0, 0, 0, 3693, 3694, 1, 0, 0, 0, 3694, 317, 1, 0, 0, 0, 3695, 3696, 5, 36, 0, 0, 3696, 3730, 3, 1172, 586, 0, 3697, 3698, 5, 148, 0, 0, 3698, 3730, 3, 322, 161, 0, 3699, 3730, 5, 173, 0, 0, 3700, 3702, 5, 225, 0, 0, 3701, 3703, 3, 320, 160, 0, 3702, 3701, 1, 0, 0, 0, 3702, 3703, 1, 0, 0, 0, 3703, 3704, 1, 0, 0, 0, 3704, 3730, 3, 322, 161, 0, 3705, 3706, 5, 260, 0, 0, 3706, 3730, 3, 322, 161, 0, 3707, 3708, 5, 262, 0, 0, 3708, 3730, 3, 322, 161, 0, 3709, 3710, 5, 269, 0, 0, 3710, 3730, 7, 30, 0, 0, 3711, 3712, 5, 281, 0, 0, 3712, 3713, 5, 147, 0, 0, 3713, 3730, 3, 1432, 716, 0, 3714, 3715, 5, 328, 0, 0, 3715, 3716, 5, 266, 0, 0, 3716, 3730, 3, 558, 279, 0, 3717, 3719, 5, 340, 0, 0, 3718, 3720, 3, 14, 7, 0, 3719, 3718, 1, 0, 0, 0, 3719, 3720, 1, 0, 0, 0, 3720, 3721, 1, 0, 0, 0, 3721, 3730, 3, 322, 161, 0, 3722, 3724, 5, 314, 0, 0, 3723, 3725, 3, 14, 7, 0, 3724, 3723, 1, 0, 0, 0, 3724, 3725, 1, 0, 0, 0, 3725, 3727, 1, 0, 0, 0, 3726, 3728, 3, 322, 161, 0, 3727, 3726, 1, 0, 0, 0, 3727, 3728, 1, 0, 0, 0, 3728, 3730, 1, 0, 0, 0, 3729, 3695, 1, 0, 0, 0, 3729, 3697, 1, 0, 0, 0, 3729, 3699, 1, 0, 0, 0, 3729, 3700, 1, 0, 0, 0, 3729, 3705, 1, 0, 0, 0, 3729, 3707, 1, 0, 0, 0, 3729, 3709, 1, 0, 0, 0, 3729, 3711, 1, 0, 0, 0, 3729, 3714, 1, 0, 0, 0, 3729, 3717, 1, 0, 0, 0, 3729, 3722, 1, 0, 0, 0, 3730, 319, 1, 0, 0, 0, 3731, 3732, 5, 147, 0, 0, 3732, 321, 1, 0, 0, 0, 3733, 3740, 3, 1454, 727, 0, 3734, 3735, 5, 12, 0, 0, 3735, 3740, 3, 1454, 727, 0, 3736, 3737, 5, 13, 0, 0, 3737, 3740, 3, 1454, 727, 0, 3738, 3740, 3, 1464, 732, 0, 3739, 3733, 1, 0, 0, 0, 3739, 3734, 1, 0, 0, 0, 3739, 3736, 1, 0, 0, 0, 3739, 3738, 1, 0, 0, 0, 3740, 323, 1, 0, 0, 0, 3741, 3746, 3, 322, 161, 0, 3742, 3743, 5, 6, 0, 0, 3743, 3745, 3, 322, 161, 0, 3744, 3742, 1, 0, 0, 0, 3745, 3748, 1, 0, 0, 0, 3746, 3744, 1, 0, 0, 0, 3746, 3747, 1, 0, 0, 0, 3747, 325, 1, 0, 0, 0, 3748, 3746, 1, 0, 0, 0, 3749, 3751, 5, 46, 0, 0, 3750, 3752, 3, 658, 329, 0, 3751, 3750, 1, 0, 0, 0, 3751, 3752, 1, 0, 0, 0, 3752, 3754, 1, 0, 0, 0, 3753, 3755, 3, 328, 164, 0, 3754, 3753, 1, 0, 0, 0, 3754, 3755, 1, 0, 0, 0, 3755, 3757, 1, 0, 0, 0, 3756, 3758, 3, 338, 169, 0, 3757, 3756, 1, 0, 0, 0, 3757, 3758, 1, 0, 0, 0, 3758, 3759, 1, 0, 0, 0, 3759, 3760, 5, 247, 0, 0, 3760, 3769, 3, 1436, 718, 0, 3761, 3762, 5, 215, 0, 0, 3762, 3764, 3, 330, 165, 0, 3763, 3765, 3, 332, 166, 0, 3764, 3763, 1, 0, 0, 0, 3764, 3765, 1, 0, 0, 0, 3765, 3767, 1, 0, 0, 0, 3766, 3768, 3, 336, 168, 0, 3767, 3766, 1, 0, 0, 0, 3767, 3768, 1, 0, 0, 0, 3768, 3770, 1, 0, 0, 0, 3769, 3761, 1, 0, 0, 0, 3769, 3770, 1, 0, 0, 0, 3770, 327, 1, 0, 0, 0, 3771, 3772, 5, 359, 0, 0, 3772, 329, 1, 0, 0, 0, 3773, 3775, 3, 1436, 718, 0, 3774, 3776, 3, 560, 280, 0, 3775, 3774, 1, 0, 0, 0, 3775, 3776, 1, 0, 0, 0, 3776, 331, 1, 0, 0, 0, 3777, 3778, 5, 239, 0, 0, 3778, 3779, 3, 330, 165, 0, 3779, 333, 1, 0, 0, 0, 3780, 3781, 5, 373, 0, 0, 3781, 3785, 3, 330, 165, 0, 3782, 3783, 5, 269, 0, 0, 3783, 3785, 5, 373, 0, 0, 3784, 3780, 1, 0, 0, 0, 3784, 3782, 1, 0, 0, 0, 3785, 335, 1, 0, 0, 0, 3786, 3787, 3, 334, 167, 0, 3787, 337, 1, 0, 0, 0, 3788, 3789, 5, 295, 0, 0, 3789, 339, 1, 0, 0, 0, 3790, 3791, 5, 46, 0, 0, 3791, 3792, 5, 351, 0, 0, 3792, 3794, 3, 1402, 701, 0, 3793, 3795, 3, 342, 171, 0, 3794, 3793, 1, 0, 0, 0, 3794, 3795, 1, 0, 0, 0, 3795, 3796, 1, 0, 0, 0, 3796, 3797, 5, 255, 0, 0, 3797, 3799, 3, 1458, 729, 0, 3798, 3800, 3, 134, 67, 0, 3799, 3798, 1, 0, 0, 0, 3799, 3800, 1, 0, 0, 0, 3800, 341, 1, 0, 0, 0, 3801, 3802, 5, 282, 0, 0, 3802, 3803, 3, 1470, 735, 0, 3803, 343, 1, 0, 0, 0, 3804, 3805, 5, 46, 0, 0, 3805, 3807, 5, 204, 0, 0, 3806, 3808, 3, 516, 258, 0, 3807, 3806, 1, 0, 0, 0, 3807, 3808, 1, 0, 0, 0, 3808, 3809, 1, 0, 0, 0, 3809, 3811, 3, 1436, 718, 0, 3810, 3812, 3, 14, 7, 0, 3811, 3810, 1, 0, 0, 0, 3811, 3812, 1, 0, 0, 0, 3812, 3813, 1, 0, 0, 0, 3813, 3814, 3, 346, 173, 0, 3814, 345, 1, 0, 0, 0, 3815, 3817, 3, 348, 174, 0, 3816, 3815, 1, 0, 0, 0, 3817, 3820, 1, 0, 0, 0, 3818, 3816, 1, 0, 0, 0, 3818, 3819, 1, 0, 0, 0, 3819, 347, 1, 0, 0, 0, 3820, 3818, 1, 0, 0, 0, 3821, 3822, 5, 323, 0, 0, 3822, 3829, 3, 1422, 711, 0, 3823, 3824, 5, 375, 0, 0, 3824, 3829, 3, 80, 40, 0, 3825, 3826, 5, 64, 0, 0, 3826, 3829, 3, 80, 40, 0, 3827, 3829, 5, 150, 0, 0, 3828, 3821, 1, 0, 0, 0, 3828, 3823, 1, 0, 0, 0, 3828, 3825, 1, 0, 0, 0, 3828, 3827, 1, 0, 0, 0, 3829, 349, 1, 0, 0, 0, 3830, 3831, 5, 138, 0, 0, 3831, 3832, 5, 204, 0, 0, 3832, 3833, 3, 1436, 718, 0, 3833, 3834, 5, 369, 0, 0, 3834, 3835, 3, 352, 176, 0, 3835, 351, 1, 0, 0, 0, 3836, 3838, 3, 354, 177, 0, 3837, 3836, 1, 0, 0, 0, 3838, 3841, 1, 0, 0, 0, 3839, 3837, 1, 0, 0, 0, 3839, 3840, 1, 0, 0, 0, 3840, 353, 1, 0, 0, 0, 3841, 3839, 1, 0, 0, 0, 3842, 3843, 5, 94, 0, 0, 3843, 3844, 3, 80, 40, 0, 3844, 355, 1, 0, 0, 0, 3845, 3846, 5, 138, 0, 0, 3846, 3847, 5, 204, 0, 0, 3847, 3848, 3, 1436, 718, 0, 3848, 3849, 3, 44, 22, 0, 3849, 3850, 3, 548, 274, 0, 3850, 3948, 1, 0, 0, 0, 3851, 3852, 5, 138, 0, 0, 3852, 3853, 5, 204, 0, 0, 3853, 3854, 3, 1436, 718, 0, 3854, 3855, 3, 44, 22, 0, 3855, 3856, 3, 546, 273, 0, 3856, 3948, 1, 0, 0, 0, 3857, 3858, 5, 138, 0, 0, 3858, 3859, 5, 204, 0, 0, 3859, 3860, 3, 1436, 718, 0, 3860, 3861, 3, 44, 22, 0, 3861, 3862, 5, 136, 0, 0, 3862, 3863, 3, 698, 349, 0, 3863, 3948, 1, 0, 0, 0, 3864, 3865, 5, 138, 0, 0, 3865, 3866, 5, 204, 0, 0, 3866, 3867, 3, 1436, 718, 0, 3867, 3868, 3, 44, 22, 0, 3868, 3869, 5, 41, 0, 0, 3869, 3870, 5, 2, 0, 0, 3870, 3871, 3, 1168, 584, 0, 3871, 3872, 5, 36, 0, 0, 3872, 3873, 3, 1168, 584, 0, 3873, 3874, 5, 3, 0, 0, 3874, 3948, 1, 0, 0, 0, 3875, 3876, 5, 138, 0, 0, 3876, 3877, 5, 204, 0, 0, 3877, 3878, 3, 1436, 718, 0, 3878, 3879, 3, 44, 22, 0, 3879, 3880, 5, 189, 0, 0, 3880, 3881, 3, 1168, 584, 0, 3881, 3948, 1, 0, 0, 0, 3882, 3883, 5, 138, 0, 0, 3883, 3884, 5, 204, 0, 0, 3884, 3885, 3, 1436, 718, 0, 3885, 3886, 3, 44, 22, 0, 3886, 3887, 5, 211, 0, 0, 3887, 3888, 3, 674, 337, 0, 3888, 3948, 1, 0, 0, 0, 3889, 3890, 5, 138, 0, 0, 3890, 3891, 5, 204, 0, 0, 3891, 3892, 3, 1436, 718, 0, 3892, 3893, 3, 44, 22, 0, 3893, 3894, 5, 278, 0, 0, 3894, 3895, 3, 736, 368, 0, 3895, 3948, 1, 0, 0, 0, 3896, 3897, 5, 138, 0, 0, 3897, 3898, 5, 204, 0, 0, 3898, 3899, 3, 1436, 718, 0, 3899, 3900, 3, 44, 22, 0, 3900, 3901, 5, 278, 0, 0, 3901, 3902, 5, 156, 0, 0, 3902, 3903, 3, 558, 279, 0, 3903, 3904, 5, 100, 0, 0, 3904, 3905, 3, 1436, 718, 0, 3905, 3948, 1, 0, 0, 0, 3906, 3907, 5, 138, 0, 0, 3907, 3908, 5, 204, 0, 0, 3908, 3909, 3, 1436, 718, 0, 3909, 3910, 3, 44, 22, 0, 3910, 3911, 5, 278, 0, 0, 3911, 3912, 5, 206, 0, 0, 3912, 3913, 3, 558, 279, 0, 3913, 3914, 5, 100, 0, 0, 3914, 3915, 3, 1436, 718, 0, 3915, 3948, 1, 0, 0, 0, 3916, 3917, 5, 138, 0, 0, 3917, 3918, 5, 204, 0, 0, 3918, 3919, 3, 1436, 718, 0, 3919, 3920, 3, 44, 22, 0, 3920, 3921, 5, 296, 0, 0, 3921, 3922, 3, 670, 335, 0, 3922, 3948, 1, 0, 0, 0, 3923, 3924, 5, 138, 0, 0, 3924, 3925, 5, 204, 0, 0, 3925, 3926, 3, 1436, 718, 0, 3926, 3927, 3, 44, 22, 0, 3927, 3928, 5, 442, 0, 0, 3928, 3929, 3, 666, 333, 0, 3929, 3948, 1, 0, 0, 0, 3930, 3931, 5, 138, 0, 0, 3931, 3932, 5, 204, 0, 0, 3932, 3933, 3, 1436, 718, 0, 3933, 3934, 3, 44, 22, 0, 3934, 3935, 5, 443, 0, 0, 3935, 3936, 5, 62, 0, 0, 3936, 3937, 3, 1168, 584, 0, 3937, 3938, 5, 247, 0, 0, 3938, 3939, 3, 1436, 718, 0, 3939, 3948, 1, 0, 0, 0, 3940, 3941, 5, 138, 0, 0, 3941, 3942, 5, 204, 0, 0, 3942, 3943, 3, 1436, 718, 0, 3943, 3944, 3, 44, 22, 0, 3944, 3945, 5, 360, 0, 0, 3945, 3946, 3, 1168, 584, 0, 3946, 3948, 1, 0, 0, 0, 3947, 3845, 1, 0, 0, 0, 3947, 3851, 1, 0, 0, 0, 3947, 3857, 1, 0, 0, 0, 3947, 3864, 1, 0, 0, 0, 3947, 3875, 1, 0, 0, 0, 3947, 3882, 1, 0, 0, 0, 3947, 3889, 1, 0, 0, 0, 3947, 3896, 1, 0, 0, 0, 3947, 3906, 1, 0, 0, 0, 3947, 3916, 1, 0, 0, 0, 3947, 3923, 1, 0, 0, 0, 3947, 3930, 1, 0, 0, 0, 3947, 3940, 1, 0, 0, 0, 3948, 357, 1, 0, 0, 0, 3949, 3950, 5, 46, 0, 0, 3950, 3951, 5, 63, 0, 0, 3951, 3952, 5, 174, 0, 0, 3952, 3953, 5, 381, 0, 0, 3953, 3955, 3, 1436, 718, 0, 3954, 3956, 3, 364, 182, 0, 3955, 3954, 1, 0, 0, 0, 3955, 3956, 1, 0, 0, 0, 3956, 3958, 1, 0, 0, 0, 3957, 3959, 3, 368, 184, 0, 3958, 3957, 1, 0, 0, 0, 3958, 3959, 1, 0, 0, 0, 3959, 359, 1, 0, 0, 0, 3960, 3961, 5, 215, 0, 0, 3961, 3969, 3, 330, 165, 0, 3962, 3963, 5, 269, 0, 0, 3963, 3969, 5, 215, 0, 0, 3964, 3965, 5, 373, 0, 0, 3965, 3969, 3, 330, 165, 0, 3966, 3967, 5, 269, 0, 0, 3967, 3969, 5, 373, 0, 0, 3968, 3960, 1, 0, 0, 0, 3968, 3962, 1, 0, 0, 0, 3968, 3964, 1, 0, 0, 0, 3968, 3966, 1, 0, 0, 0, 3969, 361, 1, 0, 0, 0, 3970, 3972, 3, 360, 180, 0, 3971, 3970, 1, 0, 0, 0, 3972, 3973, 1, 0, 0, 0, 3973, 3971, 1, 0, 0, 0, 3973, 3974, 1, 0, 0, 0, 3974, 363, 1, 0, 0, 0, 3975, 3976, 3, 362, 181, 0, 3976, 365, 1, 0, 0, 0, 3977, 3978, 5, 138, 0, 0, 3978, 3979, 5, 63, 0, 0, 3979, 3980, 5, 174, 0, 0, 3980, 3981, 5, 381, 0, 0, 3981, 3983, 3, 1436, 718, 0, 3982, 3984, 3, 364, 182, 0, 3983, 3982, 1, 0, 0, 0, 3983, 3984, 1, 0, 0, 0, 3984, 3985, 1, 0, 0, 0, 3985, 3986, 3, 372, 186, 0, 3986, 3995, 1, 0, 0, 0, 3987, 3988, 5, 138, 0, 0, 3988, 3989, 5, 63, 0, 0, 3989, 3990, 5, 174, 0, 0, 3990, 3991, 5, 381, 0, 0, 3991, 3992, 3, 1436, 718, 0, 3992, 3993, 3, 362, 181, 0, 3993, 3995, 1, 0, 0, 0, 3994, 3977, 1, 0, 0, 0, 3994, 3987, 1, 0, 0, 0, 3995, 367, 1, 0, 0, 0, 3996, 3997, 5, 280, 0, 0, 3997, 3998, 5, 2, 0, 0, 3998, 3999, 3, 370, 185, 0, 3999, 4000, 5, 3, 0, 0, 4000, 369, 1, 0, 0, 0, 4001, 4006, 3, 378, 189, 0, 4002, 4003, 5, 6, 0, 0, 4003, 4005, 3, 378, 189, 0, 4004, 4002, 1, 0, 0, 0, 4005, 4008, 1, 0, 0, 0, 4006, 4004, 1, 0, 0, 0, 4006, 4007, 1, 0, 0, 0, 4007, 371, 1, 0, 0, 0, 4008, 4006, 1, 0, 0, 0, 4009, 4010, 5, 280, 0, 0, 4010, 4011, 5, 2, 0, 0, 4011, 4012, 3, 374, 187, 0, 4012, 4013, 5, 3, 0, 0, 4013, 373, 1, 0, 0, 0, 4014, 4019, 3, 376, 188, 0, 4015, 4016, 5, 6, 0, 0, 4016, 4018, 3, 376, 188, 0, 4017, 4015, 1, 0, 0, 0, 4018, 4021, 1, 0, 0, 0, 4019, 4017, 1, 0, 0, 0, 4019, 4020, 1, 0, 0, 0, 4020, 375, 1, 0, 0, 0, 4021, 4019, 1, 0, 0, 0, 4022, 4030, 3, 378, 189, 0, 4023, 4024, 5, 333, 0, 0, 4024, 4030, 3, 378, 189, 0, 4025, 4026, 5, 133, 0, 0, 4026, 4030, 3, 378, 189, 0, 4027, 4028, 5, 191, 0, 0, 4028, 4030, 3, 378, 189, 0, 4029, 4022, 1, 0, 0, 0, 4029, 4023, 1, 0, 0, 0, 4029, 4025, 1, 0, 0, 0, 4029, 4027, 1, 0, 0, 0, 4030, 377, 1, 0, 0, 0, 4031, 4032, 3, 380, 190, 0, 4032, 4033, 3, 382, 191, 0, 4033, 379, 1, 0, 0, 0, 4034, 4035, 3, 1490, 745, 0, 4035, 381, 1, 0, 0, 0, 4036, 4037, 3, 1458, 729, 0, 4037, 383, 1, 0, 0, 0, 4038, 4039, 5, 46, 0, 0, 4039, 4041, 5, 331, 0, 0, 4040, 4042, 3, 516, 258, 0, 4041, 4040, 1, 0, 0, 0, 4041, 4042, 1, 0, 0, 0, 4042, 4043, 1, 0, 0, 0, 4043, 4045, 3, 1436, 718, 0, 4044, 4046, 3, 386, 193, 0, 4045, 4044, 1, 0, 0, 0, 4045, 4046, 1, 0, 0, 0, 4046, 4048, 1, 0, 0, 0, 4047, 4049, 3, 390, 195, 0, 4048, 4047, 1, 0, 0, 0, 4048, 4049, 1, 0, 0, 0, 4049, 4050, 1, 0, 0, 0, 4050, 4051, 5, 63, 0, 0, 4051, 4052, 5, 174, 0, 0, 4052, 4053, 5, 381, 0, 0, 4053, 4055, 3, 1436, 718, 0, 4054, 4056, 3, 368, 184, 0, 4055, 4054, 1, 0, 0, 0, 4055, 4056, 1, 0, 0, 0, 4056, 385, 1, 0, 0, 0, 4057, 4058, 5, 360, 0, 0, 4058, 4059, 3, 1458, 729, 0, 4059, 387, 1, 0, 0, 0, 4060, 4063, 5, 375, 0, 0, 4061, 4064, 3, 1458, 729, 0, 4062, 4064, 5, 78, 0, 0, 4063, 4061, 1, 0, 0, 0, 4063, 4062, 1, 0, 0, 0, 4064, 389, 1, 0, 0, 0, 4065, 4066, 3, 388, 194, 0, 4066, 391, 1, 0, 0, 0, 4067, 4068, 5, 138, 0, 0, 4068, 4069, 5, 331, 0, 0, 4069, 4075, 3, 1436, 718, 0, 4070, 4076, 3, 372, 186, 0, 4071, 4073, 3, 388, 194, 0, 4072, 4074, 3, 372, 186, 0, 4073, 4072, 1, 0, 0, 0, 4073, 4074, 1, 0, 0, 0, 4074, 4076, 1, 0, 0, 0, 4075, 4070, 1, 0, 0, 0, 4075, 4071, 1, 0, 0, 0, 4076, 393, 1, 0, 0, 0, 4077, 4078, 5, 46, 0, 0, 4078, 4079, 5, 63, 0, 0, 4079, 4081, 5, 92, 0, 0, 4080, 4082, 3, 516, 258, 0, 4081, 4080, 1, 0, 0, 0, 4081, 4082, 1, 0, 0, 0, 4082, 4083, 1, 0, 0, 0, 4083, 4084, 3, 1404, 702, 0, 4084, 4086, 5, 2, 0, 0, 4085, 4087, 3, 194, 97, 0, 4086, 4085, 1, 0, 0, 0, 4086, 4087, 1, 0, 0, 0, 4087, 4088, 1, 0, 0, 0, 4088, 4090, 5, 3, 0, 0, 4089, 4091, 3, 266, 133, 0, 4090, 4089, 1, 0, 0, 0, 4090, 4091, 1, 0, 0, 0, 4091, 4092, 1, 0, 0, 0, 4092, 4093, 5, 331, 0, 0, 4093, 4095, 3, 1436, 718, 0, 4094, 4096, 3, 368, 184, 0, 4095, 4094, 1, 0, 0, 0, 4095, 4096, 1, 0, 0, 0, 4096, 4117, 1, 0, 0, 0, 4097, 4098, 5, 46, 0, 0, 4098, 4099, 5, 63, 0, 0, 4099, 4101, 5, 92, 0, 0, 4100, 4102, 3, 516, 258, 0, 4101, 4100, 1, 0, 0, 0, 4101, 4102, 1, 0, 0, 0, 4102, 4103, 1, 0, 0, 0, 4103, 4104, 3, 1404, 702, 0, 4104, 4105, 5, 285, 0, 0, 4105, 4106, 5, 275, 0, 0, 4106, 4108, 3, 1406, 703, 0, 4107, 4109, 3, 196, 98, 0, 4108, 4107, 1, 0, 0, 0, 4108, 4109, 1, 0, 0, 0, 4109, 4110, 1, 0, 0, 0, 4110, 4111, 3, 144, 72, 0, 4111, 4112, 5, 331, 0, 0, 4112, 4114, 3, 1436, 718, 0, 4113, 4115, 3, 368, 184, 0, 4114, 4113, 1, 0, 0, 0, 4114, 4115, 1, 0, 0, 0, 4115, 4117, 1, 0, 0, 0, 4116, 4077, 1, 0, 0, 0, 4116, 4097, 1, 0, 0, 0, 4117, 395, 1, 0, 0, 0, 4118, 4119, 5, 444, 0, 0, 4119, 4120, 5, 63, 0, 0, 4120, 4121, 5, 323, 0, 0, 4121, 4123, 3, 1422, 711, 0, 4122, 4124, 3, 400, 200, 0, 4123, 4122, 1, 0, 0, 0, 4123, 4124, 1, 0, 0, 0, 4124, 4125, 1, 0, 0, 0, 4125, 4126, 5, 64, 0, 0, 4126, 4127, 5, 331, 0, 0, 4127, 4128, 3, 1436, 718, 0, 4128, 4129, 5, 71, 0, 0, 4129, 4131, 3, 1436, 718, 0, 4130, 4132, 3, 368, 184, 0, 4131, 4130, 1, 0, 0, 0, 4131, 4132, 1, 0, 0, 0, 4132, 397, 1, 0, 0, 0, 4133, 4134, 5, 74, 0, 0, 4134, 4137, 5, 94, 0, 0, 4135, 4137, 5, 59, 0, 0, 4136, 4133, 1, 0, 0, 0, 4136, 4135, 1, 0, 0, 0, 4137, 399, 1, 0, 0, 0, 4138, 4139, 3, 398, 199, 0, 4139, 4140, 5, 2, 0, 0, 4140, 4141, 3, 1124, 562, 0, 4141, 4142, 5, 3, 0, 0, 4142, 401, 1, 0, 0, 0, 4143, 4144, 5, 46, 0, 0, 4144, 4145, 5, 99, 0, 0, 4145, 4147, 5, 257, 0, 0, 4146, 4148, 3, 516, 258, 0, 4147, 4146, 1, 0, 0, 0, 4147, 4148, 1, 0, 0, 0, 4148, 4149, 1, 0, 0, 0, 4149, 4150, 5, 62, 0, 0, 4150, 4151, 3, 404, 202, 0, 4151, 4152, 5, 331, 0, 0, 4152, 4154, 3, 1436, 718, 0, 4153, 4155, 3, 368, 184, 0, 4154, 4153, 1, 0, 0, 0, 4154, 4155, 1, 0, 0, 0, 4155, 403, 1, 0, 0, 0, 4156, 4159, 3, 1470, 735, 0, 4157, 4159, 5, 99, 0, 0, 4158, 4156, 1, 0, 0, 0, 4158, 4157, 1, 0, 0, 0, 4159, 405, 1, 0, 0, 0, 4160, 4161, 5, 138, 0, 0, 4161, 4162, 5, 99, 0, 0, 4162, 4163, 5, 257, 0, 0, 4163, 4164, 5, 62, 0, 0, 4164, 4165, 3, 404, 202, 0, 4165, 4166, 5, 331, 0, 0, 4166, 4167, 3, 1436, 718, 0, 4167, 4168, 3, 372, 186, 0, 4168, 407, 1, 0, 0, 0, 4169, 4170, 5, 46, 0, 0, 4170, 4171, 5, 445, 0, 0, 4171, 4172, 3, 1436, 718, 0, 4172, 4173, 5, 80, 0, 0, 4173, 4175, 3, 1412, 706, 0, 4174, 4176, 3, 426, 213, 0, 4175, 4174, 1, 0, 0, 0, 4175, 4176, 1, 0, 0, 0, 4176, 4178, 1, 0, 0, 0, 4177, 4179, 3, 428, 214, 0, 4178, 4177, 1, 0, 0, 0, 4178, 4179, 1, 0, 0, 0, 4179, 4181, 1, 0, 0, 0, 4180, 4182, 3, 422, 211, 0, 4181, 4180, 1, 0, 0, 0, 4181, 4182, 1, 0, 0, 0, 4182, 4184, 1, 0, 0, 0, 4183, 4185, 3, 418, 209, 0, 4184, 4183, 1, 0, 0, 0, 4184, 4185, 1, 0, 0, 0, 4185, 4187, 1, 0, 0, 0, 4186, 4188, 3, 420, 210, 0, 4187, 4186, 1, 0, 0, 0, 4187, 4188, 1, 0, 0, 0, 4188, 409, 1, 0, 0, 0, 4189, 4190, 5, 138, 0, 0, 4190, 4191, 5, 445, 0, 0, 4191, 4192, 3, 1436, 718, 0, 4192, 4193, 5, 80, 0, 0, 4193, 4195, 3, 1412, 706, 0, 4194, 4196, 3, 424, 212, 0, 4195, 4194, 1, 0, 0, 0, 4195, 4196, 1, 0, 0, 0, 4196, 4198, 1, 0, 0, 0, 4197, 4199, 3, 418, 209, 0, 4198, 4197, 1, 0, 0, 0, 4198, 4199, 1, 0, 0, 0, 4199, 4201, 1, 0, 0, 0, 4200, 4202, 3, 420, 210, 0, 4201, 4200, 1, 0, 0, 0, 4201, 4202, 1, 0, 0, 0, 4202, 411, 1, 0, 0, 0, 4203, 4204, 5, 138, 0, 0, 4204, 4205, 5, 296, 0, 0, 4205, 4207, 3, 1428, 714, 0, 4206, 4208, 3, 660, 330, 0, 4207, 4206, 1, 0, 0, 0, 4207, 4208, 1, 0, 0, 0, 4208, 4209, 1, 0, 0, 0, 4209, 4210, 3, 414, 207, 0, 4210, 413, 1, 0, 0, 0, 4211, 4215, 3, 416, 208, 0, 4212, 4214, 3, 416, 208, 0, 4213, 4212, 1, 0, 0, 0, 4214, 4217, 1, 0, 0, 0, 4215, 4213, 1, 0, 0, 0, 4215, 4216, 1, 0, 0, 0, 4216, 4219, 1, 0, 0, 0, 4217, 4215, 1, 0, 0, 0, 4218, 4220, 5, 315, 0, 0, 4219, 4218, 1, 0, 0, 0, 4219, 4220, 1, 0, 0, 0, 4220, 4238, 1, 0, 0, 0, 4221, 4222, 5, 309, 0, 0, 4222, 4223, 5, 94, 0, 0, 4223, 4238, 3, 1430, 715, 0, 4224, 4225, 5, 282, 0, 0, 4225, 4226, 5, 94, 0, 0, 4226, 4238, 3, 1470, 735, 0, 4227, 4228, 5, 333, 0, 0, 4228, 4229, 5, 323, 0, 0, 4229, 4238, 3, 48, 24, 0, 4230, 4232, 5, 269, 0, 0, 4231, 4230, 1, 0, 0, 0, 4231, 4232, 1, 0, 0, 0, 4232, 4233, 1, 0, 0, 0, 4233, 4234, 5, 462, 0, 0, 4234, 4235, 5, 80, 0, 0, 4235, 4236, 5, 204, 0, 0, 4236, 4238, 3, 1436, 718, 0, 4237, 4211, 1, 0, 0, 0, 4237, 4221, 1, 0, 0, 0, 4237, 4224, 1, 0, 0, 0, 4237, 4227, 1, 0, 0, 0, 4237, 4231, 1, 0, 0, 0, 4238, 415, 1, 0, 0, 0, 4239, 4241, 5, 205, 0, 0, 4240, 4239, 1, 0, 0, 0, 4240, 4241, 1, 0, 0, 0, 4241, 4242, 1, 0, 0, 0, 4242, 4243, 5, 327, 0, 0, 4243, 4250, 5, 243, 0, 0, 4244, 4246, 5, 205, 0, 0, 4245, 4244, 1, 0, 0, 0, 4245, 4246, 1, 0, 0, 0, 4246, 4247, 1, 0, 0, 0, 4247, 4248, 5, 327, 0, 0, 4248, 4250, 5, 181, 0, 0, 4249, 4240, 1, 0, 0, 0, 4249, 4245, 1, 0, 0, 0, 4250, 4268, 1, 0, 0, 0, 4251, 4252, 5, 333, 0, 0, 4252, 4253, 3, 1436, 718, 0, 4253, 4256, 7, 31, 0, 0, 4254, 4257, 3, 1436, 718, 0, 4255, 4257, 5, 53, 0, 0, 4256, 4254, 1, 0, 0, 0, 4256, 4255, 1, 0, 0, 0, 4257, 4268, 1, 0, 0, 0, 4258, 4259, 5, 333, 0, 0, 4259, 4260, 3, 1436, 718, 0, 4260, 4261, 5, 64, 0, 0, 4261, 4262, 5, 434, 0, 0, 4262, 4268, 1, 0, 0, 0, 4263, 4264, 5, 313, 0, 0, 4264, 4268, 3, 1436, 718, 0, 4265, 4266, 5, 313, 0, 0, 4266, 4268, 5, 30, 0, 0, 4267, 4249, 1, 0, 0, 0, 4267, 4251, 1, 0, 0, 0, 4267, 4258, 1, 0, 0, 0, 4267, 4263, 1, 0, 0, 0, 4267, 4265, 1, 0, 0, 0, 4268, 417, 1, 0, 0, 0, 4269, 4270, 5, 100, 0, 0, 4270, 4271, 5, 2, 0, 0, 4271, 4272, 3, 1212, 606, 0, 4272, 4273, 5, 3, 0, 0, 4273, 419, 1, 0, 0, 0, 4274, 4275, 5, 105, 0, 0, 4275, 4276, 5, 42, 0, 0, 4276, 4277, 5, 2, 0, 0, 4277, 4278, 3, 1212, 606, 0, 4278, 4279, 5, 3, 0, 0, 4279, 421, 1, 0, 0, 0, 4280, 4281, 5, 94, 0, 0, 4281, 4282, 3, 1472, 736, 0, 4282, 423, 1, 0, 0, 0, 4283, 4284, 5, 94, 0, 0, 4284, 4285, 3, 1472, 736, 0, 4285, 425, 1, 0, 0, 0, 4286, 4290, 5, 36, 0, 0, 4287, 4291, 5, 541, 0, 0, 4288, 4291, 5, 542, 0, 0, 4289, 4291, 3, 1492, 746, 0, 4290, 4287, 1, 0, 0, 0, 4290, 4288, 1, 0, 0, 0, 4290, 4289, 1, 0, 0, 0, 4291, 427, 1, 0, 0, 0, 4292, 4293, 5, 62, 0, 0, 4293, 4294, 3, 430, 215, 0, 4294, 429, 1, 0, 0, 0, 4295, 4296, 7, 32, 0, 0, 4296, 431, 1, 0, 0, 0, 4297, 4298, 5, 46, 0, 0, 4298, 4299, 5, 131, 0, 0, 4299, 4300, 5, 446, 0, 0, 4300, 4301, 3, 1436, 718, 0, 4301, 4302, 5, 360, 0, 0, 4302, 4303, 3, 434, 217, 0, 4303, 4304, 5, 215, 0, 0, 4304, 4305, 3, 330, 165, 0, 4305, 433, 1, 0, 0, 0, 4306, 4307, 7, 33, 0, 0, 4307, 435, 1, 0, 0, 0, 4308, 4310, 5, 46, 0, 0, 4309, 4311, 3, 658, 329, 0, 4310, 4309, 1, 0, 0, 0, 4310, 4311, 1, 0, 0, 0, 4311, 4312, 1, 0, 0, 0, 4312, 4313, 5, 357, 0, 0, 4313, 4314, 3, 1436, 718, 0, 4314, 4315, 3, 438, 219, 0, 4315, 4316, 3, 444, 222, 0, 4316, 4317, 5, 80, 0, 0, 4317, 4319, 3, 1406, 703, 0, 4318, 4320, 3, 448, 224, 0, 4319, 4318, 1, 0, 0, 0, 4319, 4320, 1, 0, 0, 0, 4320, 4322, 1, 0, 0, 0, 4321, 4323, 3, 460, 230, 0, 4322, 4321, 1, 0, 0, 0, 4322, 4323, 1, 0, 0, 0, 4323, 4325, 1, 0, 0, 0, 4324, 4326, 3, 466, 233, 0, 4325, 4324, 1, 0, 0, 0, 4325, 4326, 1, 0, 0, 0, 4326, 4327, 1, 0, 0, 0, 4327, 4328, 5, 202, 0, 0, 4328, 4329, 3, 468, 234, 0, 4329, 4330, 5, 2, 0, 0, 4330, 4331, 3, 470, 235, 0, 4331, 4332, 5, 3, 0, 0, 4332, 4363, 1, 0, 0, 0, 4333, 4335, 5, 46, 0, 0, 4334, 4336, 3, 658, 329, 0, 4335, 4334, 1, 0, 0, 0, 4335, 4336, 1, 0, 0, 0, 4336, 4338, 1, 0, 0, 0, 4337, 4339, 5, 45, 0, 0, 4338, 4337, 1, 0, 0, 0, 4338, 4339, 1, 0, 0, 0, 4339, 4340, 1, 0, 0, 0, 4340, 4341, 5, 357, 0, 0, 4341, 4342, 3, 1436, 718, 0, 4342, 4343, 3, 438, 219, 0, 4343, 4344, 3, 444, 222, 0, 4344, 4345, 5, 80, 0, 0, 4345, 4347, 3, 1406, 703, 0, 4346, 4348, 3, 474, 237, 0, 4347, 4346, 1, 0, 0, 0, 4347, 4348, 1, 0, 0, 0, 4348, 4349, 1, 0, 0, 0, 4349, 4351, 3, 476, 238, 0, 4350, 4352, 3, 440, 220, 0, 4351, 4350, 1, 0, 0, 0, 4351, 4352, 1, 0, 0, 0, 4352, 4354, 1, 0, 0, 0, 4353, 4355, 3, 466, 233, 0, 4354, 4353, 1, 0, 0, 0, 4354, 4355, 1, 0, 0, 0, 4355, 4356, 1, 0, 0, 0, 4356, 4357, 5, 202, 0, 0, 4357, 4358, 3, 468, 234, 0, 4358, 4359, 5, 2, 0, 0, 4359, 4360, 3, 470, 235, 0, 4360, 4361, 5, 3, 0, 0, 4361, 4363, 1, 0, 0, 0, 4362, 4308, 1, 0, 0, 0, 4362, 4333, 1, 0, 0, 0, 4363, 437, 1, 0, 0, 0, 4364, 4369, 5, 145, 0, 0, 4365, 4369, 5, 135, 0, 0, 4366, 4367, 5, 242, 0, 0, 4367, 4369, 5, 275, 0, 0, 4368, 4364, 1, 0, 0, 0, 4368, 4365, 1, 0, 0, 0, 4368, 4366, 1, 0, 0, 0, 4369, 439, 1, 0, 0, 0, 4370, 4372, 5, 62, 0, 0, 4371, 4373, 5, 192, 0, 0, 4372, 4371, 1, 0, 0, 0, 4372, 4373, 1, 0, 0, 0, 4373, 4374, 1, 0, 0, 0, 4374, 4375, 3, 442, 221, 0, 4375, 441, 1, 0, 0, 0, 4376, 4377, 7, 34, 0, 0, 4377, 443, 1, 0, 0, 0, 4378, 4383, 3, 446, 223, 0, 4379, 4380, 5, 82, 0, 0, 4380, 4382, 3, 446, 223, 0, 4381, 4379, 1, 0, 0, 0, 4382, 4385, 1, 0, 0, 0, 4383, 4381, 1, 0, 0, 0, 4383, 4384, 1, 0, 0, 0, 4384, 445, 1, 0, 0, 0, 4385, 4383, 1, 0, 0, 0, 4386, 4394, 5, 241, 0, 0, 4387, 4394, 5, 182, 0, 0, 4388, 4394, 5, 369, 0, 0, 4389, 4390, 5, 369, 0, 0, 4390, 4391, 5, 275, 0, 0, 4391, 4394, 3, 244, 122, 0, 4392, 4394, 5, 358, 0, 0, 4393, 4386, 1, 0, 0, 0, 4393, 4387, 1, 0, 0, 0, 4393, 4388, 1, 0, 0, 0, 4393, 4389, 1, 0, 0, 0, 4393, 4392, 1, 0, 0, 0, 4394, 447, 1, 0, 0, 0, 4395, 4396, 5, 447, 0, 0, 4396, 4397, 3, 450, 225, 0, 4397, 449, 1, 0, 0, 0, 4398, 4400, 3, 452, 226, 0, 4399, 4398, 1, 0, 0, 0, 4400, 4401, 1, 0, 0, 0, 4401, 4399, 1, 0, 0, 0, 4401, 4402, 1, 0, 0, 0, 4402, 451, 1, 0, 0, 0, 4403, 4404, 3, 454, 227, 0, 4404, 4406, 3, 456, 228, 0, 4405, 4407, 3, 872, 436, 0, 4406, 4405, 1, 0, 0, 0, 4406, 4407, 1, 0, 0, 0, 4407, 4408, 1, 0, 0, 0, 4408, 4409, 3, 458, 229, 0, 4409, 453, 1, 0, 0, 0, 4410, 4411, 7, 35, 0, 0, 4411, 455, 1, 0, 0, 0, 4412, 4413, 7, 36, 0, 0, 4413, 457, 1, 0, 0, 0, 4414, 4415, 3, 1474, 737, 0, 4415, 459, 1, 0, 0, 0, 4416, 4418, 5, 62, 0, 0, 4417, 4419, 3, 462, 231, 0, 4418, 4417, 1, 0, 0, 0, 4418, 4419, 1, 0, 0, 0, 4419, 4420, 1, 0, 0, 0, 4420, 4421, 3, 464, 232, 0, 4421, 461, 1, 0, 0, 0, 4422, 4423, 5, 192, 0, 0, 4423, 463, 1, 0, 0, 0, 4424, 4425, 7, 34, 0, 0, 4425, 465, 1, 0, 0, 0, 4426, 4427, 5, 102, 0, 0, 4427, 4428, 5, 2, 0, 0, 4428, 4429, 3, 1212, 606, 0, 4429, 4430, 5, 3, 0, 0, 4430, 467, 1, 0, 0, 0, 4431, 4432, 5, 211, 0, 0, 4432, 4436, 3, 1444, 722, 0, 4433, 4434, 5, 296, 0, 0, 4434, 4436, 3, 1428, 714, 0, 4435, 4431, 1, 0, 0, 0, 4435, 4433, 1, 0, 0, 0, 4436, 469, 1, 0, 0, 0, 4437, 4440, 3, 472, 236, 0, 4438, 4440, 1, 0, 0, 0, 4439, 4437, 1, 0, 0, 0, 4439, 4438, 1, 0, 0, 0, 4440, 4445, 1, 0, 0, 0, 4441, 4442, 5, 6, 0, 0, 4442, 4444, 3, 472, 236, 0, 4443, 4441, 1, 0, 0, 0, 4444, 4447, 1, 0, 0, 0, 4445, 4443, 1, 0, 0, 0, 4445, 4446, 1, 0, 0, 0, 4446, 471, 1, 0, 0, 0, 4447, 4445, 1, 0, 0, 0, 4448, 4453, 3, 1456, 728, 0, 4449, 4453, 3, 1454, 727, 0, 4450, 4453, 3, 1458, 729, 0, 4451, 4453, 3, 1490, 745, 0, 4452, 4448, 1, 0, 0, 0, 4452, 4449, 1, 0, 0, 0, 4452, 4450, 1, 0, 0, 0, 4452, 4451, 1, 0, 0, 0, 4453, 473, 1, 0, 0, 0, 4454, 4455, 5, 64, 0, 0, 4455, 4456, 3, 1412, 706, 0, 4456, 475, 1, 0, 0, 0, 4457, 4459, 3, 478, 239, 0, 4458, 4457, 1, 0, 0, 0, 4459, 4462, 1, 0, 0, 0, 4460, 4458, 1, 0, 0, 0, 4460, 4461, 1, 0, 0, 0, 4461, 477, 1, 0, 0, 0, 4462, 4460, 1, 0, 0, 0, 4463, 4464, 5, 77, 0, 0, 4464, 4475, 5, 54, 0, 0, 4465, 4475, 5, 54, 0, 0, 4466, 4467, 5, 69, 0, 0, 4467, 4475, 5, 221, 0, 0, 4468, 4469, 5, 69, 0, 0, 4469, 4475, 5, 180, 0, 0, 4470, 4471, 5, 77, 0, 0, 4471, 4475, 5, 371, 0, 0, 4472, 4473, 5, 269, 0, 0, 4473, 4475, 5, 228, 0, 0, 4474, 4463, 1, 0, 0, 0, 4474, 4465, 1, 0, 0, 0, 4474, 4466, 1, 0, 0, 0, 4474, 4468, 1, 0, 0, 0, 4474, 4470, 1, 0, 0, 0, 4474, 4472, 1, 0, 0, 0, 4475, 479, 1, 0, 0, 0, 4476, 4477, 5, 46, 0, 0, 4477, 4478, 5, 198, 0, 0, 4478, 4479, 5, 357, 0, 0, 4479, 4480, 3, 1436, 718, 0, 4480, 4481, 5, 80, 0, 0, 4481, 4482, 3, 1490, 745, 0, 4482, 4483, 5, 202, 0, 0, 4483, 4484, 3, 468, 234, 0, 4484, 4485, 5, 2, 0, 0, 4485, 4486, 5, 3, 0, 0, 4486, 4501, 1, 0, 0, 0, 4487, 4488, 5, 46, 0, 0, 4488, 4489, 5, 198, 0, 0, 4489, 4490, 5, 357, 0, 0, 4490, 4491, 3, 1436, 718, 0, 4491, 4492, 5, 80, 0, 0, 4492, 4493, 3, 1490, 745, 0, 4493, 4494, 5, 102, 0, 0, 4494, 4495, 3, 482, 241, 0, 4495, 4496, 5, 202, 0, 0, 4496, 4497, 3, 468, 234, 0, 4497, 4498, 5, 2, 0, 0, 4498, 4499, 5, 3, 0, 0, 4499, 4501, 1, 0, 0, 0, 4500, 4476, 1, 0, 0, 0, 4500, 4487, 1, 0, 0, 0, 4501, 481, 1, 0, 0, 0, 4502, 4507, 3, 484, 242, 0, 4503, 4504, 5, 33, 0, 0, 4504, 4506, 3, 484, 242, 0, 4505, 4503, 1, 0, 0, 0, 4506, 4509, 1, 0, 0, 0, 4507, 4505, 1, 0, 0, 0, 4507, 4508, 1, 0, 0, 0, 4508, 483, 1, 0, 0, 0, 4509, 4507, 1, 0, 0, 0, 4510, 4511, 3, 1474, 737, 0, 4511, 4512, 5, 68, 0, 0, 4512, 4513, 5, 2, 0, 0, 4513, 4514, 3, 486, 243, 0, 4514, 4515, 5, 3, 0, 0, 4515, 485, 1, 0, 0, 0, 4516, 4521, 3, 1458, 729, 0, 4517, 4518, 5, 6, 0, 0, 4518, 4520, 3, 1458, 729, 0, 4519, 4517, 1, 0, 0, 0, 4520, 4523, 1, 0, 0, 0, 4521, 4519, 1, 0, 0, 0, 4521, 4522, 1, 0, 0, 0, 4522, 487, 1, 0, 0, 0, 4523, 4521, 1, 0, 0, 0, 4524, 4525, 5, 138, 0, 0, 4525, 4526, 5, 198, 0, 0, 4526, 4527, 5, 357, 0, 0, 4527, 4528, 3, 1436, 718, 0, 4528, 4529, 3, 490, 245, 0, 4529, 489, 1, 0, 0, 0, 4530, 4532, 5, 193, 0, 0, 4531, 4533, 7, 20, 0, 0, 4532, 4531, 1, 0, 0, 0, 4532, 4533, 1, 0, 0, 0, 4533, 4536, 1, 0, 0, 0, 4534, 4536, 5, 186, 0, 0, 4535, 4530, 1, 0, 0, 0, 4535, 4534, 1, 0, 0, 0, 4536, 491, 1, 0, 0, 0, 4537, 4538, 5, 46, 0, 0, 4538, 4539, 5, 140, 0, 0, 4539, 4540, 3, 558, 279, 0, 4540, 4541, 5, 42, 0, 0, 4541, 4542, 5, 2, 0, 0, 4542, 4543, 3, 1212, 606, 0, 4543, 4544, 5, 3, 0, 0, 4544, 4545, 3, 476, 238, 0, 4545, 493, 1, 0, 0, 0, 4546, 4548, 5, 46, 0, 0, 4547, 4549, 3, 658, 329, 0, 4548, 4547, 1, 0, 0, 0, 4548, 4549, 1, 0, 0, 0, 4549, 4550, 1, 0, 0, 0, 4550, 4551, 5, 136, 0, 0, 4551, 4552, 3, 1444, 722, 0, 4552, 4553, 3, 694, 347, 0, 4553, 4554, 3, 496, 248, 0, 4554, 4650, 1, 0, 0, 0, 4555, 4557, 5, 46, 0, 0, 4556, 4558, 3, 658, 329, 0, 4557, 4556, 1, 0, 0, 0, 4557, 4558, 1, 0, 0, 0, 4558, 4559, 1, 0, 0, 0, 4559, 4560, 5, 136, 0, 0, 4560, 4561, 3, 1444, 722, 0, 4561, 4562, 3, 504, 252, 0, 4562, 4650, 1, 0, 0, 0, 4563, 4564, 5, 46, 0, 0, 4564, 4565, 5, 278, 0, 0, 4565, 4566, 3, 732, 366, 0, 4566, 4567, 3, 496, 248, 0, 4567, 4650, 1, 0, 0, 0, 4568, 4569, 5, 46, 0, 0, 4569, 4570, 5, 360, 0, 0, 4570, 4571, 3, 558, 279, 0, 4571, 4572, 3, 496, 248, 0, 4572, 4650, 1, 0, 0, 0, 4573, 4574, 5, 46, 0, 0, 4574, 4575, 5, 360, 0, 0, 4575, 4650, 3, 558, 279, 0, 4576, 4577, 5, 46, 0, 0, 4577, 4578, 5, 360, 0, 0, 4578, 4579, 3, 558, 279, 0, 4579, 4580, 5, 36, 0, 0, 4580, 4582, 5, 2, 0, 0, 4581, 4583, 3, 1148, 574, 0, 4582, 4581, 1, 0, 0, 0, 4582, 4583, 1, 0, 0, 0, 4583, 4584, 1, 0, 0, 0, 4584, 4585, 5, 3, 0, 0, 4585, 4650, 1, 0, 0, 0, 4586, 4587, 5, 46, 0, 0, 4587, 4588, 5, 360, 0, 0, 4588, 4589, 3, 558, 279, 0, 4589, 4590, 5, 36, 0, 0, 4590, 4591, 5, 196, 0, 0, 4591, 4593, 5, 2, 0, 0, 4592, 4594, 3, 510, 255, 0, 4593, 4592, 1, 0, 0, 0, 4593, 4594, 1, 0, 0, 0, 4594, 4595, 1, 0, 0, 0, 4595, 4596, 5, 3, 0, 0, 4596, 4650, 1, 0, 0, 0, 4597, 4598, 5, 46, 0, 0, 4598, 4599, 5, 360, 0, 0, 4599, 4600, 3, 558, 279, 0, 4600, 4601, 5, 36, 0, 0, 4601, 4602, 5, 299, 0, 0, 4602, 4603, 3, 496, 248, 0, 4603, 4650, 1, 0, 0, 0, 4604, 4605, 5, 46, 0, 0, 4605, 4606, 5, 355, 0, 0, 4606, 4607, 5, 325, 0, 0, 4607, 4608, 5, 283, 0, 0, 4608, 4609, 3, 558, 279, 0, 4609, 4610, 3, 496, 248, 0, 4610, 4650, 1, 0, 0, 0, 4611, 4612, 5, 46, 0, 0, 4612, 4613, 5, 355, 0, 0, 4613, 4614, 5, 325, 0, 0, 4614, 4615, 5, 185, 0, 0, 4615, 4616, 3, 558, 279, 0, 4616, 4617, 3, 496, 248, 0, 4617, 4650, 1, 0, 0, 0, 4618, 4619, 5, 46, 0, 0, 4619, 4620, 5, 355, 0, 0, 4620, 4621, 5, 325, 0, 0, 4621, 4622, 5, 353, 0, 0, 4622, 4623, 3, 558, 279, 0, 4623, 4624, 3, 496, 248, 0, 4624, 4650, 1, 0, 0, 0, 4625, 4626, 5, 46, 0, 0, 4626, 4627, 5, 355, 0, 0, 4627, 4628, 5, 325, 0, 0, 4628, 4629, 5, 163, 0, 0, 4629, 4630, 3, 558, 279, 0, 4630, 4631, 3, 496, 248, 0, 4631, 4650, 1, 0, 0, 0, 4632, 4633, 5, 46, 0, 0, 4633, 4635, 5, 108, 0, 0, 4634, 4636, 3, 516, 258, 0, 4635, 4634, 1, 0, 0, 0, 4635, 4636, 1, 0, 0, 0, 4636, 4637, 1, 0, 0, 0, 4637, 4638, 3, 558, 279, 0, 4638, 4639, 3, 496, 248, 0, 4639, 4650, 1, 0, 0, 0, 4640, 4641, 5, 46, 0, 0, 4641, 4643, 5, 108, 0, 0, 4642, 4644, 3, 516, 258, 0, 4643, 4642, 1, 0, 0, 0, 4643, 4644, 1, 0, 0, 0, 4644, 4645, 1, 0, 0, 0, 4645, 4646, 3, 558, 279, 0, 4646, 4647, 5, 64, 0, 0, 4647, 4648, 3, 558, 279, 0, 4648, 4650, 1, 0, 0, 0, 4649, 4546, 1, 0, 0, 0, 4649, 4555, 1, 0, 0, 0, 4649, 4563, 1, 0, 0, 0, 4649, 4568, 1, 0, 0, 0, 4649, 4573, 1, 0, 0, 0, 4649, 4576, 1, 0, 0, 0, 4649, 4586, 1, 0, 0, 0, 4649, 4597, 1, 0, 0, 0, 4649, 4604, 1, 0, 0, 0, 4649, 4611, 1, 0, 0, 0, 4649, 4618, 1, 0, 0, 0, 4649, 4625, 1, 0, 0, 0, 4649, 4632, 1, 0, 0, 0, 4649, 4640, 1, 0, 0, 0, 4650, 495, 1, 0, 0, 0, 4651, 4652, 5, 2, 0, 0, 4652, 4653, 3, 498, 249, 0, 4653, 4654, 5, 3, 0, 0, 4654, 497, 1, 0, 0, 0, 4655, 4660, 3, 500, 250, 0, 4656, 4657, 5, 6, 0, 0, 4657, 4659, 3, 500, 250, 0, 4658, 4656, 1, 0, 0, 0, 4659, 4662, 1, 0, 0, 0, 4660, 4658, 1, 0, 0, 0, 4660, 4661, 1, 0, 0, 0, 4661, 499, 1, 0, 0, 0, 4662, 4660, 1, 0, 0, 0, 4663, 4666, 3, 1490, 745, 0, 4664, 4665, 5, 10, 0, 0, 4665, 4667, 3, 502, 251, 0, 4666, 4664, 1, 0, 0, 0, 4666, 4667, 1, 0, 0, 0, 4667, 501, 1, 0, 0, 0, 4668, 4675, 3, 688, 344, 0, 4669, 4675, 3, 1502, 751, 0, 4670, 4675, 3, 1324, 662, 0, 4671, 4675, 3, 322, 161, 0, 4672, 4675, 3, 1458, 729, 0, 4673, 4675, 5, 407, 0, 0, 4674, 4668, 1, 0, 0, 0, 4674, 4669, 1, 0, 0, 0, 4674, 4670, 1, 0, 0, 0, 4674, 4671, 1, 0, 0, 0, 4674, 4672, 1, 0, 0, 0, 4674, 4673, 1, 0, 0, 0, 4675, 503, 1, 0, 0, 0, 4676, 4677, 5, 2, 0, 0, 4677, 4678, 3, 506, 253, 0, 4678, 4679, 5, 3, 0, 0, 4679, 505, 1, 0, 0, 0, 4680, 4685, 3, 508, 254, 0, 4681, 4682, 5, 6, 0, 0, 4682, 4684, 3, 508, 254, 0, 4683, 4681, 1, 0, 0, 0, 4684, 4687, 1, 0, 0, 0, 4685, 4683, 1, 0, 0, 0, 4685, 4686, 1, 0, 0, 0, 4686, 507, 1, 0, 0, 0, 4687, 4685, 1, 0, 0, 0, 4688, 4689, 3, 1492, 746, 0, 4689, 4690, 5, 10, 0, 0, 4690, 4691, 3, 502, 251, 0, 4691, 509, 1, 0, 0, 0, 4692, 4693, 3, 512, 256, 0, 4693, 511, 1, 0, 0, 0, 4694, 4699, 3, 1458, 729, 0, 4695, 4696, 5, 6, 0, 0, 4696, 4698, 3, 1458, 729, 0, 4697, 4695, 1, 0, 0, 0, 4698, 4701, 1, 0, 0, 0, 4699, 4697, 1, 0, 0, 0, 4699, 4700, 1, 0, 0, 0, 4700, 513, 1, 0, 0, 0, 4701, 4699, 1, 0, 0, 0, 4702, 4703, 5, 138, 0, 0, 4703, 4704, 5, 360, 0, 0, 4704, 4705, 3, 558, 279, 0, 4705, 4706, 5, 133, 0, 0, 4706, 4708, 5, 450, 0, 0, 4707, 4709, 3, 516, 258, 0, 4708, 4707, 1, 0, 0, 0, 4708, 4709, 1, 0, 0, 0, 4709, 4710, 1, 0, 0, 0, 4710, 4713, 3, 1458, 729, 0, 4711, 4712, 7, 37, 0, 0, 4712, 4714, 3, 1458, 729, 0, 4713, 4711, 1, 0, 0, 0, 4713, 4714, 1, 0, 0, 0, 4714, 4725, 1, 0, 0, 0, 4715, 4716, 5, 138, 0, 0, 4716, 4717, 5, 360, 0, 0, 4717, 4718, 3, 558, 279, 0, 4718, 4719, 5, 309, 0, 0, 4719, 4720, 5, 450, 0, 0, 4720, 4721, 3, 1458, 729, 0, 4721, 4722, 5, 94, 0, 0, 4722, 4723, 3, 1458, 729, 0, 4723, 4725, 1, 0, 0, 0, 4724, 4702, 1, 0, 0, 0, 4724, 4715, 1, 0, 0, 0, 4725, 515, 1, 0, 0, 0, 4726, 4727, 5, 220, 0, 0, 4727, 4728, 5, 77, 0, 0, 4728, 4729, 5, 396, 0, 0, 4729, 517, 1, 0, 0, 0, 4730, 4731, 5, 46, 0, 0, 4731, 4732, 5, 278, 0, 0, 4732, 4733, 5, 156, 0, 0, 4733, 4735, 3, 558, 279, 0, 4734, 4736, 3, 524, 262, 0, 4735, 4734, 1, 0, 0, 0, 4735, 4736, 1, 0, 0, 0, 4736, 4737, 1, 0, 0, 0, 4737, 4738, 5, 62, 0, 0, 4738, 4739, 5, 360, 0, 0, 4739, 4740, 3, 1168, 584, 0, 4740, 4741, 5, 100, 0, 0, 4741, 4743, 3, 1436, 718, 0, 4742, 4744, 3, 526, 263, 0, 4743, 4742, 1, 0, 0, 0, 4743, 4744, 1, 0, 0, 0, 4744, 4745, 1, 0, 0, 0, 4745, 4746, 5, 36, 0, 0, 4746, 4747, 3, 520, 260, 0, 4747, 519, 1, 0, 0, 0, 4748, 4753, 3, 522, 261, 0, 4749, 4750, 5, 6, 0, 0, 4750, 4752, 3, 522, 261, 0, 4751, 4749, 1, 0, 0, 0, 4752, 4755, 1, 0, 0, 0, 4753, 4751, 1, 0, 0, 0, 4753, 4754, 1, 0, 0, 0, 4754, 521, 1, 0, 0, 0, 4755, 4753, 1, 0, 0, 0, 4756, 4757, 5, 278, 0, 0, 4757, 4758, 3, 1456, 728, 0, 4758, 4760, 3, 732, 366, 0, 4759, 4761, 3, 528, 264, 0, 4760, 4759, 1, 0, 0, 0, 4760, 4761, 1, 0, 0, 0, 4761, 4763, 1, 0, 0, 0, 4762, 4764, 3, 530, 265, 0, 4763, 4762, 1, 0, 0, 0, 4763, 4764, 1, 0, 0, 0, 4764, 4788, 1, 0, 0, 0, 4765, 4766, 5, 278, 0, 0, 4766, 4767, 3, 1456, 728, 0, 4767, 4769, 3, 736, 368, 0, 4768, 4770, 3, 528, 264, 0, 4769, 4768, 1, 0, 0, 0, 4769, 4770, 1, 0, 0, 0, 4770, 4772, 1, 0, 0, 0, 4771, 4773, 3, 530, 265, 0, 4772, 4771, 1, 0, 0, 0, 4772, 4773, 1, 0, 0, 0, 4773, 4788, 1, 0, 0, 0, 4774, 4775, 5, 211, 0, 0, 4775, 4776, 3, 1456, 728, 0, 4776, 4777, 3, 674, 337, 0, 4777, 4788, 1, 0, 0, 0, 4778, 4779, 5, 211, 0, 0, 4779, 4780, 3, 1456, 728, 0, 4780, 4781, 5, 2, 0, 0, 4781, 4782, 3, 1342, 671, 0, 4782, 4783, 5, 3, 0, 0, 4783, 4784, 3, 674, 337, 0, 4784, 4788, 1, 0, 0, 0, 4785, 4786, 5, 345, 0, 0, 4786, 4788, 3, 1168, 584, 0, 4787, 4756, 1, 0, 0, 0, 4787, 4765, 1, 0, 0, 0, 4787, 4774, 1, 0, 0, 0, 4787, 4778, 1, 0, 0, 0, 4787, 4785, 1, 0, 0, 0, 4788, 523, 1, 0, 0, 0, 4789, 4790, 5, 53, 0, 0, 4790, 525, 1, 0, 0, 0, 4791, 4792, 5, 206, 0, 0, 4792, 4793, 3, 558, 279, 0, 4793, 527, 1, 0, 0, 0, 4794, 4795, 5, 62, 0, 0, 4795, 4801, 5, 325, 0, 0, 4796, 4797, 5, 62, 0, 0, 4797, 4798, 5, 83, 0, 0, 4798, 4799, 5, 147, 0, 0, 4799, 4801, 3, 558, 279, 0, 4800, 4794, 1, 0, 0, 0, 4800, 4796, 1, 0, 0, 0, 4801, 529, 1, 0, 0, 0, 4802, 4803, 5, 302, 0, 0, 4803, 531, 1, 0, 0, 0, 4804, 4805, 5, 46, 0, 0, 4805, 4806, 5, 278, 0, 0, 4806, 4807, 5, 206, 0, 0, 4807, 4808, 3, 558, 279, 0, 4808, 4809, 5, 100, 0, 0, 4809, 4810, 3, 1436, 718, 0, 4810, 533, 1, 0, 0, 0, 4811, 4812, 5, 138, 0, 0, 4812, 4813, 5, 278, 0, 0, 4813, 4814, 5, 206, 0, 0, 4814, 4815, 3, 558, 279, 0, 4815, 4816, 5, 100, 0, 0, 4816, 4817, 3, 1436, 718, 0, 4817, 4818, 5, 133, 0, 0, 4818, 4819, 3, 520, 260, 0, 4819, 4830, 1, 0, 0, 0, 4820, 4821, 5, 138, 0, 0, 4821, 4822, 5, 278, 0, 0, 4822, 4823, 5, 206, 0, 0, 4823, 4824, 3, 558, 279, 0, 4824, 4825, 5, 100, 0, 0, 4825, 4826, 3, 1436, 718, 0, 4826, 4827, 5, 191, 0, 0, 4827, 4828, 3, 536, 268, 0, 4828, 4830, 1, 0, 0, 0, 4829, 4811, 1, 0, 0, 0, 4829, 4820, 1, 0, 0, 0, 4830, 535, 1, 0, 0, 0, 4831, 4836, 3, 538, 269, 0, 4832, 4833, 5, 6, 0, 0, 4833, 4835, 3, 538, 269, 0, 4834, 4832, 1, 0, 0, 0, 4835, 4838, 1, 0, 0, 0, 4836, 4834, 1, 0, 0, 0, 4836, 4837, 1, 0, 0, 0, 4837, 537, 1, 0, 0, 0, 4838, 4836, 1, 0, 0, 0, 4839, 4840, 5, 278, 0, 0, 4840, 4841, 3, 1456, 728, 0, 4841, 4842, 5, 2, 0, 0, 4842, 4843, 3, 1342, 671, 0, 4843, 4844, 5, 3, 0, 0, 4844, 4852, 1, 0, 0, 0, 4845, 4846, 5, 211, 0, 0, 4846, 4847, 3, 1456, 728, 0, 4847, 4848, 5, 2, 0, 0, 4848, 4849, 3, 1342, 671, 0, 4849, 4850, 5, 3, 0, 0, 4850, 4852, 1, 0, 0, 0, 4851, 4839, 1, 0, 0, 0, 4851, 4845, 1, 0, 0, 0, 4852, 539, 1, 0, 0, 0, 4853, 4854, 5, 301, 0, 0, 4854, 4855, 5, 281, 0, 0, 4855, 4856, 5, 147, 0, 0, 4856, 4857, 3, 1472, 736, 0, 4857, 4858, 5, 94, 0, 0, 4858, 4859, 3, 1470, 735, 0, 4859, 541, 1, 0, 0, 0, 4860, 4861, 5, 191, 0, 0, 4861, 4863, 5, 92, 0, 0, 4862, 4864, 3, 748, 374, 0, 4863, 4862, 1, 0, 0, 0, 4863, 4864, 1, 0, 0, 0, 4864, 4865, 1, 0, 0, 0, 4865, 4867, 3, 1392, 696, 0, 4866, 4868, 3, 124, 62, 0, 4867, 4866, 1, 0, 0, 0, 4867, 4868, 1, 0, 0, 0, 4868, 5240, 1, 0, 0, 0, 4869, 4870, 5, 191, 0, 0, 4870, 4872, 5, 328, 0, 0, 4871, 4873, 3, 748, 374, 0, 4872, 4871, 1, 0, 0, 0, 4872, 4873, 1, 0, 0, 0, 4873, 4874, 1, 0, 0, 0, 4874, 4876, 3, 1416, 708, 0, 4875, 4877, 3, 124, 62, 0, 4876, 4875, 1, 0, 0, 0, 4876, 4877, 1, 0, 0, 0, 4877, 5240, 1, 0, 0, 0, 4878, 4879, 5, 191, 0, 0, 4879, 4881, 5, 376, 0, 0, 4880, 4882, 3, 748, 374, 0, 4881, 4880, 1, 0, 0, 0, 4881, 4882, 1, 0, 0, 0, 4882, 4883, 1, 0, 0, 0, 4883, 4885, 3, 544, 272, 0, 4884, 4886, 3, 124, 62, 0, 4885, 4884, 1, 0, 0, 0, 4885, 4886, 1, 0, 0, 0, 4886, 5240, 1, 0, 0, 0, 4887, 4888, 5, 191, 0, 0, 4888, 4889, 5, 259, 0, 0, 4889, 4891, 5, 376, 0, 0, 4890, 4892, 3, 748, 374, 0, 4891, 4890, 1, 0, 0, 0, 4891, 4892, 1, 0, 0, 0, 4892, 4893, 1, 0, 0, 0, 4893, 4895, 3, 544, 272, 0, 4894, 4896, 3, 124, 62, 0, 4895, 4894, 1, 0, 0, 0, 4895, 4896, 1, 0, 0, 0, 4896, 5240, 1, 0, 0, 0, 4897, 4898, 5, 191, 0, 0, 4898, 4900, 5, 226, 0, 0, 4899, 4901, 3, 748, 374, 0, 4900, 4899, 1, 0, 0, 0, 4900, 4901, 1, 0, 0, 0, 4901, 4902, 1, 0, 0, 0, 4902, 4904, 3, 1416, 708, 0, 4903, 4905, 3, 124, 62, 0, 4904, 4903, 1, 0, 0, 0, 4904, 4905, 1, 0, 0, 0, 4905, 5240, 1, 0, 0, 0, 4906, 4907, 5, 191, 0, 0, 4907, 4908, 5, 63, 0, 0, 4908, 4910, 5, 92, 0, 0, 4909, 4911, 3, 748, 374, 0, 4910, 4909, 1, 0, 0, 0, 4910, 4911, 1, 0, 0, 0, 4911, 4912, 1, 0, 0, 0, 4912, 4914, 3, 1392, 696, 0, 4913, 4915, 3, 124, 62, 0, 4914, 4913, 1, 0, 0, 0, 4914, 4915, 1, 0, 0, 0, 4915, 5240, 1, 0, 0, 0, 4916, 4917, 5, 191, 0, 0, 4917, 4919, 5, 108, 0, 0, 4918, 4920, 3, 748, 374, 0, 4919, 4918, 1, 0, 0, 0, 4919, 4920, 1, 0, 0, 0, 4920, 4921, 1, 0, 0, 0, 4921, 4923, 3, 1416, 708, 0, 4922, 4924, 3, 124, 62, 0, 4923, 4922, 1, 0, 0, 0, 4923, 4924, 1, 0, 0, 0, 4924, 5240, 1, 0, 0, 0, 4925, 4926, 5, 191, 0, 0, 4926, 4928, 5, 168, 0, 0, 4927, 4929, 3, 748, 374, 0, 4928, 4927, 1, 0, 0, 0, 4928, 4929, 1, 0, 0, 0, 4929, 4930, 1, 0, 0, 0, 4930, 4932, 3, 1416, 708, 0, 4931, 4933, 3, 124, 62, 0, 4932, 4931, 1, 0, 0, 0, 4932, 4933, 1, 0, 0, 0, 4933, 5240, 1, 0, 0, 0, 4934, 4935, 5, 191, 0, 0, 4935, 4937, 5, 342, 0, 0, 4936, 4938, 3, 748, 374, 0, 4937, 4936, 1, 0, 0, 0, 4937, 4938, 1, 0, 0, 0, 4938, 4939, 1, 0, 0, 0, 4939, 4941, 3, 1416, 708, 0, 4940, 4942, 3, 124, 62, 0, 4941, 4940, 1, 0, 0, 0, 4941, 4942, 1, 0, 0, 0, 4942, 5240, 1, 0, 0, 0, 4943, 4944, 5, 191, 0, 0, 4944, 4945, 5, 355, 0, 0, 4945, 4946, 5, 325, 0, 0, 4946, 4948, 5, 283, 0, 0, 4947, 4949, 3, 748, 374, 0, 4948, 4947, 1, 0, 0, 0, 4948, 4949, 1, 0, 0, 0, 4949, 4950, 1, 0, 0, 0, 4950, 4952, 3, 1416, 708, 0, 4951, 4953, 3, 124, 62, 0, 4952, 4951, 1, 0, 0, 0, 4952, 4953, 1, 0, 0, 0, 4953, 5240, 1, 0, 0, 0, 4954, 4955, 5, 191, 0, 0, 4955, 4956, 5, 355, 0, 0, 4956, 4957, 5, 325, 0, 0, 4957, 4959, 5, 185, 0, 0, 4958, 4960, 3, 748, 374, 0, 4959, 4958, 1, 0, 0, 0, 4959, 4960, 1, 0, 0, 0, 4960, 4961, 1, 0, 0, 0, 4961, 4963, 3, 1416, 708, 0, 4962, 4964, 3, 124, 62, 0, 4963, 4962, 1, 0, 0, 0, 4963, 4964, 1, 0, 0, 0, 4964, 5240, 1, 0, 0, 0, 4965, 4966, 5, 191, 0, 0, 4966, 4967, 5, 355, 0, 0, 4967, 4968, 5, 325, 0, 0, 4968, 4970, 5, 353, 0, 0, 4969, 4971, 3, 748, 374, 0, 4970, 4969, 1, 0, 0, 0, 4970, 4971, 1, 0, 0, 0, 4971, 4972, 1, 0, 0, 0, 4972, 4974, 3, 1416, 708, 0, 4973, 4975, 3, 124, 62, 0, 4974, 4973, 1, 0, 0, 0, 4974, 4975, 1, 0, 0, 0, 4975, 5240, 1, 0, 0, 0, 4976, 4977, 5, 191, 0, 0, 4977, 4978, 5, 355, 0, 0, 4978, 4979, 5, 325, 0, 0, 4979, 4981, 5, 163, 0, 0, 4980, 4982, 3, 748, 374, 0, 4981, 4980, 1, 0, 0, 0, 4981, 4982, 1, 0, 0, 0, 4982, 4983, 1, 0, 0, 0, 4983, 4985, 3, 1416, 708, 0, 4984, 4986, 3, 124, 62, 0, 4985, 4984, 1, 0, 0, 0, 4985, 4986, 1, 0, 0, 0, 4986, 5240, 1, 0, 0, 0, 4987, 4988, 5, 191, 0, 0, 4988, 4989, 5, 131, 0, 0, 4989, 4991, 5, 446, 0, 0, 4990, 4992, 3, 748, 374, 0, 4991, 4990, 1, 0, 0, 0, 4991, 4992, 1, 0, 0, 0, 4992, 4993, 1, 0, 0, 0, 4993, 4995, 3, 1416, 708, 0, 4994, 4996, 3, 124, 62, 0, 4995, 4994, 1, 0, 0, 0, 4995, 4996, 1, 0, 0, 0, 4996, 5240, 1, 0, 0, 0, 4997, 4998, 5, 191, 0, 0, 4998, 4999, 5, 198, 0, 0, 4999, 5001, 5, 357, 0, 0, 5000, 5002, 3, 748, 374, 0, 5001, 5000, 1, 0, 0, 0, 5001, 5002, 1, 0, 0, 0, 5002, 5003, 1, 0, 0, 0, 5003, 5005, 3, 1416, 708, 0, 5004, 5006, 3, 124, 62, 0, 5005, 5004, 1, 0, 0, 0, 5005, 5006, 1, 0, 0, 0, 5006, 5240, 1, 0, 0, 0, 5007, 5008, 5, 191, 0, 0, 5008, 5010, 5, 204, 0, 0, 5009, 5011, 3, 748, 374, 0, 5010, 5009, 1, 0, 0, 0, 5010, 5011, 1, 0, 0, 0, 5011, 5012, 1, 0, 0, 0, 5012, 5014, 3, 1416, 708, 0, 5013, 5015, 3, 124, 62, 0, 5014, 5013, 1, 0, 0, 0, 5014, 5015, 1, 0, 0, 0, 5015, 5240, 1, 0, 0, 0, 5016, 5017, 5, 191, 0, 0, 5017, 5018, 5, 63, 0, 0, 5018, 5019, 5, 174, 0, 0, 5019, 5021, 5, 381, 0, 0, 5020, 5022, 3, 748, 374, 0, 5021, 5020, 1, 0, 0, 0, 5021, 5022, 1, 0, 0, 0, 5022, 5023, 1, 0, 0, 0, 5023, 5025, 3, 1416, 708, 0, 5024, 5026, 3, 124, 62, 0, 5025, 5024, 1, 0, 0, 0, 5025, 5026, 1, 0, 0, 0, 5026, 5240, 1, 0, 0, 0, 5027, 5029, 5, 191, 0, 0, 5028, 5030, 3, 338, 169, 0, 5029, 5028, 1, 0, 0, 0, 5029, 5030, 1, 0, 0, 0, 5030, 5031, 1, 0, 0, 0, 5031, 5033, 5, 247, 0, 0, 5032, 5034, 3, 748, 374, 0, 5033, 5032, 1, 0, 0, 0, 5033, 5034, 1, 0, 0, 0, 5034, 5035, 1, 0, 0, 0, 5035, 5037, 3, 1416, 708, 0, 5036, 5038, 3, 124, 62, 0, 5037, 5036, 1, 0, 0, 0, 5037, 5038, 1, 0, 0, 0, 5038, 5240, 1, 0, 0, 0, 5039, 5040, 5, 191, 0, 0, 5040, 5042, 5, 452, 0, 0, 5041, 5043, 3, 748, 374, 0, 5042, 5041, 1, 0, 0, 0, 5042, 5043, 1, 0, 0, 0, 5043, 5044, 1, 0, 0, 0, 5044, 5046, 3, 1416, 708, 0, 5045, 5047, 3, 124, 62, 0, 5046, 5045, 1, 0, 0, 0, 5046, 5047, 1, 0, 0, 0, 5047, 5240, 1, 0, 0, 0, 5048, 5049, 5, 191, 0, 0, 5049, 5051, 5, 331, 0, 0, 5050, 5052, 3, 748, 374, 0, 5051, 5050, 1, 0, 0, 0, 5051, 5052, 1, 0, 0, 0, 5052, 5053, 1, 0, 0, 0, 5053, 5055, 3, 1416, 708, 0, 5054, 5056, 3, 124, 62, 0, 5055, 5054, 1, 0, 0, 0, 5055, 5056, 1, 0, 0, 0, 5056, 5240, 1, 0, 0, 0, 5057, 5058, 5, 191, 0, 0, 5058, 5060, 5, 323, 0, 0, 5059, 5061, 3, 748, 374, 0, 5060, 5059, 1, 0, 0, 0, 5060, 5061, 1, 0, 0, 0, 5061, 5062, 1, 0, 0, 0, 5062, 5064, 3, 1394, 697, 0, 5063, 5065, 3, 124, 62, 0, 5064, 5063, 1, 0, 0, 0, 5064, 5065, 1, 0, 0, 0, 5065, 5240, 1, 0, 0, 0, 5066, 5067, 5, 191, 0, 0, 5067, 5069, 5, 445, 0, 0, 5068, 5070, 3, 748, 374, 0, 5069, 5068, 1, 0, 0, 0, 5069, 5070, 1, 0, 0, 0, 5070, 5071, 1, 0, 0, 0, 5071, 5072, 3, 1436, 718, 0, 5072, 5073, 5, 80, 0, 0, 5073, 5075, 3, 558, 279, 0, 5074, 5076, 3, 124, 62, 0, 5075, 5074, 1, 0, 0, 0, 5075, 5076, 1, 0, 0, 0, 5076, 5240, 1, 0, 0, 0, 5077, 5078, 5, 191, 0, 0, 5078, 5080, 5, 321, 0, 0, 5079, 5081, 3, 748, 374, 0, 5080, 5079, 1, 0, 0, 0, 5080, 5081, 1, 0, 0, 0, 5081, 5082, 1, 0, 0, 0, 5082, 5083, 3, 1436, 718, 0, 5083, 5084, 5, 80, 0, 0, 5084, 5086, 3, 558, 279, 0, 5085, 5087, 3, 124, 62, 0, 5086, 5085, 1, 0, 0, 0, 5086, 5087, 1, 0, 0, 0, 5087, 5240, 1, 0, 0, 0, 5088, 5089, 5, 191, 0, 0, 5089, 5091, 5, 357, 0, 0, 5090, 5092, 3, 748, 374, 0, 5091, 5090, 1, 0, 0, 0, 5091, 5092, 1, 0, 0, 0, 5092, 5093, 1, 0, 0, 0, 5093, 5094, 3, 1436, 718, 0, 5094, 5095, 5, 80, 0, 0, 5095, 5097, 3, 558, 279, 0, 5096, 5098, 3, 124, 62, 0, 5097, 5096, 1, 0, 0, 0, 5097, 5098, 1, 0, 0, 0, 5098, 5240, 1, 0, 0, 0, 5099, 5100, 5, 191, 0, 0, 5100, 5102, 5, 360, 0, 0, 5101, 5103, 3, 748, 374, 0, 5102, 5101, 1, 0, 0, 0, 5102, 5103, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, 5106, 3, 562, 281, 0, 5105, 5107, 3, 124, 62, 0, 5106, 5105, 1, 0, 0, 0, 5106, 5107, 1, 0, 0, 0, 5107, 5240, 1, 0, 0, 0, 5108, 5109, 5, 191, 0, 0, 5109, 5111, 5, 189, 0, 0, 5110, 5112, 3, 748, 374, 0, 5111, 5110, 1, 0, 0, 0, 5111, 5112, 1, 0, 0, 0, 5112, 5113, 1, 0, 0, 0, 5113, 5115, 3, 562, 281, 0, 5114, 5116, 3, 124, 62, 0, 5115, 5114, 1, 0, 0, 0, 5115, 5116, 1, 0, 0, 0, 5116, 5240, 1, 0, 0, 0, 5117, 5118, 5, 191, 0, 0, 5118, 5119, 5, 226, 0, 0, 5119, 5121, 5, 109, 0, 0, 5120, 5122, 3, 748, 374, 0, 5121, 5120, 1, 0, 0, 0, 5121, 5122, 1, 0, 0, 0, 5122, 5123, 1, 0, 0, 0, 5123, 5125, 3, 552, 276, 0, 5124, 5126, 3, 124, 62, 0, 5125, 5124, 1, 0, 0, 0, 5125, 5126, 1, 0, 0, 0, 5126, 5240, 1, 0, 0, 0, 5127, 5128, 5, 191, 0, 0, 5128, 5130, 5, 41, 0, 0, 5129, 5131, 3, 748, 374, 0, 5130, 5129, 1, 0, 0, 0, 5130, 5131, 1, 0, 0, 0, 5131, 5132, 1, 0, 0, 0, 5132, 5133, 5, 2, 0, 0, 5133, 5134, 3, 1168, 584, 0, 5134, 5135, 5, 36, 0, 0, 5135, 5136, 3, 1168, 584, 0, 5136, 5138, 5, 3, 0, 0, 5137, 5139, 3, 124, 62, 0, 5138, 5137, 1, 0, 0, 0, 5138, 5139, 1, 0, 0, 0, 5139, 5240, 1, 0, 0, 0, 5140, 5141, 5, 191, 0, 0, 5141, 5142, 5, 278, 0, 0, 5142, 5144, 5, 156, 0, 0, 5143, 5145, 3, 748, 374, 0, 5144, 5143, 1, 0, 0, 0, 5144, 5145, 1, 0, 0, 0, 5145, 5146, 1, 0, 0, 0, 5146, 5147, 3, 558, 279, 0, 5147, 5148, 5, 100, 0, 0, 5148, 5150, 3, 1436, 718, 0, 5149, 5151, 3, 124, 62, 0, 5150, 5149, 1, 0, 0, 0, 5150, 5151, 1, 0, 0, 0, 5151, 5240, 1, 0, 0, 0, 5152, 5153, 5, 191, 0, 0, 5153, 5154, 5, 278, 0, 0, 5154, 5156, 5, 206, 0, 0, 5155, 5157, 3, 748, 374, 0, 5156, 5155, 1, 0, 0, 0, 5156, 5157, 1, 0, 0, 0, 5157, 5158, 1, 0, 0, 0, 5158, 5159, 3, 558, 279, 0, 5159, 5160, 5, 100, 0, 0, 5160, 5162, 3, 1436, 718, 0, 5161, 5163, 3, 124, 62, 0, 5162, 5161, 1, 0, 0, 0, 5162, 5163, 1, 0, 0, 0, 5163, 5240, 1, 0, 0, 0, 5164, 5165, 5, 191, 0, 0, 5165, 5166, 5, 281, 0, 0, 5166, 5167, 5, 147, 0, 0, 5167, 5169, 3, 1472, 736, 0, 5168, 5170, 3, 124, 62, 0, 5169, 5168, 1, 0, 0, 0, 5169, 5170, 1, 0, 0, 0, 5170, 5240, 1, 0, 0, 0, 5171, 5172, 5, 191, 0, 0, 5172, 5174, 5, 376, 0, 0, 5173, 5175, 3, 748, 374, 0, 5174, 5173, 1, 0, 0, 0, 5174, 5175, 1, 0, 0, 0, 5175, 5176, 1, 0, 0, 0, 5176, 5178, 3, 544, 272, 0, 5177, 5179, 3, 124, 62, 0, 5178, 5177, 1, 0, 0, 0, 5178, 5179, 1, 0, 0, 0, 5179, 5240, 1, 0, 0, 0, 5180, 5181, 5, 191, 0, 0, 5181, 5183, 5, 451, 0, 0, 5182, 5184, 3, 748, 374, 0, 5183, 5182, 1, 0, 0, 0, 5183, 5184, 1, 0, 0, 0, 5184, 5185, 1, 0, 0, 0, 5185, 5187, 3, 1436, 718, 0, 5186, 5188, 3, 124, 62, 0, 5187, 5186, 1, 0, 0, 0, 5187, 5188, 1, 0, 0, 0, 5188, 5240, 1, 0, 0, 0, 5189, 5190, 5, 191, 0, 0, 5190, 5192, 5, 351, 0, 0, 5191, 5193, 3, 748, 374, 0, 5192, 5191, 1, 0, 0, 0, 5192, 5193, 1, 0, 0, 0, 5193, 5194, 1, 0, 0, 0, 5194, 5240, 3, 1402, 701, 0, 5195, 5196, 5, 191, 0, 0, 5196, 5198, 5, 443, 0, 0, 5197, 5199, 3, 748, 374, 0, 5198, 5197, 1, 0, 0, 0, 5198, 5199, 1, 0, 0, 0, 5199, 5200, 1, 0, 0, 0, 5200, 5201, 5, 62, 0, 0, 5201, 5202, 3, 1168, 584, 0, 5202, 5203, 5, 247, 0, 0, 5203, 5205, 3, 1436, 718, 0, 5204, 5206, 3, 124, 62, 0, 5205, 5204, 1, 0, 0, 0, 5205, 5206, 1, 0, 0, 0, 5206, 5240, 1, 0, 0, 0, 5207, 5208, 5, 191, 0, 0, 5208, 5210, 7, 38, 0, 0, 5209, 5211, 3, 748, 374, 0, 5210, 5209, 1, 0, 0, 0, 5210, 5211, 1, 0, 0, 0, 5211, 5212, 1, 0, 0, 0, 5212, 5240, 3, 1472, 736, 0, 5213, 5214, 5, 191, 0, 0, 5214, 5215, 5, 99, 0, 0, 5215, 5217, 5, 257, 0, 0, 5216, 5218, 3, 748, 374, 0, 5217, 5216, 1, 0, 0, 0, 5217, 5218, 1, 0, 0, 0, 5218, 5219, 1, 0, 0, 0, 5219, 5220, 5, 62, 0, 0, 5220, 5221, 3, 404, 202, 0, 5221, 5222, 5, 331, 0, 0, 5222, 5223, 3, 1436, 718, 0, 5223, 5240, 1, 0, 0, 0, 5224, 5225, 5, 191, 0, 0, 5225, 5227, 5, 175, 0, 0, 5226, 5228, 3, 748, 374, 0, 5227, 5226, 1, 0, 0, 0, 5227, 5228, 1, 0, 0, 0, 5228, 5229, 1, 0, 0, 0, 5229, 5237, 3, 1420, 710, 0, 5230, 5232, 3, 14, 7, 0, 5231, 5230, 1, 0, 0, 0, 5231, 5232, 1, 0, 0, 0, 5232, 5233, 1, 0, 0, 0, 5233, 5234, 5, 2, 0, 0, 5234, 5235, 3, 860, 430, 0, 5235, 5236, 5, 3, 0, 0, 5236, 5238, 1, 0, 0, 0, 5237, 5231, 1, 0, 0, 0, 5237, 5238, 1, 0, 0, 0, 5238, 5240, 1, 0, 0, 0, 5239, 4860, 1, 0, 0, 0, 5239, 4869, 1, 0, 0, 0, 5239, 4878, 1, 0, 0, 0, 5239, 4887, 1, 0, 0, 0, 5239, 4897, 1, 0, 0, 0, 5239, 4906, 1, 0, 0, 0, 5239, 4916, 1, 0, 0, 0, 5239, 4925, 1, 0, 0, 0, 5239, 4934, 1, 0, 0, 0, 5239, 4943, 1, 0, 0, 0, 5239, 4954, 1, 0, 0, 0, 5239, 4965, 1, 0, 0, 0, 5239, 4976, 1, 0, 0, 0, 5239, 4987, 1, 0, 0, 0, 5239, 4997, 1, 0, 0, 0, 5239, 5007, 1, 0, 0, 0, 5239, 5016, 1, 0, 0, 0, 5239, 5027, 1, 0, 0, 0, 5239, 5039, 1, 0, 0, 0, 5239, 5048, 1, 0, 0, 0, 5239, 5057, 1, 0, 0, 0, 5239, 5066, 1, 0, 0, 0, 5239, 5077, 1, 0, 0, 0, 5239, 5088, 1, 0, 0, 0, 5239, 5099, 1, 0, 0, 0, 5239, 5108, 1, 0, 0, 0, 5239, 5117, 1, 0, 0, 0, 5239, 5127, 1, 0, 0, 0, 5239, 5140, 1, 0, 0, 0, 5239, 5152, 1, 0, 0, 0, 5239, 5164, 1, 0, 0, 0, 5239, 5171, 1, 0, 0, 0, 5239, 5180, 1, 0, 0, 0, 5239, 5189, 1, 0, 0, 0, 5239, 5195, 1, 0, 0, 0, 5239, 5207, 1, 0, 0, 0, 5239, 5213, 1, 0, 0, 0, 5239, 5224, 1, 0, 0, 0, 5240, 543, 1, 0, 0, 0, 5241, 5246, 3, 1410, 705, 0, 5242, 5243, 5, 6, 0, 0, 5243, 5245, 3, 1410, 705, 0, 5244, 5242, 1, 0, 0, 0, 5245, 5248, 1, 0, 0, 0, 5246, 5244, 1, 0, 0, 0, 5246, 5247, 1, 0, 0, 0, 5247, 545, 1, 0, 0, 0, 5248, 5246, 1, 0, 0, 0, 5249, 5251, 5, 63, 0, 0, 5250, 5249, 1, 0, 0, 0, 5250, 5251, 1, 0, 0, 0, 5251, 5252, 1, 0, 0, 0, 5252, 5253, 5, 92, 0, 0, 5253, 5274, 3, 1406, 703, 0, 5254, 5256, 5, 259, 0, 0, 5255, 5254, 1, 0, 0, 0, 5255, 5256, 1, 0, 0, 0, 5256, 5257, 1, 0, 0, 0, 5257, 5258, 5, 376, 0, 0, 5258, 5274, 3, 1410, 705, 0, 5259, 5260, 5, 226, 0, 0, 5260, 5274, 3, 558, 279, 0, 5261, 5262, 5, 108, 0, 0, 5262, 5274, 3, 558, 279, 0, 5263, 5264, 5, 168, 0, 0, 5264, 5274, 3, 558, 279, 0, 5265, 5266, 5, 342, 0, 0, 5266, 5274, 3, 558, 279, 0, 5267, 5268, 5, 328, 0, 0, 5268, 5274, 3, 558, 279, 0, 5269, 5270, 5, 355, 0, 0, 5270, 5271, 5, 325, 0, 0, 5271, 5272, 7, 39, 0, 0, 5272, 5274, 3, 558, 279, 0, 5273, 5250, 1, 0, 0, 0, 5273, 5255, 1, 0, 0, 0, 5273, 5259, 1, 0, 0, 0, 5273, 5261, 1, 0, 0, 0, 5273, 5263, 1, 0, 0, 0, 5273, 5265, 1, 0, 0, 0, 5273, 5267, 1, 0, 0, 0, 5273, 5269, 1, 0, 0, 0, 5274, 547, 1, 0, 0, 0, 5275, 5276, 5, 131, 0, 0, 5276, 5277, 5, 446, 0, 0, 5277, 5307, 3, 1436, 718, 0, 5278, 5279, 5, 198, 0, 0, 5279, 5280, 5, 357, 0, 0, 5280, 5307, 3, 1436, 718, 0, 5281, 5282, 5, 204, 0, 0, 5282, 5307, 3, 1436, 718, 0, 5283, 5284, 5, 63, 0, 0, 5284, 5285, 5, 174, 0, 0, 5285, 5286, 5, 381, 0, 0, 5286, 5307, 3, 1436, 718, 0, 5287, 5289, 3, 338, 169, 0, 5288, 5287, 1, 0, 0, 0, 5288, 5289, 1, 0, 0, 0, 5289, 5290, 1, 0, 0, 0, 5290, 5291, 5, 247, 0, 0, 5291, 5307, 3, 1436, 718, 0, 5292, 5293, 5, 452, 0, 0, 5293, 5307, 3, 1436, 718, 0, 5294, 5295, 5, 323, 0, 0, 5295, 5307, 3, 1422, 711, 0, 5296, 5297, 5, 331, 0, 0, 5297, 5307, 3, 1436, 718, 0, 5298, 5299, 5, 175, 0, 0, 5299, 5307, 3, 1420, 710, 0, 5300, 5301, 5, 318, 0, 0, 5301, 5307, 3, 1436, 718, 0, 5302, 5303, 5, 451, 0, 0, 5303, 5307, 3, 1436, 718, 0, 5304, 5305, 5, 351, 0, 0, 5305, 5307, 3, 1402, 701, 0, 5306, 5275, 1, 0, 0, 0, 5306, 5278, 1, 0, 0, 0, 5306, 5281, 1, 0, 0, 0, 5306, 5283, 1, 0, 0, 0, 5306, 5288, 1, 0, 0, 0, 5306, 5292, 1, 0, 0, 0, 5306, 5294, 1, 0, 0, 0, 5306, 5296, 1, 0, 0, 0, 5306, 5298, 1, 0, 0, 0, 5306, 5300, 1, 0, 0, 0, 5306, 5302, 1, 0, 0, 0, 5306, 5304, 1, 0, 0, 0, 5307, 549, 1, 0, 0, 0, 5308, 5309, 7, 40, 0, 0, 5309, 551, 1, 0, 0, 0, 5310, 5315, 3, 558, 279, 0, 5311, 5312, 5, 6, 0, 0, 5312, 5314, 3, 558, 279, 0, 5313, 5311, 1, 0, 0, 0, 5314, 5317, 1, 0, 0, 0, 5315, 5313, 1, 0, 0, 0, 5315, 5316, 1, 0, 0, 0, 5316, 553, 1, 0, 0, 0, 5317, 5315, 1, 0, 0, 0, 5318, 5319, 3, 556, 278, 0, 5319, 5320, 5, 11, 0, 0, 5320, 5321, 3, 1432, 716, 0, 5321, 555, 1, 0, 0, 0, 5322, 5324, 3, 1474, 737, 0, 5323, 5325, 3, 560, 280, 0, 5324, 5323, 1, 0, 0, 0, 5324, 5325, 1, 0, 0, 0, 5325, 557, 1, 0, 0, 0, 5326, 5328, 3, 1474, 737, 0, 5327, 5329, 3, 560, 280, 0, 5328, 5327, 1, 0, 0, 0, 5328, 5329, 1, 0, 0, 0, 5329, 559, 1, 0, 0, 0, 5330, 5331, 5, 11, 0, 0, 5331, 5333, 3, 1438, 719, 0, 5332, 5330, 1, 0, 0, 0, 5333, 5334, 1, 0, 0, 0, 5334, 5332, 1, 0, 0, 0, 5334, 5335, 1, 0, 0, 0, 5335, 561, 1, 0, 0, 0, 5336, 5341, 3, 1168, 584, 0, 5337, 5338, 5, 6, 0, 0, 5338, 5340, 3, 1168, 584, 0, 5339, 5337, 1, 0, 0, 0, 5340, 5343, 1, 0, 0, 0, 5341, 5339, 1, 0, 0, 0, 5341, 5342, 1, 0, 0, 0, 5342, 563, 1, 0, 0, 0, 5343, 5341, 1, 0, 0, 0, 5344, 5346, 5, 358, 0, 0, 5345, 5347, 5, 92, 0, 0, 5346, 5345, 1, 0, 0, 0, 5346, 5347, 1, 0, 0, 0, 5347, 5348, 1, 0, 0, 0, 5348, 5353, 3, 566, 283, 0, 5349, 5350, 5, 6, 0, 0, 5350, 5352, 3, 566, 283, 0, 5351, 5349, 1, 0, 0, 0, 5352, 5355, 1, 0, 0, 0, 5353, 5351, 1, 0, 0, 0, 5353, 5354, 1, 0, 0, 0, 5354, 5358, 1, 0, 0, 0, 5355, 5353, 1, 0, 0, 0, 5356, 5357, 7, 41, 0, 0, 5357, 5359, 5, 219, 0, 0, 5358, 5356, 1, 0, 0, 0, 5358, 5359, 1, 0, 0, 0, 5359, 5361, 1, 0, 0, 0, 5360, 5362, 3, 124, 62, 0, 5361, 5360, 1, 0, 0, 0, 5361, 5362, 1, 0, 0, 0, 5362, 565, 1, 0, 0, 0, 5363, 5365, 5, 81, 0, 0, 5364, 5363, 1, 0, 0, 0, 5364, 5365, 1, 0, 0, 0, 5365, 5366, 1, 0, 0, 0, 5366, 5368, 3, 1406, 703, 0, 5367, 5369, 5, 9, 0, 0, 5368, 5367, 1, 0, 0, 0, 5368, 5369, 1, 0, 0, 0, 5369, 567, 1, 0, 0, 0, 5370, 5371, 5, 159, 0, 0, 5371, 5372, 5, 80, 0, 0, 5372, 5373, 3, 546, 273, 0, 5373, 5374, 5, 116, 0, 0, 5374, 5375, 3, 570, 285, 0, 5375, 5536, 1, 0, 0, 0, 5376, 5377, 5, 159, 0, 0, 5377, 5378, 5, 80, 0, 0, 5378, 5379, 5, 44, 0, 0, 5379, 5380, 3, 554, 277, 0, 5380, 5381, 5, 116, 0, 0, 5381, 5382, 3, 570, 285, 0, 5382, 5536, 1, 0, 0, 0, 5383, 5384, 5, 159, 0, 0, 5384, 5385, 5, 80, 0, 0, 5385, 5386, 3, 548, 274, 0, 5386, 5387, 5, 116, 0, 0, 5387, 5388, 3, 570, 285, 0, 5388, 5536, 1, 0, 0, 0, 5389, 5390, 5, 159, 0, 0, 5390, 5391, 5, 80, 0, 0, 5391, 5392, 5, 360, 0, 0, 5392, 5393, 3, 1168, 584, 0, 5393, 5394, 5, 116, 0, 0, 5394, 5395, 3, 570, 285, 0, 5395, 5536, 1, 0, 0, 0, 5396, 5397, 5, 159, 0, 0, 5397, 5398, 5, 80, 0, 0, 5398, 5399, 5, 189, 0, 0, 5399, 5400, 3, 1168, 584, 0, 5400, 5401, 5, 116, 0, 0, 5401, 5402, 3, 570, 285, 0, 5402, 5536, 1, 0, 0, 0, 5403, 5404, 5, 159, 0, 0, 5404, 5405, 5, 80, 0, 0, 5405, 5406, 5, 136, 0, 0, 5406, 5407, 3, 698, 349, 0, 5407, 5408, 5, 116, 0, 0, 5408, 5409, 3, 570, 285, 0, 5409, 5536, 1, 0, 0, 0, 5410, 5411, 5, 159, 0, 0, 5411, 5412, 5, 80, 0, 0, 5412, 5413, 5, 211, 0, 0, 5413, 5414, 3, 674, 337, 0, 5414, 5415, 5, 116, 0, 0, 5415, 5416, 3, 570, 285, 0, 5416, 5536, 1, 0, 0, 0, 5417, 5418, 5, 159, 0, 0, 5418, 5419, 5, 80, 0, 0, 5419, 5420, 5, 278, 0, 0, 5420, 5421, 3, 736, 368, 0, 5421, 5422, 5, 116, 0, 0, 5422, 5423, 3, 570, 285, 0, 5423, 5536, 1, 0, 0, 0, 5424, 5425, 5, 159, 0, 0, 5425, 5426, 5, 80, 0, 0, 5426, 5427, 5, 45, 0, 0, 5427, 5428, 3, 1436, 718, 0, 5428, 5429, 5, 80, 0, 0, 5429, 5430, 3, 1406, 703, 0, 5430, 5431, 5, 116, 0, 0, 5431, 5432, 3, 570, 285, 0, 5432, 5536, 1, 0, 0, 0, 5433, 5434, 5, 159, 0, 0, 5434, 5435, 5, 80, 0, 0, 5435, 5436, 5, 45, 0, 0, 5436, 5437, 3, 1436, 718, 0, 5437, 5439, 5, 80, 0, 0, 5438, 5440, 5, 189, 0, 0, 5439, 5438, 1, 0, 0, 0, 5439, 5440, 1, 0, 0, 0, 5440, 5441, 1, 0, 0, 0, 5441, 5442, 3, 558, 279, 0, 5442, 5443, 5, 116, 0, 0, 5443, 5444, 3, 570, 285, 0, 5444, 5536, 1, 0, 0, 0, 5445, 5446, 5, 159, 0, 0, 5446, 5447, 5, 80, 0, 0, 5447, 5448, 5, 445, 0, 0, 5448, 5449, 3, 1436, 718, 0, 5449, 5450, 5, 80, 0, 0, 5450, 5451, 3, 558, 279, 0, 5451, 5452, 5, 116, 0, 0, 5452, 5453, 3, 570, 285, 0, 5453, 5536, 1, 0, 0, 0, 5454, 5455, 5, 159, 0, 0, 5455, 5456, 5, 80, 0, 0, 5456, 5457, 5, 321, 0, 0, 5457, 5458, 3, 1436, 718, 0, 5458, 5459, 5, 80, 0, 0, 5459, 5460, 3, 558, 279, 0, 5460, 5461, 5, 116, 0, 0, 5461, 5462, 3, 570, 285, 0, 5462, 5536, 1, 0, 0, 0, 5463, 5464, 5, 159, 0, 0, 5464, 5465, 5, 80, 0, 0, 5465, 5466, 5, 357, 0, 0, 5466, 5467, 3, 1436, 718, 0, 5467, 5468, 5, 80, 0, 0, 5468, 5469, 3, 558, 279, 0, 5469, 5470, 5, 116, 0, 0, 5470, 5471, 3, 570, 285, 0, 5471, 5536, 1, 0, 0, 0, 5472, 5473, 5, 159, 0, 0, 5473, 5474, 5, 80, 0, 0, 5474, 5475, 5, 296, 0, 0, 5475, 5476, 3, 670, 335, 0, 5476, 5477, 5, 116, 0, 0, 5477, 5478, 3, 570, 285, 0, 5478, 5536, 1, 0, 0, 0, 5479, 5480, 5, 159, 0, 0, 5480, 5481, 5, 80, 0, 0, 5481, 5482, 5, 442, 0, 0, 5482, 5483, 3, 666, 333, 0, 5483, 5484, 5, 116, 0, 0, 5484, 5485, 3, 570, 285, 0, 5485, 5536, 1, 0, 0, 0, 5486, 5487, 5, 159, 0, 0, 5487, 5488, 5, 80, 0, 0, 5488, 5489, 5, 443, 0, 0, 5489, 5490, 5, 62, 0, 0, 5490, 5491, 3, 1168, 584, 0, 5491, 5492, 5, 247, 0, 0, 5492, 5493, 3, 1436, 718, 0, 5493, 5494, 5, 116, 0, 0, 5494, 5495, 3, 570, 285, 0, 5495, 5536, 1, 0, 0, 0, 5496, 5497, 5, 159, 0, 0, 5497, 5498, 5, 80, 0, 0, 5498, 5499, 5, 278, 0, 0, 5499, 5500, 5, 156, 0, 0, 5500, 5501, 3, 558, 279, 0, 5501, 5502, 5, 100, 0, 0, 5502, 5503, 3, 1436, 718, 0, 5503, 5504, 5, 116, 0, 0, 5504, 5505, 3, 570, 285, 0, 5505, 5536, 1, 0, 0, 0, 5506, 5507, 5, 159, 0, 0, 5507, 5508, 5, 80, 0, 0, 5508, 5509, 5, 278, 0, 0, 5509, 5510, 5, 206, 0, 0, 5510, 5511, 3, 558, 279, 0, 5511, 5512, 5, 100, 0, 0, 5512, 5513, 3, 1436, 718, 0, 5513, 5514, 5, 116, 0, 0, 5514, 5515, 3, 570, 285, 0, 5515, 5536, 1, 0, 0, 0, 5516, 5517, 5, 159, 0, 0, 5517, 5518, 5, 80, 0, 0, 5518, 5519, 5, 248, 0, 0, 5519, 5520, 5, 274, 0, 0, 5520, 5521, 3, 322, 161, 0, 5521, 5522, 5, 116, 0, 0, 5522, 5523, 3, 570, 285, 0, 5523, 5536, 1, 0, 0, 0, 5524, 5525, 5, 159, 0, 0, 5525, 5526, 5, 80, 0, 0, 5526, 5527, 5, 41, 0, 0, 5527, 5528, 5, 2, 0, 0, 5528, 5529, 3, 1168, 584, 0, 5529, 5530, 5, 36, 0, 0, 5530, 5531, 3, 1168, 584, 0, 5531, 5532, 5, 3, 0, 0, 5532, 5533, 5, 116, 0, 0, 5533, 5534, 3, 570, 285, 0, 5534, 5536, 1, 0, 0, 0, 5535, 5370, 1, 0, 0, 0, 5535, 5376, 1, 0, 0, 0, 5535, 5383, 1, 0, 0, 0, 5535, 5389, 1, 0, 0, 0, 5535, 5396, 1, 0, 0, 0, 5535, 5403, 1, 0, 0, 0, 5535, 5410, 1, 0, 0, 0, 5535, 5417, 1, 0, 0, 0, 5535, 5424, 1, 0, 0, 0, 5535, 5433, 1, 0, 0, 0, 5535, 5445, 1, 0, 0, 0, 5535, 5454, 1, 0, 0, 0, 5535, 5463, 1, 0, 0, 0, 5535, 5472, 1, 0, 0, 0, 5535, 5479, 1, 0, 0, 0, 5535, 5486, 1, 0, 0, 0, 5535, 5496, 1, 0, 0, 0, 5535, 5506, 1, 0, 0, 0, 5535, 5516, 1, 0, 0, 0, 5535, 5524, 1, 0, 0, 0, 5536, 569, 1, 0, 0, 0, 5537, 5540, 3, 1458, 729, 0, 5538, 5540, 5, 78, 0, 0, 5539, 5537, 1, 0, 0, 0, 5539, 5538, 1, 0, 0, 0, 5540, 571, 1, 0, 0, 0, 5541, 5542, 5, 327, 0, 0, 5542, 5544, 5, 246, 0, 0, 5543, 5545, 3, 574, 287, 0, 5544, 5543, 1, 0, 0, 0, 5544, 5545, 1, 0, 0, 0, 5545, 5546, 1, 0, 0, 0, 5546, 5547, 5, 80, 0, 0, 5547, 5548, 5, 44, 0, 0, 5548, 5549, 3, 1432, 716, 0, 5549, 5550, 5, 116, 0, 0, 5550, 5551, 3, 576, 288, 0, 5551, 5651, 1, 0, 0, 0, 5552, 5553, 5, 327, 0, 0, 5553, 5555, 5, 246, 0, 0, 5554, 5556, 3, 574, 287, 0, 5555, 5554, 1, 0, 0, 0, 5555, 5556, 1, 0, 0, 0, 5556, 5557, 1, 0, 0, 0, 5557, 5558, 5, 80, 0, 0, 5558, 5559, 5, 360, 0, 0, 5559, 5560, 3, 1168, 584, 0, 5560, 5561, 5, 116, 0, 0, 5561, 5562, 3, 576, 288, 0, 5562, 5651, 1, 0, 0, 0, 5563, 5564, 5, 327, 0, 0, 5564, 5566, 5, 246, 0, 0, 5565, 5567, 3, 574, 287, 0, 5566, 5565, 1, 0, 0, 0, 5566, 5567, 1, 0, 0, 0, 5567, 5568, 1, 0, 0, 0, 5568, 5569, 5, 80, 0, 0, 5569, 5570, 5, 189, 0, 0, 5570, 5571, 3, 1168, 584, 0, 5571, 5572, 5, 116, 0, 0, 5572, 5573, 3, 576, 288, 0, 5573, 5651, 1, 0, 0, 0, 5574, 5575, 5, 327, 0, 0, 5575, 5577, 5, 246, 0, 0, 5576, 5578, 3, 574, 287, 0, 5577, 5576, 1, 0, 0, 0, 5577, 5578, 1, 0, 0, 0, 5578, 5579, 1, 0, 0, 0, 5579, 5580, 5, 80, 0, 0, 5580, 5581, 5, 136, 0, 0, 5581, 5582, 3, 698, 349, 0, 5582, 5583, 5, 116, 0, 0, 5583, 5584, 3, 576, 288, 0, 5584, 5651, 1, 0, 0, 0, 5585, 5586, 5, 327, 0, 0, 5586, 5588, 5, 246, 0, 0, 5587, 5589, 3, 574, 287, 0, 5588, 5587, 1, 0, 0, 0, 5588, 5589, 1, 0, 0, 0, 5589, 5590, 1, 0, 0, 0, 5590, 5591, 5, 80, 0, 0, 5591, 5592, 5, 211, 0, 0, 5592, 5593, 3, 674, 337, 0, 5593, 5594, 5, 116, 0, 0, 5594, 5595, 3, 576, 288, 0, 5595, 5651, 1, 0, 0, 0, 5596, 5597, 5, 327, 0, 0, 5597, 5599, 5, 246, 0, 0, 5598, 5600, 3, 574, 287, 0, 5599, 5598, 1, 0, 0, 0, 5599, 5600, 1, 0, 0, 0, 5600, 5601, 1, 0, 0, 0, 5601, 5602, 5, 80, 0, 0, 5602, 5603, 5, 248, 0, 0, 5603, 5604, 5, 274, 0, 0, 5604, 5605, 3, 322, 161, 0, 5605, 5606, 5, 116, 0, 0, 5606, 5607, 3, 576, 288, 0, 5607, 5651, 1, 0, 0, 0, 5608, 5609, 5, 327, 0, 0, 5609, 5611, 5, 246, 0, 0, 5610, 5612, 3, 574, 287, 0, 5611, 5610, 1, 0, 0, 0, 5611, 5612, 1, 0, 0, 0, 5612, 5613, 1, 0, 0, 0, 5613, 5614, 5, 80, 0, 0, 5614, 5615, 5, 296, 0, 0, 5615, 5616, 3, 670, 335, 0, 5616, 5617, 5, 116, 0, 0, 5617, 5618, 3, 576, 288, 0, 5618, 5651, 1, 0, 0, 0, 5619, 5620, 5, 327, 0, 0, 5620, 5622, 5, 246, 0, 0, 5621, 5623, 3, 574, 287, 0, 5622, 5621, 1, 0, 0, 0, 5622, 5623, 1, 0, 0, 0, 5623, 5624, 1, 0, 0, 0, 5624, 5625, 5, 80, 0, 0, 5625, 5626, 5, 442, 0, 0, 5626, 5627, 3, 666, 333, 0, 5627, 5628, 5, 116, 0, 0, 5628, 5629, 3, 576, 288, 0, 5629, 5651, 1, 0, 0, 0, 5630, 5631, 5, 327, 0, 0, 5631, 5633, 5, 246, 0, 0, 5632, 5634, 3, 574, 287, 0, 5633, 5632, 1, 0, 0, 0, 5633, 5634, 1, 0, 0, 0, 5634, 5635, 1, 0, 0, 0, 5635, 5636, 5, 80, 0, 0, 5636, 5637, 3, 546, 273, 0, 5637, 5638, 5, 116, 0, 0, 5638, 5639, 3, 576, 288, 0, 5639, 5651, 1, 0, 0, 0, 5640, 5641, 5, 327, 0, 0, 5641, 5643, 5, 246, 0, 0, 5642, 5644, 3, 574, 287, 0, 5643, 5642, 1, 0, 0, 0, 5643, 5644, 1, 0, 0, 0, 5644, 5645, 1, 0, 0, 0, 5645, 5646, 5, 80, 0, 0, 5646, 5647, 3, 548, 274, 0, 5647, 5648, 5, 116, 0, 0, 5648, 5649, 3, 576, 288, 0, 5649, 5651, 1, 0, 0, 0, 5650, 5541, 1, 0, 0, 0, 5650, 5552, 1, 0, 0, 0, 5650, 5563, 1, 0, 0, 0, 5650, 5574, 1, 0, 0, 0, 5650, 5585, 1, 0, 0, 0, 5650, 5596, 1, 0, 0, 0, 5650, 5608, 1, 0, 0, 0, 5650, 5619, 1, 0, 0, 0, 5650, 5630, 1, 0, 0, 0, 5650, 5640, 1, 0, 0, 0, 5651, 573, 1, 0, 0, 0, 5652, 5653, 5, 62, 0, 0, 5653, 5654, 3, 80, 40, 0, 5654, 575, 1, 0, 0, 0, 5655, 5658, 3, 1458, 729, 0, 5656, 5658, 5, 78, 0, 0, 5657, 5655, 1, 0, 0, 0, 5657, 5656, 1, 0, 0, 0, 5658, 577, 1, 0, 0, 0, 5659, 5660, 5, 61, 0, 0, 5660, 5664, 3, 580, 290, 0, 5661, 5662, 5, 265, 0, 0, 5662, 5664, 3, 580, 290, 0, 5663, 5659, 1, 0, 0, 0, 5663, 5661, 1, 0, 0, 0, 5664, 579, 1, 0, 0, 0, 5665, 5751, 3, 994, 497, 0, 5666, 5667, 3, 582, 291, 0, 5667, 5668, 3, 994, 497, 0, 5668, 5751, 1, 0, 0, 0, 5669, 5671, 5, 268, 0, 0, 5670, 5672, 3, 584, 292, 0, 5671, 5670, 1, 0, 0, 0, 5671, 5672, 1, 0, 0, 0, 5672, 5673, 1, 0, 0, 0, 5673, 5751, 3, 994, 497, 0, 5674, 5676, 5, 293, 0, 0, 5675, 5677, 3, 584, 292, 0, 5676, 5675, 1, 0, 0, 0, 5676, 5677, 1, 0, 0, 0, 5677, 5678, 1, 0, 0, 0, 5678, 5751, 3, 994, 497, 0, 5679, 5681, 5, 207, 0, 0, 5680, 5682, 3, 584, 292, 0, 5681, 5680, 1, 0, 0, 0, 5681, 5682, 1, 0, 0, 0, 5682, 5683, 1, 0, 0, 0, 5683, 5751, 3, 994, 497, 0, 5684, 5686, 5, 249, 0, 0, 5685, 5687, 3, 584, 292, 0, 5686, 5685, 1, 0, 0, 0, 5686, 5687, 1, 0, 0, 0, 5687, 5688, 1, 0, 0, 0, 5688, 5751, 3, 994, 497, 0, 5689, 5690, 5, 130, 0, 0, 5690, 5692, 3, 1464, 732, 0, 5691, 5693, 3, 584, 292, 0, 5692, 5691, 1, 0, 0, 0, 5692, 5693, 1, 0, 0, 0, 5693, 5694, 1, 0, 0, 0, 5694, 5695, 3, 994, 497, 0, 5695, 5751, 1, 0, 0, 0, 5696, 5697, 5, 307, 0, 0, 5697, 5699, 3, 1464, 732, 0, 5698, 5700, 3, 584, 292, 0, 5699, 5698, 1, 0, 0, 0, 5699, 5700, 1, 0, 0, 0, 5700, 5701, 1, 0, 0, 0, 5701, 5702, 3, 994, 497, 0, 5702, 5751, 1, 0, 0, 0, 5703, 5705, 3, 1464, 732, 0, 5704, 5706, 3, 584, 292, 0, 5705, 5704, 1, 0, 0, 0, 5705, 5706, 1, 0, 0, 0, 5706, 5707, 1, 0, 0, 0, 5707, 5708, 3, 994, 497, 0, 5708, 5751, 1, 0, 0, 0, 5709, 5711, 5, 30, 0, 0, 5710, 5712, 3, 584, 292, 0, 5711, 5710, 1, 0, 0, 0, 5711, 5712, 1, 0, 0, 0, 5712, 5713, 1, 0, 0, 0, 5713, 5751, 3, 994, 497, 0, 5714, 5716, 5, 210, 0, 0, 5715, 5717, 3, 584, 292, 0, 5716, 5715, 1, 0, 0, 0, 5716, 5717, 1, 0, 0, 0, 5717, 5718, 1, 0, 0, 0, 5718, 5751, 3, 994, 497, 0, 5719, 5720, 5, 210, 0, 0, 5720, 5722, 3, 1464, 732, 0, 5721, 5723, 3, 584, 292, 0, 5722, 5721, 1, 0, 0, 0, 5722, 5723, 1, 0, 0, 0, 5723, 5724, 1, 0, 0, 0, 5724, 5725, 3, 994, 497, 0, 5725, 5751, 1, 0, 0, 0, 5726, 5727, 5, 210, 0, 0, 5727, 5729, 5, 30, 0, 0, 5728, 5730, 3, 584, 292, 0, 5729, 5728, 1, 0, 0, 0, 5729, 5730, 1, 0, 0, 0, 5730, 5731, 1, 0, 0, 0, 5731, 5751, 3, 994, 497, 0, 5732, 5734, 5, 144, 0, 0, 5733, 5735, 3, 584, 292, 0, 5734, 5733, 1, 0, 0, 0, 5734, 5735, 1, 0, 0, 0, 5735, 5736, 1, 0, 0, 0, 5736, 5751, 3, 994, 497, 0, 5737, 5738, 5, 144, 0, 0, 5738, 5740, 3, 1464, 732, 0, 5739, 5741, 3, 584, 292, 0, 5740, 5739, 1, 0, 0, 0, 5740, 5741, 1, 0, 0, 0, 5741, 5742, 1, 0, 0, 0, 5742, 5743, 3, 994, 497, 0, 5743, 5751, 1, 0, 0, 0, 5744, 5745, 5, 144, 0, 0, 5745, 5747, 5, 30, 0, 0, 5746, 5748, 3, 584, 292, 0, 5747, 5746, 1, 0, 0, 0, 5747, 5748, 1, 0, 0, 0, 5748, 5749, 1, 0, 0, 0, 5749, 5751, 3, 994, 497, 0, 5750, 5665, 1, 0, 0, 0, 5750, 5666, 1, 0, 0, 0, 5750, 5669, 1, 0, 0, 0, 5750, 5674, 1, 0, 0, 0, 5750, 5679, 1, 0, 0, 0, 5750, 5684, 1, 0, 0, 0, 5750, 5689, 1, 0, 0, 0, 5750, 5696, 1, 0, 0, 0, 5750, 5703, 1, 0, 0, 0, 5750, 5709, 1, 0, 0, 0, 5750, 5714, 1, 0, 0, 0, 5750, 5719, 1, 0, 0, 0, 5750, 5726, 1, 0, 0, 0, 5750, 5732, 1, 0, 0, 0, 5750, 5737, 1, 0, 0, 0, 5750, 5744, 1, 0, 0, 0, 5751, 581, 1, 0, 0, 0, 5752, 5753, 7, 42, 0, 0, 5753, 583, 1, 0, 0, 0, 5754, 5755, 3, 582, 291, 0, 5755, 585, 1, 0, 0, 0, 5756, 5757, 5, 65, 0, 0, 5757, 5758, 3, 590, 295, 0, 5758, 5759, 5, 80, 0, 0, 5759, 5760, 3, 600, 300, 0, 5760, 5761, 5, 94, 0, 0, 5761, 5763, 3, 602, 301, 0, 5762, 5764, 3, 606, 303, 0, 5763, 5762, 1, 0, 0, 0, 5763, 5764, 1, 0, 0, 0, 5764, 587, 1, 0, 0, 0, 5765, 5766, 5, 317, 0, 0, 5766, 5767, 3, 590, 295, 0, 5767, 5768, 5, 80, 0, 0, 5768, 5769, 3, 600, 300, 0, 5769, 5770, 5, 64, 0, 0, 5770, 5772, 3, 602, 301, 0, 5771, 5773, 3, 124, 62, 0, 5772, 5771, 1, 0, 0, 0, 5772, 5773, 1, 0, 0, 0, 5773, 5787, 1, 0, 0, 0, 5774, 5775, 5, 317, 0, 0, 5775, 5776, 5, 65, 0, 0, 5776, 5777, 5, 279, 0, 0, 5777, 5778, 5, 62, 0, 0, 5778, 5779, 3, 590, 295, 0, 5779, 5780, 5, 80, 0, 0, 5780, 5781, 3, 600, 300, 0, 5781, 5782, 5, 64, 0, 0, 5782, 5784, 3, 602, 301, 0, 5783, 5785, 3, 124, 62, 0, 5784, 5783, 1, 0, 0, 0, 5784, 5785, 1, 0, 0, 0, 5785, 5787, 1, 0, 0, 0, 5786, 5765, 1, 0, 0, 0, 5786, 5774, 1, 0, 0, 0, 5787, 589, 1, 0, 0, 0, 5788, 5805, 3, 596, 298, 0, 5789, 5805, 5, 30, 0, 0, 5790, 5791, 5, 30, 0, 0, 5791, 5805, 5, 294, 0, 0, 5792, 5793, 5, 30, 0, 0, 5793, 5794, 5, 2, 0, 0, 5794, 5795, 3, 244, 122, 0, 5795, 5796, 5, 3, 0, 0, 5796, 5805, 1, 0, 0, 0, 5797, 5798, 5, 30, 0, 0, 5798, 5799, 5, 294, 0, 0, 5799, 5800, 5, 2, 0, 0, 5800, 5801, 3, 244, 122, 0, 5801, 5802, 5, 3, 0, 0, 5802, 5805, 1, 0, 0, 0, 5803, 5805, 3, 592, 296, 0, 5804, 5788, 1, 0, 0, 0, 5804, 5789, 1, 0, 0, 0, 5804, 5790, 1, 0, 0, 0, 5804, 5792, 1, 0, 0, 0, 5804, 5797, 1, 0, 0, 0, 5804, 5803, 1, 0, 0, 0, 5805, 591, 1, 0, 0, 0, 5806, 5811, 3, 594, 297, 0, 5807, 5808, 5, 6, 0, 0, 5808, 5810, 3, 594, 297, 0, 5809, 5807, 1, 0, 0, 0, 5810, 5813, 1, 0, 0, 0, 5811, 5809, 1, 0, 0, 0, 5811, 5812, 1, 0, 0, 0, 5812, 593, 1, 0, 0, 0, 5813, 5811, 1, 0, 0, 0, 5814, 5815, 7, 43, 0, 0, 5815, 595, 1, 0, 0, 0, 5816, 5821, 3, 598, 299, 0, 5817, 5818, 5, 6, 0, 0, 5818, 5820, 3, 598, 299, 0, 5819, 5817, 1, 0, 0, 0, 5820, 5823, 1, 0, 0, 0, 5821, 5819, 1, 0, 0, 0, 5821, 5822, 1, 0, 0, 0, 5822, 597, 1, 0, 0, 0, 5823, 5821, 1, 0, 0, 0, 5824, 5826, 5, 88, 0, 0, 5825, 5827, 3, 240, 120, 0, 5826, 5825, 1, 0, 0, 0, 5826, 5827, 1, 0, 0, 0, 5827, 5841, 1, 0, 0, 0, 5828, 5830, 5, 86, 0, 0, 5829, 5831, 3, 240, 120, 0, 5830, 5829, 1, 0, 0, 0, 5830, 5831, 1, 0, 0, 0, 5831, 5841, 1, 0, 0, 0, 5832, 5834, 5, 46, 0, 0, 5833, 5835, 3, 240, 120, 0, 5834, 5833, 1, 0, 0, 0, 5834, 5835, 1, 0, 0, 0, 5835, 5841, 1, 0, 0, 0, 5836, 5838, 3, 1474, 737, 0, 5837, 5839, 3, 240, 120, 0, 5838, 5837, 1, 0, 0, 0, 5838, 5839, 1, 0, 0, 0, 5839, 5841, 1, 0, 0, 0, 5840, 5824, 1, 0, 0, 0, 5840, 5828, 1, 0, 0, 0, 5840, 5832, 1, 0, 0, 0, 5840, 5836, 1, 0, 0, 0, 5841, 599, 1, 0, 0, 0, 5842, 5901, 3, 1390, 695, 0, 5843, 5844, 5, 92, 0, 0, 5844, 5901, 3, 1392, 696, 0, 5845, 5846, 5, 328, 0, 0, 5846, 5901, 3, 1390, 695, 0, 5847, 5848, 5, 63, 0, 0, 5848, 5849, 5, 174, 0, 0, 5849, 5850, 5, 381, 0, 0, 5850, 5901, 3, 1416, 708, 0, 5851, 5852, 5, 63, 0, 0, 5852, 5853, 5, 331, 0, 0, 5853, 5901, 3, 1416, 708, 0, 5854, 5855, 5, 211, 0, 0, 5855, 5901, 3, 672, 336, 0, 5856, 5857, 5, 296, 0, 0, 5857, 5901, 3, 668, 334, 0, 5858, 5859, 5, 442, 0, 0, 5859, 5901, 3, 664, 332, 0, 5860, 5861, 5, 175, 0, 0, 5861, 5901, 3, 1396, 698, 0, 5862, 5863, 5, 189, 0, 0, 5863, 5901, 3, 552, 276, 0, 5864, 5865, 5, 247, 0, 0, 5865, 5901, 3, 1416, 708, 0, 5866, 5867, 5, 248, 0, 0, 5867, 5868, 5, 274, 0, 0, 5868, 5901, 3, 324, 162, 0, 5869, 5870, 5, 323, 0, 0, 5870, 5901, 3, 1394, 697, 0, 5871, 5872, 5, 351, 0, 0, 5872, 5901, 3, 1414, 707, 0, 5873, 5874, 5, 360, 0, 0, 5874, 5901, 3, 552, 276, 0, 5875, 5876, 5, 30, 0, 0, 5876, 5877, 5, 350, 0, 0, 5877, 5878, 5, 68, 0, 0, 5878, 5879, 5, 323, 0, 0, 5879, 5901, 3, 1394, 697, 0, 5880, 5881, 5, 30, 0, 0, 5881, 5882, 5, 329, 0, 0, 5882, 5883, 5, 68, 0, 0, 5883, 5884, 5, 323, 0, 0, 5884, 5901, 3, 1394, 697, 0, 5885, 5886, 5, 30, 0, 0, 5886, 5887, 5, 212, 0, 0, 5887, 5888, 5, 68, 0, 0, 5888, 5889, 5, 323, 0, 0, 5889, 5901, 3, 1394, 697, 0, 5890, 5891, 5, 30, 0, 0, 5891, 5892, 5, 457, 0, 0, 5892, 5893, 5, 68, 0, 0, 5893, 5894, 5, 323, 0, 0, 5894, 5901, 3, 1394, 697, 0, 5895, 5896, 5, 30, 0, 0, 5896, 5897, 5, 455, 0, 0, 5897, 5898, 5, 68, 0, 0, 5898, 5899, 5, 323, 0, 0, 5899, 5901, 3, 1394, 697, 0, 5900, 5842, 1, 0, 0, 0, 5900, 5843, 1, 0, 0, 0, 5900, 5845, 1, 0, 0, 0, 5900, 5847, 1, 0, 0, 0, 5900, 5851, 1, 0, 0, 0, 5900, 5854, 1, 0, 0, 0, 5900, 5856, 1, 0, 0, 0, 5900, 5858, 1, 0, 0, 0, 5900, 5860, 1, 0, 0, 0, 5900, 5862, 1, 0, 0, 0, 5900, 5864, 1, 0, 0, 0, 5900, 5866, 1, 0, 0, 0, 5900, 5869, 1, 0, 0, 0, 5900, 5871, 1, 0, 0, 0, 5900, 5873, 1, 0, 0, 0, 5900, 5875, 1, 0, 0, 0, 5900, 5880, 1, 0, 0, 0, 5900, 5885, 1, 0, 0, 0, 5900, 5890, 1, 0, 0, 0, 5900, 5895, 1, 0, 0, 0, 5901, 601, 1, 0, 0, 0, 5902, 5907, 3, 604, 302, 0, 5903, 5904, 5, 6, 0, 0, 5904, 5906, 3, 604, 302, 0, 5905, 5903, 1, 0, 0, 0, 5906, 5909, 1, 0, 0, 0, 5907, 5905, 1, 0, 0, 0, 5907, 5908, 1, 0, 0, 0, 5908, 603, 1, 0, 0, 0, 5909, 5907, 1, 0, 0, 0, 5910, 5914, 3, 1470, 735, 0, 5911, 5912, 5, 66, 0, 0, 5912, 5914, 3, 1470, 735, 0, 5913, 5910, 1, 0, 0, 0, 5913, 5911, 1, 0, 0, 0, 5914, 605, 1, 0, 0, 0, 5915, 5916, 5, 105, 0, 0, 5916, 5917, 5, 65, 0, 0, 5917, 5918, 5, 279, 0, 0, 5918, 607, 1, 0, 0, 0, 5919, 5920, 5, 65, 0, 0, 5920, 5921, 3, 596, 298, 0, 5921, 5922, 5, 94, 0, 0, 5922, 5924, 3, 1472, 736, 0, 5923, 5925, 3, 612, 306, 0, 5924, 5923, 1, 0, 0, 0, 5924, 5925, 1, 0, 0, 0, 5925, 5927, 1, 0, 0, 0, 5926, 5928, 3, 614, 307, 0, 5927, 5926, 1, 0, 0, 0, 5927, 5928, 1, 0, 0, 0, 5928, 609, 1, 0, 0, 0, 5929, 5930, 5, 317, 0, 0, 5930, 5931, 3, 596, 298, 0, 5931, 5932, 5, 64, 0, 0, 5932, 5934, 3, 1472, 736, 0, 5933, 5935, 3, 614, 307, 0, 5934, 5933, 1, 0, 0, 0, 5934, 5935, 1, 0, 0, 0, 5935, 5937, 1, 0, 0, 0, 5936, 5938, 3, 124, 62, 0, 5937, 5936, 1, 0, 0, 0, 5937, 5938, 1, 0, 0, 0, 5938, 5953, 1, 0, 0, 0, 5939, 5940, 5, 317, 0, 0, 5940, 5941, 5, 134, 0, 0, 5941, 5942, 5, 279, 0, 0, 5942, 5943, 5, 62, 0, 0, 5943, 5944, 3, 596, 298, 0, 5944, 5945, 5, 64, 0, 0, 5945, 5947, 3, 1472, 736, 0, 5946, 5948, 3, 614, 307, 0, 5947, 5946, 1, 0, 0, 0, 5947, 5948, 1, 0, 0, 0, 5948, 5950, 1, 0, 0, 0, 5949, 5951, 3, 124, 62, 0, 5950, 5949, 1, 0, 0, 0, 5950, 5951, 1, 0, 0, 0, 5951, 5953, 1, 0, 0, 0, 5952, 5929, 1, 0, 0, 0, 5952, 5939, 1, 0, 0, 0, 5953, 611, 1, 0, 0, 0, 5954, 5955, 5, 105, 0, 0, 5955, 5956, 5, 134, 0, 0, 5956, 5957, 5, 279, 0, 0, 5957, 613, 1, 0, 0, 0, 5958, 5959, 5, 214, 0, 0, 5959, 5960, 5, 147, 0, 0, 5960, 5961, 3, 1470, 735, 0, 5961, 615, 1, 0, 0, 0, 5962, 5963, 5, 138, 0, 0, 5963, 5964, 5, 53, 0, 0, 5964, 5965, 5, 294, 0, 0, 5965, 5966, 3, 618, 309, 0, 5966, 5967, 3, 622, 311, 0, 5967, 617, 1, 0, 0, 0, 5968, 5970, 3, 620, 310, 0, 5969, 5968, 1, 0, 0, 0, 5970, 5973, 1, 0, 0, 0, 5971, 5969, 1, 0, 0, 0, 5971, 5972, 1, 0, 0, 0, 5972, 619, 1, 0, 0, 0, 5973, 5971, 1, 0, 0, 0, 5974, 5975, 5, 68, 0, 0, 5975, 5976, 5, 323, 0, 0, 5976, 5984, 3, 1394, 697, 0, 5977, 5978, 5, 62, 0, 0, 5978, 5979, 5, 318, 0, 0, 5979, 5984, 3, 1472, 736, 0, 5980, 5981, 5, 62, 0, 0, 5981, 5982, 5, 99, 0, 0, 5982, 5984, 3, 1472, 736, 0, 5983, 5974, 1, 0, 0, 0, 5983, 5977, 1, 0, 0, 0, 5983, 5980, 1, 0, 0, 0, 5984, 621, 1, 0, 0, 0, 5985, 5986, 5, 65, 0, 0, 5986, 5987, 3, 590, 295, 0, 5987, 5988, 5, 80, 0, 0, 5988, 5989, 3, 624, 312, 0, 5989, 5990, 5, 94, 0, 0, 5990, 5992, 3, 602, 301, 0, 5991, 5993, 3, 606, 303, 0, 5992, 5991, 1, 0, 0, 0, 5992, 5993, 1, 0, 0, 0, 5993, 6016, 1, 0, 0, 0, 5994, 5995, 5, 317, 0, 0, 5995, 5996, 3, 590, 295, 0, 5996, 5997, 5, 80, 0, 0, 5997, 5998, 3, 624, 312, 0, 5998, 5999, 5, 64, 0, 0, 5999, 6001, 3, 602, 301, 0, 6000, 6002, 3, 124, 62, 0, 6001, 6000, 1, 0, 0, 0, 6001, 6002, 1, 0, 0, 0, 6002, 6016, 1, 0, 0, 0, 6003, 6004, 5, 317, 0, 0, 6004, 6005, 5, 65, 0, 0, 6005, 6006, 5, 279, 0, 0, 6006, 6007, 5, 62, 0, 0, 6007, 6008, 3, 590, 295, 0, 6008, 6009, 5, 80, 0, 0, 6009, 6010, 3, 624, 312, 0, 6010, 6011, 5, 64, 0, 0, 6011, 6013, 3, 602, 301, 0, 6012, 6014, 3, 124, 62, 0, 6013, 6012, 1, 0, 0, 0, 6013, 6014, 1, 0, 0, 0, 6014, 6016, 1, 0, 0, 0, 6015, 5985, 1, 0, 0, 0, 6015, 5994, 1, 0, 0, 0, 6015, 6003, 1, 0, 0, 0, 6016, 623, 1, 0, 0, 0, 6017, 6018, 7, 44, 0, 0, 6018, 625, 1, 0, 0, 0, 6019, 6021, 5, 46, 0, 0, 6020, 6022, 3, 628, 314, 0, 6021, 6020, 1, 0, 0, 0, 6021, 6022, 1, 0, 0, 0, 6022, 6023, 1, 0, 0, 0, 6023, 6025, 5, 226, 0, 0, 6024, 6026, 3, 630, 315, 0, 6025, 6024, 1, 0, 0, 0, 6025, 6026, 1, 0, 0, 0, 6026, 6028, 1, 0, 0, 0, 6027, 6029, 3, 516, 258, 0, 6028, 6027, 1, 0, 0, 0, 6028, 6029, 1, 0, 0, 0, 6029, 6031, 1, 0, 0, 0, 6030, 6032, 3, 632, 316, 0, 6031, 6030, 1, 0, 0, 0, 6031, 6032, 1, 0, 0, 0, 6032, 6033, 1, 0, 0, 0, 6033, 6034, 5, 80, 0, 0, 6034, 6036, 3, 1118, 559, 0, 6035, 6037, 3, 634, 317, 0, 6036, 6035, 1, 0, 0, 0, 6036, 6037, 1, 0, 0, 0, 6037, 6038, 1, 0, 0, 0, 6038, 6039, 5, 2, 0, 0, 6039, 6040, 3, 636, 318, 0, 6040, 6042, 5, 3, 0, 0, 6041, 6043, 3, 642, 321, 0, 6042, 6041, 1, 0, 0, 0, 6042, 6043, 1, 0, 0, 0, 6043, 6045, 1, 0, 0, 0, 6044, 6046, 3, 220, 110, 0, 6045, 6044, 1, 0, 0, 0, 6045, 6046, 1, 0, 0, 0, 6046, 6048, 1, 0, 0, 0, 6047, 6049, 3, 134, 67, 0, 6048, 6047, 1, 0, 0, 0, 6048, 6049, 1, 0, 0, 0, 6049, 6051, 1, 0, 0, 0, 6050, 6052, 3, 282, 141, 0, 6051, 6050, 1, 0, 0, 0, 6051, 6052, 1, 0, 0, 0, 6052, 6054, 1, 0, 0, 0, 6053, 6055, 3, 1144, 572, 0, 6054, 6053, 1, 0, 0, 0, 6054, 6055, 1, 0, 0, 0, 6055, 627, 1, 0, 0, 0, 6056, 6057, 5, 98, 0, 0, 6057, 629, 1, 0, 0, 0, 6058, 6059, 5, 109, 0, 0, 6059, 631, 1, 0, 0, 0, 6060, 6061, 3, 1436, 718, 0, 6061, 633, 1, 0, 0, 0, 6062, 6063, 5, 100, 0, 0, 6063, 6064, 3, 1436, 718, 0, 6064, 635, 1, 0, 0, 0, 6065, 6070, 3, 640, 320, 0, 6066, 6067, 5, 6, 0, 0, 6067, 6069, 3, 640, 320, 0, 6068, 6066, 1, 0, 0, 0, 6069, 6072, 1, 0, 0, 0, 6070, 6068, 1, 0, 0, 0, 6070, 6071, 1, 0, 0, 0, 6071, 637, 1, 0, 0, 0, 6072, 6070, 1, 0, 0, 0, 6073, 6075, 3, 646, 323, 0, 6074, 6073, 1, 0, 0, 0, 6074, 6075, 1, 0, 0, 0, 6075, 6077, 1, 0, 0, 0, 6076, 6078, 3, 648, 324, 0, 6077, 6076, 1, 0, 0, 0, 6077, 6078, 1, 0, 0, 0, 6078, 6080, 1, 0, 0, 0, 6079, 6081, 3, 650, 325, 0, 6080, 6079, 1, 0, 0, 0, 6080, 6081, 1, 0, 0, 0, 6081, 6083, 1, 0, 0, 0, 6082, 6084, 3, 652, 326, 0, 6083, 6082, 1, 0, 0, 0, 6083, 6084, 1, 0, 0, 0, 6084, 6097, 1, 0, 0, 0, 6085, 6087, 3, 646, 323, 0, 6086, 6085, 1, 0, 0, 0, 6086, 6087, 1, 0, 0, 0, 6087, 6088, 1, 0, 0, 0, 6088, 6089, 3, 558, 279, 0, 6089, 6091, 3, 132, 66, 0, 6090, 6092, 3, 650, 325, 0, 6091, 6090, 1, 0, 0, 0, 6091, 6092, 1, 0, 0, 0, 6092, 6094, 1, 0, 0, 0, 6093, 6095, 3, 652, 326, 0, 6094, 6093, 1, 0, 0, 0, 6094, 6095, 1, 0, 0, 0, 6095, 6097, 1, 0, 0, 0, 6096, 6074, 1, 0, 0, 0, 6096, 6086, 1, 0, 0, 0, 6097, 639, 1, 0, 0, 0, 6098, 6099, 3, 1432, 716, 0, 6099, 6100, 3, 638, 319, 0, 6100, 6110, 1, 0, 0, 0, 6101, 6102, 3, 1262, 631, 0, 6102, 6103, 3, 638, 319, 0, 6103, 6110, 1, 0, 0, 0, 6104, 6105, 5, 2, 0, 0, 6105, 6106, 3, 1212, 606, 0, 6106, 6107, 5, 3, 0, 0, 6107, 6108, 3, 638, 319, 0, 6108, 6110, 1, 0, 0, 0, 6109, 6098, 1, 0, 0, 0, 6109, 6101, 1, 0, 0, 0, 6109, 6104, 1, 0, 0, 0, 6110, 641, 1, 0, 0, 0, 6111, 6112, 5, 441, 0, 0, 6112, 6113, 5, 2, 0, 0, 6113, 6114, 3, 644, 322, 0, 6114, 6115, 5, 3, 0, 0, 6115, 643, 1, 0, 0, 0, 6116, 6121, 3, 640, 320, 0, 6117, 6118, 5, 6, 0, 0, 6118, 6120, 3, 640, 320, 0, 6119, 6117, 1, 0, 0, 0, 6120, 6123, 1, 0, 0, 0, 6121, 6119, 1, 0, 0, 0, 6121, 6122, 1, 0, 0, 0, 6122, 645, 1, 0, 0, 0, 6123, 6121, 1, 0, 0, 0, 6124, 6125, 5, 43, 0, 0, 6125, 6126, 3, 558, 279, 0, 6126, 647, 1, 0, 0, 0, 6127, 6128, 3, 558, 279, 0, 6128, 649, 1, 0, 0, 0, 6129, 6130, 7, 45, 0, 0, 6130, 651, 1, 0, 0, 0, 6131, 6132, 5, 273, 0, 0, 6132, 6136, 5, 207, 0, 0, 6133, 6134, 5, 273, 0, 0, 6134, 6136, 5, 249, 0, 0, 6135, 6131, 1, 0, 0, 0, 6135, 6133, 1, 0, 0, 0, 6136, 653, 1, 0, 0, 0, 6137, 6139, 5, 46, 0, 0, 6138, 6140, 3, 658, 329, 0, 6139, 6138, 1, 0, 0, 0, 6139, 6140, 1, 0, 0, 0, 6140, 6145, 1, 0, 0, 0, 6141, 6142, 5, 211, 0, 0, 6142, 6146, 3, 1442, 721, 0, 6143, 6144, 5, 296, 0, 0, 6144, 6146, 3, 1430, 715, 0, 6145, 6141, 1, 0, 0, 0, 6145, 6143, 1, 0, 0, 0, 6146, 6147, 1, 0, 0, 0, 6147, 6157, 3, 676, 338, 0, 6148, 6155, 5, 316, 0, 0, 6149, 6156, 3, 686, 343, 0, 6150, 6151, 5, 92, 0, 0, 6151, 6152, 5, 2, 0, 0, 6152, 6153, 3, 714, 357, 0, 6153, 6154, 5, 3, 0, 0, 6154, 6156, 1, 0, 0, 0, 6155, 6149, 1, 0, 0, 0, 6155, 6150, 1, 0, 0, 0, 6156, 6158, 1, 0, 0, 0, 6157, 6148, 1, 0, 0, 0, 6157, 6158, 1, 0, 0, 0, 6158, 6159, 1, 0, 0, 0, 6159, 6162, 3, 702, 351, 0, 6160, 6161, 5, 105, 0, 0, 6161, 6163, 3, 656, 328, 0, 6162, 6160, 1, 0, 0, 0, 6162, 6163, 1, 0, 0, 0, 6163, 655, 1, 0, 0, 0, 6164, 6165, 5, 2, 0, 0, 6165, 6170, 3, 1474, 737, 0, 6166, 6167, 5, 6, 0, 0, 6167, 6169, 3, 1474, 737, 0, 6168, 6166, 1, 0, 0, 0, 6169, 6172, 1, 0, 0, 0, 6170, 6168, 1, 0, 0, 0, 6170, 6171, 1, 0, 0, 0, 6171, 6173, 1, 0, 0, 0, 6172, 6170, 1, 0, 0, 0, 6173, 6174, 5, 3, 0, 0, 6174, 657, 1, 0, 0, 0, 6175, 6176, 5, 82, 0, 0, 6176, 6177, 5, 311, 0, 0, 6177, 659, 1, 0, 0, 0, 6178, 6180, 5, 2, 0, 0, 6179, 6181, 3, 662, 331, 0, 6180, 6179, 1, 0, 0, 0, 6180, 6181, 1, 0, 0, 0, 6181, 6182, 1, 0, 0, 0, 6182, 6183, 5, 3, 0, 0, 6183, 661, 1, 0, 0, 0, 6184, 6189, 3, 680, 340, 0, 6185, 6186, 5, 6, 0, 0, 6186, 6188, 3, 680, 340, 0, 6187, 6185, 1, 0, 0, 0, 6188, 6191, 1, 0, 0, 0, 6189, 6187, 1, 0, 0, 0, 6189, 6190, 1, 0, 0, 0, 6190, 663, 1, 0, 0, 0, 6191, 6189, 1, 0, 0, 0, 6192, 6197, 3, 666, 333, 0, 6193, 6194, 5, 6, 0, 0, 6194, 6196, 3, 666, 333, 0, 6195, 6193, 1, 0, 0, 0, 6196, 6199, 1, 0, 0, 0, 6197, 6195, 1, 0, 0, 0, 6197, 6198, 1, 0, 0, 0, 6198, 665, 1, 0, 0, 0, 6199, 6197, 1, 0, 0, 0, 6200, 6201, 3, 1426, 713, 0, 6201, 6202, 3, 660, 330, 0, 6202, 6209, 1, 0, 0, 0, 6203, 6209, 3, 1500, 750, 0, 6204, 6206, 3, 1474, 737, 0, 6205, 6207, 3, 1380, 690, 0, 6206, 6205, 1, 0, 0, 0, 6206, 6207, 1, 0, 0, 0, 6207, 6209, 1, 0, 0, 0, 6208, 6200, 1, 0, 0, 0, 6208, 6203, 1, 0, 0, 0, 6208, 6204, 1, 0, 0, 0, 6209, 667, 1, 0, 0, 0, 6210, 6215, 3, 670, 335, 0, 6211, 6212, 5, 6, 0, 0, 6212, 6214, 3, 670, 335, 0, 6213, 6211, 1, 0, 0, 0, 6214, 6217, 1, 0, 0, 0, 6215, 6213, 1, 0, 0, 0, 6215, 6216, 1, 0, 0, 0, 6216, 669, 1, 0, 0, 0, 6217, 6215, 1, 0, 0, 0, 6218, 6219, 3, 1428, 714, 0, 6219, 6220, 3, 660, 330, 0, 6220, 6227, 1, 0, 0, 0, 6221, 6227, 3, 1500, 750, 0, 6222, 6224, 3, 1474, 737, 0, 6223, 6225, 3, 1380, 690, 0, 6224, 6223, 1, 0, 0, 0, 6224, 6225, 1, 0, 0, 0, 6225, 6227, 1, 0, 0, 0, 6226, 6218, 1, 0, 0, 0, 6226, 6221, 1, 0, 0, 0, 6226, 6222, 1, 0, 0, 0, 6227, 671, 1, 0, 0, 0, 6228, 6233, 3, 674, 337, 0, 6229, 6230, 5, 6, 0, 0, 6230, 6232, 3, 674, 337, 0, 6231, 6229, 1, 0, 0, 0, 6232, 6235, 1, 0, 0, 0, 6233, 6231, 1, 0, 0, 0, 6233, 6234, 1, 0, 0, 0, 6234, 673, 1, 0, 0, 0, 6235, 6233, 1, 0, 0, 0, 6236, 6237, 3, 1444, 722, 0, 6237, 6238, 3, 660, 330, 0, 6238, 6245, 1, 0, 0, 0, 6239, 6245, 3, 1500, 750, 0, 6240, 6242, 3, 1474, 737, 0, 6241, 6243, 3, 1380, 690, 0, 6242, 6241, 1, 0, 0, 0, 6242, 6243, 1, 0, 0, 0, 6243, 6245, 1, 0, 0, 0, 6244, 6236, 1, 0, 0, 0, 6244, 6239, 1, 0, 0, 0, 6244, 6240, 1, 0, 0, 0, 6245, 675, 1, 0, 0, 0, 6246, 6248, 5, 2, 0, 0, 6247, 6249, 3, 678, 339, 0, 6248, 6247, 1, 0, 0, 0, 6248, 6249, 1, 0, 0, 0, 6249, 6250, 1, 0, 0, 0, 6250, 6251, 5, 3, 0, 0, 6251, 677, 1, 0, 0, 0, 6252, 6257, 3, 690, 345, 0, 6253, 6254, 5, 6, 0, 0, 6254, 6256, 3, 690, 345, 0, 6255, 6253, 1, 0, 0, 0, 6256, 6259, 1, 0, 0, 0, 6257, 6255, 1, 0, 0, 0, 6257, 6258, 1, 0, 0, 0, 6258, 679, 1, 0, 0, 0, 6259, 6257, 1, 0, 0, 0, 6260, 6262, 3, 682, 341, 0, 6261, 6263, 3, 684, 342, 0, 6262, 6261, 1, 0, 0, 0, 6262, 6263, 1, 0, 0, 0, 6263, 6264, 1, 0, 0, 0, 6264, 6265, 3, 688, 344, 0, 6265, 6274, 1, 0, 0, 0, 6266, 6268, 3, 684, 342, 0, 6267, 6269, 3, 682, 341, 0, 6268, 6267, 1, 0, 0, 0, 6268, 6269, 1, 0, 0, 0, 6269, 6270, 1, 0, 0, 0, 6270, 6271, 3, 688, 344, 0, 6271, 6274, 1, 0, 0, 0, 6272, 6274, 3, 688, 344, 0, 6273, 6260, 1, 0, 0, 0, 6273, 6266, 1, 0, 0, 0, 6273, 6272, 1, 0, 0, 0, 6274, 681, 1, 0, 0, 0, 6275, 6277, 5, 68, 0, 0, 6276, 6278, 5, 453, 0, 0, 6277, 6276, 1, 0, 0, 0, 6277, 6278, 1, 0, 0, 0, 6278, 6283, 1, 0, 0, 0, 6279, 6283, 5, 453, 0, 0, 6280, 6283, 5, 400, 0, 0, 6281, 6283, 5, 101, 0, 0, 6282, 6275, 1, 0, 0, 0, 6282, 6279, 1, 0, 0, 0, 6282, 6280, 1, 0, 0, 0, 6282, 6281, 1, 0, 0, 0, 6283, 683, 1, 0, 0, 0, 6284, 6285, 3, 1482, 741, 0, 6285, 685, 1, 0, 0, 0, 6286, 6287, 3, 688, 344, 0, 6287, 687, 1, 0, 0, 0, 6288, 6301, 3, 1168, 584, 0, 6289, 6290, 3, 1482, 741, 0, 6290, 6291, 3, 560, 280, 0, 6291, 6292, 5, 27, 0, 0, 6292, 6293, 5, 360, 0, 0, 6293, 6301, 1, 0, 0, 0, 6294, 6295, 5, 415, 0, 0, 6295, 6296, 3, 1482, 741, 0, 6296, 6297, 3, 560, 280, 0, 6297, 6298, 5, 27, 0, 0, 6298, 6299, 5, 360, 0, 0, 6299, 6301, 1, 0, 0, 0, 6300, 6288, 1, 0, 0, 0, 6300, 6289, 1, 0, 0, 0, 6300, 6294, 1, 0, 0, 0, 6301, 689, 1, 0, 0, 0, 6302, 6305, 3, 680, 340, 0, 6303, 6304, 7, 46, 0, 0, 6304, 6306, 3, 1212, 606, 0, 6305, 6303, 1, 0, 0, 0, 6305, 6306, 1, 0, 0, 0, 6306, 691, 1, 0, 0, 0, 6307, 6308, 3, 680, 340, 0, 6308, 693, 1, 0, 0, 0, 6309, 6320, 5, 2, 0, 0, 6310, 6321, 5, 9, 0, 0, 6311, 6321, 3, 696, 348, 0, 6312, 6313, 5, 83, 0, 0, 6313, 6314, 5, 147, 0, 0, 6314, 6321, 3, 696, 348, 0, 6315, 6316, 3, 696, 348, 0, 6316, 6317, 5, 83, 0, 0, 6317, 6318, 5, 147, 0, 0, 6318, 6319, 3, 696, 348, 0, 6319, 6321, 1, 0, 0, 0, 6320, 6310, 1, 0, 0, 0, 6320, 6311, 1, 0, 0, 0, 6320, 6312, 1, 0, 0, 0, 6320, 6315, 1, 0, 0, 0, 6321, 6322, 1, 0, 0, 0, 6322, 6323, 5, 3, 0, 0, 6323, 695, 1, 0, 0, 0, 6324, 6329, 3, 692, 346, 0, 6325, 6326, 5, 6, 0, 0, 6326, 6328, 3, 692, 346, 0, 6327, 6325, 1, 0, 0, 0, 6328, 6331, 1, 0, 0, 0, 6329, 6327, 1, 0, 0, 0, 6329, 6330, 1, 0, 0, 0, 6330, 697, 1, 0, 0, 0, 6331, 6329, 1, 0, 0, 0, 6332, 6333, 3, 1444, 722, 0, 6333, 6334, 3, 694, 347, 0, 6334, 699, 1, 0, 0, 0, 6335, 6340, 3, 698, 349, 0, 6336, 6337, 5, 6, 0, 0, 6337, 6339, 3, 698, 349, 0, 6338, 6336, 1, 0, 0, 0, 6339, 6342, 1, 0, 0, 0, 6340, 6338, 1, 0, 0, 0, 6340, 6341, 1, 0, 0, 0, 6341, 701, 1, 0, 0, 0, 6342, 6340, 1, 0, 0, 0, 6343, 6345, 3, 706, 353, 0, 6344, 6343, 1, 0, 0, 0, 6345, 6346, 1, 0, 0, 0, 6346, 6344, 1, 0, 0, 0, 6346, 6347, 1, 0, 0, 0, 6347, 703, 1, 0, 0, 0, 6348, 6349, 5, 149, 0, 0, 6349, 6350, 5, 80, 0, 0, 6350, 6351, 5, 78, 0, 0, 6351, 6384, 5, 458, 0, 0, 6352, 6353, 5, 316, 0, 0, 6353, 6354, 5, 78, 0, 0, 6354, 6355, 5, 80, 0, 0, 6355, 6356, 5, 78, 0, 0, 6356, 6384, 5, 458, 0, 0, 6357, 6384, 5, 346, 0, 0, 6358, 6384, 5, 222, 0, 0, 6359, 6384, 5, 338, 0, 0, 6360, 6384, 5, 377, 0, 0, 6361, 6362, 5, 205, 0, 0, 6362, 6363, 5, 327, 0, 0, 6363, 6384, 5, 181, 0, 0, 6364, 6365, 5, 205, 0, 0, 6365, 6366, 5, 327, 0, 0, 6366, 6384, 5, 243, 0, 0, 6367, 6368, 5, 327, 0, 0, 6368, 6384, 5, 181, 0, 0, 6369, 6370, 5, 327, 0, 0, 6370, 6384, 5, 243, 0, 0, 6371, 6384, 5, 250, 0, 0, 6372, 6373, 5, 77, 0, 0, 6373, 6384, 5, 250, 0, 0, 6374, 6375, 5, 170, 0, 0, 6375, 6384, 3, 322, 161, 0, 6376, 6377, 5, 320, 0, 0, 6377, 6384, 3, 322, 161, 0, 6378, 6379, 5, 459, 0, 0, 6379, 6384, 3, 558, 279, 0, 6380, 6384, 3, 90, 45, 0, 6381, 6382, 5, 460, 0, 0, 6382, 6384, 3, 1474, 737, 0, 6383, 6348, 1, 0, 0, 0, 6383, 6352, 1, 0, 0, 0, 6383, 6357, 1, 0, 0, 0, 6383, 6358, 1, 0, 0, 0, 6383, 6359, 1, 0, 0, 0, 6383, 6360, 1, 0, 0, 0, 6383, 6361, 1, 0, 0, 0, 6383, 6364, 1, 0, 0, 0, 6383, 6367, 1, 0, 0, 0, 6383, 6369, 1, 0, 0, 0, 6383, 6371, 1, 0, 0, 0, 6383, 6372, 1, 0, 0, 0, 6383, 6374, 1, 0, 0, 0, 6383, 6376, 1, 0, 0, 0, 6383, 6378, 1, 0, 0, 0, 6383, 6380, 1, 0, 0, 0, 6383, 6381, 1, 0, 0, 0, 6384, 705, 1, 0, 0, 0, 6385, 6386, 5, 36, 0, 0, 6386, 6387, 3, 1458, 729, 0, 6387, 6388, 5, 6, 0, 0, 6388, 6389, 3, 1458, 729, 0, 6389, 6411, 1, 0, 0, 0, 6390, 6391, 5, 247, 0, 0, 6391, 6411, 3, 80, 40, 0, 6392, 6393, 5, 443, 0, 0, 6393, 6411, 3, 708, 354, 0, 6394, 6411, 5, 104, 0, 0, 6395, 6396, 5, 333, 0, 0, 6396, 6403, 3, 1474, 737, 0, 6397, 6398, 5, 94, 0, 0, 6398, 6404, 3, 1474, 737, 0, 6399, 6400, 5, 10, 0, 0, 6400, 6404, 3, 1474, 737, 0, 6401, 6402, 5, 64, 0, 0, 6402, 6404, 5, 434, 0, 0, 6403, 6397, 1, 0, 0, 0, 6403, 6399, 1, 0, 0, 0, 6403, 6401, 1, 0, 0, 0, 6404, 6411, 1, 0, 0, 0, 6405, 6406, 5, 36, 0, 0, 6406, 6411, 3, 1474, 737, 0, 6407, 6411, 3, 6, 3, 0, 6408, 6411, 3, 704, 352, 0, 6409, 6411, 3, 1474, 737, 0, 6410, 6385, 1, 0, 0, 0, 6410, 6390, 1, 0, 0, 0, 6410, 6392, 1, 0, 0, 0, 6410, 6394, 1, 0, 0, 0, 6410, 6395, 1, 0, 0, 0, 6410, 6405, 1, 0, 0, 0, 6410, 6407, 1, 0, 0, 0, 6410, 6408, 1, 0, 0, 0, 6410, 6409, 1, 0, 0, 0, 6411, 707, 1, 0, 0, 0, 6412, 6413, 5, 62, 0, 0, 6413, 6414, 5, 360, 0, 0, 6414, 6421, 3, 1168, 584, 0, 6415, 6416, 5, 6, 0, 0, 6416, 6417, 5, 62, 0, 0, 6417, 6418, 5, 360, 0, 0, 6418, 6420, 3, 1168, 584, 0, 6419, 6415, 1, 0, 0, 0, 6420, 6423, 1, 0, 0, 0, 6421, 6419, 1, 0, 0, 0, 6421, 6422, 1, 0, 0, 0, 6422, 709, 1, 0, 0, 0, 6423, 6421, 1, 0, 0, 0, 6424, 6425, 5, 105, 0, 0, 6425, 6426, 3, 496, 248, 0, 6426, 711, 1, 0, 0, 0, 6427, 6428, 3, 1432, 716, 0, 6428, 6429, 3, 688, 344, 0, 6429, 713, 1, 0, 0, 0, 6430, 6435, 3, 712, 356, 0, 6431, 6432, 5, 6, 0, 0, 6432, 6434, 3, 712, 356, 0, 6433, 6431, 1, 0, 0, 0, 6434, 6437, 1, 0, 0, 0, 6435, 6433, 1, 0, 0, 0, 6435, 6436, 1, 0, 0, 0, 6436, 715, 1, 0, 0, 0, 6437, 6435, 1, 0, 0, 0, 6438, 6439, 5, 138, 0, 0, 6439, 6440, 3, 718, 359, 0, 6440, 6442, 3, 720, 360, 0, 6441, 6443, 3, 722, 361, 0, 6442, 6441, 1, 0, 0, 0, 6442, 6443, 1, 0, 0, 0, 6443, 717, 1, 0, 0, 0, 6444, 6445, 5, 211, 0, 0, 6445, 6451, 3, 674, 337, 0, 6446, 6447, 5, 296, 0, 0, 6447, 6451, 3, 670, 335, 0, 6448, 6449, 5, 442, 0, 0, 6449, 6451, 3, 666, 333, 0, 6450, 6444, 1, 0, 0, 0, 6450, 6446, 1, 0, 0, 0, 6450, 6448, 1, 0, 0, 0, 6451, 719, 1, 0, 0, 0, 6452, 6454, 3, 704, 352, 0, 6453, 6452, 1, 0, 0, 0, 6454, 6455, 1, 0, 0, 0, 6455, 6453, 1, 0, 0, 0, 6455, 6456, 1, 0, 0, 0, 6456, 721, 1, 0, 0, 0, 6457, 6458, 5, 315, 0, 0, 6458, 723, 1, 0, 0, 0, 6459, 6460, 5, 191, 0, 0, 6460, 6462, 5, 211, 0, 0, 6461, 6463, 3, 748, 374, 0, 6462, 6461, 1, 0, 0, 0, 6462, 6463, 1, 0, 0, 0, 6463, 6464, 1, 0, 0, 0, 6464, 6466, 3, 672, 336, 0, 6465, 6467, 3, 124, 62, 0, 6466, 6465, 1, 0, 0, 0, 6466, 6467, 1, 0, 0, 0, 6467, 6487, 1, 0, 0, 0, 6468, 6469, 5, 191, 0, 0, 6469, 6471, 5, 296, 0, 0, 6470, 6472, 3, 748, 374, 0, 6471, 6470, 1, 0, 0, 0, 6471, 6472, 1, 0, 0, 0, 6472, 6473, 1, 0, 0, 0, 6473, 6475, 3, 668, 334, 0, 6474, 6476, 3, 124, 62, 0, 6475, 6474, 1, 0, 0, 0, 6475, 6476, 1, 0, 0, 0, 6476, 6487, 1, 0, 0, 0, 6477, 6478, 5, 191, 0, 0, 6478, 6480, 5, 442, 0, 0, 6479, 6481, 3, 748, 374, 0, 6480, 6479, 1, 0, 0, 0, 6480, 6481, 1, 0, 0, 0, 6481, 6482, 1, 0, 0, 0, 6482, 6484, 3, 664, 332, 0, 6483, 6485, 3, 124, 62, 0, 6484, 6483, 1, 0, 0, 0, 6484, 6485, 1, 0, 0, 0, 6485, 6487, 1, 0, 0, 0, 6486, 6459, 1, 0, 0, 0, 6486, 6468, 1, 0, 0, 0, 6486, 6477, 1, 0, 0, 0, 6487, 725, 1, 0, 0, 0, 6488, 6489, 5, 191, 0, 0, 6489, 6491, 5, 136, 0, 0, 6490, 6492, 3, 748, 374, 0, 6491, 6490, 1, 0, 0, 0, 6491, 6492, 1, 0, 0, 0, 6492, 6493, 1, 0, 0, 0, 6493, 6495, 3, 700, 350, 0, 6494, 6496, 3, 124, 62, 0, 6495, 6494, 1, 0, 0, 0, 6495, 6496, 1, 0, 0, 0, 6496, 727, 1, 0, 0, 0, 6497, 6498, 5, 191, 0, 0, 6498, 6500, 5, 278, 0, 0, 6499, 6501, 3, 748, 374, 0, 6500, 6499, 1, 0, 0, 0, 6500, 6501, 1, 0, 0, 0, 6501, 6502, 1, 0, 0, 0, 6502, 6504, 3, 734, 367, 0, 6503, 6505, 3, 124, 62, 0, 6504, 6503, 1, 0, 0, 0, 6504, 6505, 1, 0, 0, 0, 6505, 729, 1, 0, 0, 0, 6506, 6507, 5, 2, 0, 0, 6507, 6508, 3, 1168, 584, 0, 6508, 6509, 5, 3, 0, 0, 6509, 6529, 1, 0, 0, 0, 6510, 6511, 5, 2, 0, 0, 6511, 6512, 3, 1168, 584, 0, 6512, 6513, 5, 6, 0, 0, 6513, 6514, 3, 1168, 584, 0, 6514, 6515, 5, 3, 0, 0, 6515, 6529, 1, 0, 0, 0, 6516, 6517, 5, 2, 0, 0, 6517, 6518, 5, 407, 0, 0, 6518, 6519, 5, 6, 0, 0, 6519, 6520, 3, 1168, 584, 0, 6520, 6521, 5, 3, 0, 0, 6521, 6529, 1, 0, 0, 0, 6522, 6523, 5, 2, 0, 0, 6523, 6524, 3, 1168, 584, 0, 6524, 6525, 5, 6, 0, 0, 6525, 6526, 5, 407, 0, 0, 6526, 6527, 5, 3, 0, 0, 6527, 6529, 1, 0, 0, 0, 6528, 6506, 1, 0, 0, 0, 6528, 6510, 1, 0, 0, 0, 6528, 6516, 1, 0, 0, 0, 6528, 6522, 1, 0, 0, 0, 6529, 731, 1, 0, 0, 0, 6530, 6531, 3, 1474, 737, 0, 6531, 6532, 5, 11, 0, 0, 6532, 6534, 1, 0, 0, 0, 6533, 6530, 1, 0, 0, 0, 6534, 6537, 1, 0, 0, 0, 6535, 6533, 1, 0, 0, 0, 6535, 6536, 1, 0, 0, 0, 6536, 6538, 1, 0, 0, 0, 6537, 6535, 1, 0, 0, 0, 6538, 6539, 3, 1318, 659, 0, 6539, 733, 1, 0, 0, 0, 6540, 6545, 3, 736, 368, 0, 6541, 6542, 5, 6, 0, 0, 6542, 6544, 3, 736, 368, 0, 6543, 6541, 1, 0, 0, 0, 6544, 6547, 1, 0, 0, 0, 6545, 6543, 1, 0, 0, 0, 6545, 6546, 1, 0, 0, 0, 6546, 735, 1, 0, 0, 0, 6547, 6545, 1, 0, 0, 0, 6548, 6549, 3, 732, 366, 0, 6549, 6550, 3, 730, 365, 0, 6550, 737, 1, 0, 0, 0, 6551, 6552, 5, 57, 0, 0, 6552, 6553, 3, 740, 370, 0, 6553, 739, 1, 0, 0, 0, 6554, 6556, 3, 742, 371, 0, 6555, 6554, 1, 0, 0, 0, 6556, 6557, 1, 0, 0, 0, 6557, 6555, 1, 0, 0, 0, 6557, 6558, 1, 0, 0, 0, 6558, 741, 1, 0, 0, 0, 6559, 6563, 3, 1458, 729, 0, 6560, 6561, 5, 247, 0, 0, 6561, 6563, 3, 80, 40, 0, 6562, 6559, 1, 0, 0, 0, 6562, 6560, 1, 0, 0, 0, 6563, 743, 1, 0, 0, 0, 6564, 6565, 5, 46, 0, 0, 6565, 6566, 5, 41, 0, 0, 6566, 6567, 5, 2, 0, 0, 6567, 6568, 3, 1168, 584, 0, 6568, 6569, 5, 36, 0, 0, 6569, 6570, 3, 1168, 584, 0, 6570, 6571, 5, 3, 0, 0, 6571, 6572, 5, 105, 0, 0, 6572, 6573, 5, 211, 0, 0, 6573, 6575, 3, 674, 337, 0, 6574, 6576, 3, 746, 373, 0, 6575, 6574, 1, 0, 0, 0, 6575, 6576, 1, 0, 0, 0, 6576, 6602, 1, 0, 0, 0, 6577, 6578, 5, 46, 0, 0, 6578, 6579, 5, 41, 0, 0, 6579, 6580, 5, 2, 0, 0, 6580, 6581, 3, 1168, 584, 0, 6581, 6582, 5, 36, 0, 0, 6582, 6583, 3, 1168, 584, 0, 6583, 6584, 5, 3, 0, 0, 6584, 6585, 5, 379, 0, 0, 6585, 6587, 5, 211, 0, 0, 6586, 6588, 3, 746, 373, 0, 6587, 6586, 1, 0, 0, 0, 6587, 6588, 1, 0, 0, 0, 6588, 6602, 1, 0, 0, 0, 6589, 6590, 5, 46, 0, 0, 6590, 6591, 5, 41, 0, 0, 6591, 6592, 5, 2, 0, 0, 6592, 6593, 3, 1168, 584, 0, 6593, 6594, 5, 36, 0, 0, 6594, 6595, 3, 1168, 584, 0, 6595, 6596, 5, 3, 0, 0, 6596, 6597, 5, 105, 0, 0, 6597, 6599, 5, 400, 0, 0, 6598, 6600, 3, 746, 373, 0, 6599, 6598, 1, 0, 0, 0, 6599, 6600, 1, 0, 0, 0, 6600, 6602, 1, 0, 0, 0, 6601, 6564, 1, 0, 0, 0, 6601, 6577, 1, 0, 0, 0, 6601, 6589, 1, 0, 0, 0, 6602, 745, 1, 0, 0, 0, 6603, 6604, 5, 36, 0, 0, 6604, 6608, 5, 223, 0, 0, 6605, 6606, 5, 36, 0, 0, 6606, 6608, 5, 141, 0, 0, 6607, 6603, 1, 0, 0, 0, 6607, 6605, 1, 0, 0, 0, 6608, 747, 1, 0, 0, 0, 6609, 6610, 5, 220, 0, 0, 6610, 6611, 5, 396, 0, 0, 6611, 749, 1, 0, 0, 0, 6612, 6614, 5, 46, 0, 0, 6613, 6615, 3, 658, 329, 0, 6614, 6613, 1, 0, 0, 0, 6614, 6615, 1, 0, 0, 0, 6615, 6616, 1, 0, 0, 0, 6616, 6617, 5, 443, 0, 0, 6617, 6618, 5, 62, 0, 0, 6618, 6619, 3, 1168, 584, 0, 6619, 6620, 5, 247, 0, 0, 6620, 6621, 3, 1436, 718, 0, 6621, 6622, 5, 2, 0, 0, 6622, 6623, 3, 752, 376, 0, 6623, 6624, 5, 3, 0, 0, 6624, 751, 1, 0, 0, 0, 6625, 6626, 5, 64, 0, 0, 6626, 6627, 5, 461, 0, 0, 6627, 6628, 5, 105, 0, 0, 6628, 6629, 5, 211, 0, 0, 6629, 6630, 3, 674, 337, 0, 6630, 6631, 5, 6, 0, 0, 6631, 6632, 5, 94, 0, 0, 6632, 6633, 5, 461, 0, 0, 6633, 6634, 5, 105, 0, 0, 6634, 6635, 5, 211, 0, 0, 6635, 6636, 3, 674, 337, 0, 6636, 6660, 1, 0, 0, 0, 6637, 6638, 5, 94, 0, 0, 6638, 6639, 5, 461, 0, 0, 6639, 6640, 5, 105, 0, 0, 6640, 6641, 5, 211, 0, 0, 6641, 6642, 3, 674, 337, 0, 6642, 6643, 5, 6, 0, 0, 6643, 6644, 5, 64, 0, 0, 6644, 6645, 5, 461, 0, 0, 6645, 6646, 5, 105, 0, 0, 6646, 6647, 5, 211, 0, 0, 6647, 6648, 3, 674, 337, 0, 6648, 6660, 1, 0, 0, 0, 6649, 6650, 5, 64, 0, 0, 6650, 6651, 5, 461, 0, 0, 6651, 6652, 5, 105, 0, 0, 6652, 6653, 5, 211, 0, 0, 6653, 6660, 3, 674, 337, 0, 6654, 6655, 5, 94, 0, 0, 6655, 6656, 5, 461, 0, 0, 6656, 6657, 5, 105, 0, 0, 6657, 6658, 5, 211, 0, 0, 6658, 6660, 3, 674, 337, 0, 6659, 6625, 1, 0, 0, 0, 6659, 6637, 1, 0, 0, 0, 6659, 6649, 1, 0, 0, 0, 6659, 6654, 1, 0, 0, 0, 6660, 753, 1, 0, 0, 0, 6661, 6662, 5, 306, 0, 0, 6662, 6678, 3, 756, 378, 0, 6663, 6664, 5, 306, 0, 0, 6664, 6678, 3, 758, 379, 0, 6665, 6666, 5, 306, 0, 0, 6666, 6667, 5, 2, 0, 0, 6667, 6668, 3, 760, 380, 0, 6668, 6669, 5, 3, 0, 0, 6669, 6670, 3, 756, 378, 0, 6670, 6678, 1, 0, 0, 0, 6671, 6672, 5, 306, 0, 0, 6672, 6673, 5, 2, 0, 0, 6673, 6674, 3, 760, 380, 0, 6674, 6675, 5, 3, 0, 0, 6675, 6676, 3, 758, 379, 0, 6676, 6678, 1, 0, 0, 0, 6677, 6661, 1, 0, 0, 0, 6677, 6663, 1, 0, 0, 0, 6677, 6665, 1, 0, 0, 0, 6677, 6671, 1, 0, 0, 0, 6678, 755, 1, 0, 0, 0, 6679, 6681, 5, 226, 0, 0, 6680, 6682, 3, 630, 315, 0, 6681, 6680, 1, 0, 0, 0, 6681, 6682, 1, 0, 0, 0, 6682, 6683, 1, 0, 0, 0, 6683, 6690, 3, 1412, 706, 0, 6684, 6686, 5, 92, 0, 0, 6685, 6687, 3, 630, 315, 0, 6686, 6685, 1, 0, 0, 0, 6686, 6687, 1, 0, 0, 0, 6687, 6688, 1, 0, 0, 0, 6688, 6690, 3, 1406, 703, 0, 6689, 6679, 1, 0, 0, 0, 6689, 6684, 1, 0, 0, 0, 6690, 757, 1, 0, 0, 0, 6691, 6693, 5, 323, 0, 0, 6692, 6694, 3, 630, 315, 0, 6693, 6692, 1, 0, 0, 0, 6693, 6694, 1, 0, 0, 0, 6694, 6695, 1, 0, 0, 0, 6695, 6707, 3, 1422, 711, 0, 6696, 6698, 5, 349, 0, 0, 6697, 6699, 3, 630, 315, 0, 6698, 6697, 1, 0, 0, 0, 6698, 6699, 1, 0, 0, 0, 6699, 6700, 1, 0, 0, 0, 6700, 6707, 3, 1436, 718, 0, 6701, 6703, 5, 175, 0, 0, 6702, 6704, 3, 630, 315, 0, 6703, 6702, 1, 0, 0, 0, 6703, 6704, 1, 0, 0, 0, 6704, 6705, 1, 0, 0, 0, 6705, 6707, 3, 1420, 710, 0, 6706, 6691, 1, 0, 0, 0, 6706, 6696, 1, 0, 0, 0, 6706, 6701, 1, 0, 0, 0, 6707, 759, 1, 0, 0, 0, 6708, 6713, 3, 762, 381, 0, 6709, 6710, 5, 6, 0, 0, 6710, 6712, 3, 762, 381, 0, 6711, 6709, 1, 0, 0, 0, 6712, 6715, 1, 0, 0, 0, 6713, 6711, 1, 0, 0, 0, 6713, 6714, 1, 0, 0, 0, 6714, 761, 1, 0, 0, 0, 6715, 6713, 1, 0, 0, 0, 6716, 6717, 5, 128, 0, 0, 6717, 763, 1, 0, 0, 0, 6718, 6719, 5, 138, 0, 0, 6719, 6720, 5, 351, 0, 0, 6720, 6721, 3, 1402, 701, 0, 6721, 6722, 5, 333, 0, 0, 6722, 6723, 3, 132, 66, 0, 6723, 6731, 1, 0, 0, 0, 6724, 6725, 5, 138, 0, 0, 6725, 6726, 5, 351, 0, 0, 6726, 6727, 3, 1402, 701, 0, 6727, 6728, 5, 313, 0, 0, 6728, 6729, 3, 132, 66, 0, 6729, 6731, 1, 0, 0, 0, 6730, 6718, 1, 0, 0, 0, 6730, 6724, 1, 0, 0, 0, 6731, 765, 1, 0, 0, 0, 6732, 6733, 5, 138, 0, 0, 6733, 6734, 5, 136, 0, 0, 6734, 6735, 3, 698, 349, 0, 6735, 6736, 5, 309, 0, 0, 6736, 6737, 5, 94, 0, 0, 6737, 6738, 3, 1436, 718, 0, 6738, 7124, 1, 0, 0, 0, 6739, 6740, 5, 138, 0, 0, 6740, 6741, 5, 108, 0, 0, 6741, 6742, 3, 558, 279, 0, 6742, 6743, 5, 309, 0, 0, 6743, 6744, 5, 94, 0, 0, 6744, 6745, 3, 1436, 718, 0, 6745, 7124, 1, 0, 0, 0, 6746, 6747, 5, 138, 0, 0, 6747, 6748, 5, 168, 0, 0, 6748, 6749, 3, 558, 279, 0, 6749, 6750, 5, 309, 0, 0, 6750, 6751, 5, 94, 0, 0, 6751, 6752, 3, 1436, 718, 0, 6752, 7124, 1, 0, 0, 0, 6753, 6754, 5, 138, 0, 0, 6754, 6755, 5, 175, 0, 0, 6755, 6756, 3, 1420, 710, 0, 6756, 6757, 5, 309, 0, 0, 6757, 6758, 5, 94, 0, 0, 6758, 6759, 3, 1418, 709, 0, 6759, 7124, 1, 0, 0, 0, 6760, 6761, 5, 138, 0, 0, 6761, 6762, 5, 189, 0, 0, 6762, 6763, 3, 558, 279, 0, 6763, 6764, 5, 309, 0, 0, 6764, 6765, 5, 94, 0, 0, 6765, 6766, 3, 1436, 718, 0, 6766, 7124, 1, 0, 0, 0, 6767, 6768, 5, 138, 0, 0, 6768, 6769, 5, 189, 0, 0, 6769, 6770, 3, 558, 279, 0, 6770, 6771, 5, 309, 0, 0, 6771, 6772, 5, 45, 0, 0, 6772, 6773, 3, 1436, 718, 0, 6773, 6774, 5, 94, 0, 0, 6774, 6775, 3, 1436, 718, 0, 6775, 7124, 1, 0, 0, 0, 6776, 6777, 5, 138, 0, 0, 6777, 6778, 5, 63, 0, 0, 6778, 6779, 5, 174, 0, 0, 6779, 6780, 5, 381, 0, 0, 6780, 6781, 3, 1436, 718, 0, 6781, 6782, 5, 309, 0, 0, 6782, 6783, 5, 94, 0, 0, 6783, 6784, 3, 1436, 718, 0, 6784, 7124, 1, 0, 0, 0, 6785, 6786, 5, 138, 0, 0, 6786, 6787, 5, 211, 0, 0, 6787, 6788, 3, 674, 337, 0, 6788, 6789, 5, 309, 0, 0, 6789, 6790, 5, 94, 0, 0, 6790, 6791, 3, 1442, 721, 0, 6791, 7124, 1, 0, 0, 0, 6792, 6793, 5, 138, 0, 0, 6793, 6794, 5, 66, 0, 0, 6794, 6795, 3, 1468, 734, 0, 6795, 6796, 5, 309, 0, 0, 6796, 6797, 5, 94, 0, 0, 6797, 6798, 3, 1468, 734, 0, 6798, 7124, 1, 0, 0, 0, 6799, 6801, 5, 138, 0, 0, 6800, 6802, 3, 338, 169, 0, 6801, 6800, 1, 0, 0, 0, 6801, 6802, 1, 0, 0, 0, 6802, 6803, 1, 0, 0, 0, 6803, 6804, 5, 247, 0, 0, 6804, 6805, 3, 1436, 718, 0, 6805, 6806, 5, 309, 0, 0, 6806, 6807, 5, 94, 0, 0, 6807, 6808, 3, 1436, 718, 0, 6808, 7124, 1, 0, 0, 0, 6809, 6810, 5, 138, 0, 0, 6810, 6811, 5, 278, 0, 0, 6811, 6812, 5, 156, 0, 0, 6812, 6813, 3, 558, 279, 0, 6813, 6814, 5, 100, 0, 0, 6814, 6815, 3, 1436, 718, 0, 6815, 6816, 5, 309, 0, 0, 6816, 6817, 5, 94, 0, 0, 6817, 6818, 3, 1436, 718, 0, 6818, 7124, 1, 0, 0, 0, 6819, 6820, 5, 138, 0, 0, 6820, 6821, 5, 278, 0, 0, 6821, 6822, 5, 206, 0, 0, 6822, 6823, 3, 558, 279, 0, 6823, 6824, 5, 100, 0, 0, 6824, 6825, 3, 1436, 718, 0, 6825, 6826, 5, 309, 0, 0, 6826, 6827, 5, 94, 0, 0, 6827, 6828, 3, 1436, 718, 0, 6828, 7124, 1, 0, 0, 0, 6829, 6830, 5, 138, 0, 0, 6830, 6832, 5, 445, 0, 0, 6831, 6833, 3, 748, 374, 0, 6832, 6831, 1, 0, 0, 0, 6832, 6833, 1, 0, 0, 0, 6833, 6834, 1, 0, 0, 0, 6834, 6835, 3, 1436, 718, 0, 6835, 6836, 5, 80, 0, 0, 6836, 6837, 3, 1412, 706, 0, 6837, 6838, 5, 309, 0, 0, 6838, 6839, 5, 94, 0, 0, 6839, 6840, 3, 1436, 718, 0, 6840, 7124, 1, 0, 0, 0, 6841, 6842, 5, 138, 0, 0, 6842, 6843, 5, 296, 0, 0, 6843, 6844, 3, 670, 335, 0, 6844, 6845, 5, 309, 0, 0, 6845, 6846, 5, 94, 0, 0, 6846, 6847, 3, 1430, 715, 0, 6847, 7124, 1, 0, 0, 0, 6848, 6849, 5, 138, 0, 0, 6849, 6850, 5, 452, 0, 0, 6850, 6851, 3, 1436, 718, 0, 6851, 6852, 5, 309, 0, 0, 6852, 6853, 5, 94, 0, 0, 6853, 6854, 3, 1436, 718, 0, 6854, 7124, 1, 0, 0, 0, 6855, 6856, 5, 138, 0, 0, 6856, 6857, 5, 442, 0, 0, 6857, 6858, 3, 666, 333, 0, 6858, 6859, 5, 309, 0, 0, 6859, 6860, 5, 94, 0, 0, 6860, 6861, 3, 1436, 718, 0, 6861, 7124, 1, 0, 0, 0, 6862, 6863, 5, 138, 0, 0, 6863, 6864, 5, 323, 0, 0, 6864, 6865, 3, 1422, 711, 0, 6865, 6866, 5, 309, 0, 0, 6866, 6867, 5, 94, 0, 0, 6867, 6868, 3, 48, 24, 0, 6868, 7124, 1, 0, 0, 0, 6869, 6870, 5, 138, 0, 0, 6870, 6871, 5, 331, 0, 0, 6871, 6872, 3, 1436, 718, 0, 6872, 6873, 5, 309, 0, 0, 6873, 6874, 5, 94, 0, 0, 6874, 6875, 3, 1436, 718, 0, 6875, 7124, 1, 0, 0, 0, 6876, 6877, 5, 138, 0, 0, 6877, 6878, 5, 451, 0, 0, 6878, 6879, 3, 1436, 718, 0, 6879, 6880, 5, 309, 0, 0, 6880, 6881, 5, 94, 0, 0, 6881, 6882, 3, 1436, 718, 0, 6882, 7124, 1, 0, 0, 0, 6883, 6884, 5, 138, 0, 0, 6884, 6886, 5, 92, 0, 0, 6885, 6887, 3, 748, 374, 0, 6886, 6885, 1, 0, 0, 0, 6886, 6887, 1, 0, 0, 0, 6887, 6888, 1, 0, 0, 0, 6888, 6889, 3, 1118, 559, 0, 6889, 6890, 5, 309, 0, 0, 6890, 6891, 5, 94, 0, 0, 6891, 6892, 3, 1404, 702, 0, 6892, 7124, 1, 0, 0, 0, 6893, 6894, 5, 138, 0, 0, 6894, 6896, 5, 328, 0, 0, 6895, 6897, 3, 748, 374, 0, 6896, 6895, 1, 0, 0, 0, 6896, 6897, 1, 0, 0, 0, 6897, 6898, 1, 0, 0, 0, 6898, 6899, 3, 1412, 706, 0, 6899, 6900, 5, 309, 0, 0, 6900, 6901, 5, 94, 0, 0, 6901, 6902, 3, 1436, 718, 0, 6902, 7124, 1, 0, 0, 0, 6903, 6904, 5, 138, 0, 0, 6904, 6906, 5, 376, 0, 0, 6905, 6907, 3, 748, 374, 0, 6906, 6905, 1, 0, 0, 0, 6906, 6907, 1, 0, 0, 0, 6907, 6908, 1, 0, 0, 0, 6908, 6909, 3, 1410, 705, 0, 6909, 6910, 5, 309, 0, 0, 6910, 6911, 5, 94, 0, 0, 6911, 6912, 3, 1408, 704, 0, 6912, 7124, 1, 0, 0, 0, 6913, 6914, 5, 138, 0, 0, 6914, 6915, 5, 259, 0, 0, 6915, 6917, 5, 376, 0, 0, 6916, 6918, 3, 748, 374, 0, 6917, 6916, 1, 0, 0, 0, 6917, 6918, 1, 0, 0, 0, 6918, 6919, 1, 0, 0, 0, 6919, 6920, 3, 1410, 705, 0, 6920, 6921, 5, 309, 0, 0, 6921, 6922, 5, 94, 0, 0, 6922, 6923, 3, 1408, 704, 0, 6923, 7124, 1, 0, 0, 0, 6924, 6925, 5, 138, 0, 0, 6925, 6927, 5, 226, 0, 0, 6926, 6928, 3, 748, 374, 0, 6927, 6926, 1, 0, 0, 0, 6927, 6928, 1, 0, 0, 0, 6928, 6929, 1, 0, 0, 0, 6929, 6930, 3, 1412, 706, 0, 6930, 6931, 5, 309, 0, 0, 6931, 6932, 5, 94, 0, 0, 6932, 6933, 3, 1436, 718, 0, 6933, 7124, 1, 0, 0, 0, 6934, 6935, 5, 138, 0, 0, 6935, 6936, 5, 63, 0, 0, 6936, 6938, 5, 92, 0, 0, 6937, 6939, 3, 748, 374, 0, 6938, 6937, 1, 0, 0, 0, 6938, 6939, 1, 0, 0, 0, 6939, 6940, 1, 0, 0, 0, 6940, 6941, 3, 1118, 559, 0, 6941, 6942, 5, 309, 0, 0, 6942, 6943, 5, 94, 0, 0, 6943, 6944, 3, 1404, 702, 0, 6944, 7124, 1, 0, 0, 0, 6945, 6946, 5, 138, 0, 0, 6946, 6948, 5, 92, 0, 0, 6947, 6949, 3, 748, 374, 0, 6948, 6947, 1, 0, 0, 0, 6948, 6949, 1, 0, 0, 0, 6949, 6950, 1, 0, 0, 0, 6950, 6951, 3, 1118, 559, 0, 6951, 6953, 5, 309, 0, 0, 6952, 6954, 5, 44, 0, 0, 6953, 6952, 1, 0, 0, 0, 6953, 6954, 1, 0, 0, 0, 6954, 6955, 1, 0, 0, 0, 6955, 6956, 3, 1432, 716, 0, 6956, 6957, 5, 94, 0, 0, 6957, 6958, 3, 1434, 717, 0, 6958, 7124, 1, 0, 0, 0, 6959, 6960, 5, 138, 0, 0, 6960, 6962, 5, 376, 0, 0, 6961, 6963, 3, 748, 374, 0, 6962, 6961, 1, 0, 0, 0, 6962, 6963, 1, 0, 0, 0, 6963, 6964, 1, 0, 0, 0, 6964, 6965, 3, 1410, 705, 0, 6965, 6967, 5, 309, 0, 0, 6966, 6968, 5, 44, 0, 0, 6967, 6966, 1, 0, 0, 0, 6967, 6968, 1, 0, 0, 0, 6968, 6969, 1, 0, 0, 0, 6969, 6970, 3, 1432, 716, 0, 6970, 6971, 5, 94, 0, 0, 6971, 6972, 3, 1434, 717, 0, 6972, 7124, 1, 0, 0, 0, 6973, 6974, 5, 138, 0, 0, 6974, 6975, 5, 259, 0, 0, 6975, 6977, 5, 376, 0, 0, 6976, 6978, 3, 748, 374, 0, 6977, 6976, 1, 0, 0, 0, 6977, 6978, 1, 0, 0, 0, 6978, 6979, 1, 0, 0, 0, 6979, 6980, 3, 1410, 705, 0, 6980, 6982, 5, 309, 0, 0, 6981, 6983, 5, 44, 0, 0, 6982, 6981, 1, 0, 0, 0, 6982, 6983, 1, 0, 0, 0, 6983, 6984, 1, 0, 0, 0, 6984, 6985, 3, 1432, 716, 0, 6985, 6986, 5, 94, 0, 0, 6986, 6987, 3, 1434, 717, 0, 6987, 7124, 1, 0, 0, 0, 6988, 6989, 5, 138, 0, 0, 6989, 6991, 5, 92, 0, 0, 6990, 6992, 3, 748, 374, 0, 6991, 6990, 1, 0, 0, 0, 6991, 6992, 1, 0, 0, 0, 6992, 6993, 1, 0, 0, 0, 6993, 6994, 3, 1118, 559, 0, 6994, 6995, 5, 309, 0, 0, 6995, 6996, 5, 45, 0, 0, 6996, 6997, 3, 1436, 718, 0, 6997, 6998, 5, 94, 0, 0, 6998, 6999, 3, 1436, 718, 0, 6999, 7124, 1, 0, 0, 0, 7000, 7001, 5, 138, 0, 0, 7001, 7002, 5, 63, 0, 0, 7002, 7004, 5, 92, 0, 0, 7003, 7005, 3, 748, 374, 0, 7004, 7003, 1, 0, 0, 0, 7004, 7005, 1, 0, 0, 0, 7005, 7006, 1, 0, 0, 0, 7006, 7007, 3, 1118, 559, 0, 7007, 7009, 5, 309, 0, 0, 7008, 7010, 5, 44, 0, 0, 7009, 7008, 1, 0, 0, 0, 7009, 7010, 1, 0, 0, 0, 7010, 7011, 1, 0, 0, 0, 7011, 7012, 3, 1432, 716, 0, 7012, 7013, 5, 94, 0, 0, 7013, 7014, 3, 1434, 717, 0, 7014, 7124, 1, 0, 0, 0, 7015, 7016, 5, 138, 0, 0, 7016, 7017, 5, 321, 0, 0, 7017, 7018, 3, 1436, 718, 0, 7018, 7019, 5, 80, 0, 0, 7019, 7020, 3, 1412, 706, 0, 7020, 7021, 5, 309, 0, 0, 7021, 7022, 5, 94, 0, 0, 7022, 7023, 3, 1436, 718, 0, 7023, 7124, 1, 0, 0, 0, 7024, 7025, 5, 138, 0, 0, 7025, 7026, 5, 357, 0, 0, 7026, 7027, 3, 1436, 718, 0, 7027, 7028, 5, 80, 0, 0, 7028, 7029, 3, 1412, 706, 0, 7029, 7030, 5, 309, 0, 0, 7030, 7031, 5, 94, 0, 0, 7031, 7032, 3, 1436, 718, 0, 7032, 7124, 1, 0, 0, 0, 7033, 7034, 5, 138, 0, 0, 7034, 7035, 5, 198, 0, 0, 7035, 7036, 5, 357, 0, 0, 7036, 7037, 3, 1436, 718, 0, 7037, 7038, 5, 309, 0, 0, 7038, 7039, 5, 94, 0, 0, 7039, 7040, 3, 1436, 718, 0, 7040, 7124, 1, 0, 0, 0, 7041, 7042, 5, 138, 0, 0, 7042, 7043, 5, 318, 0, 0, 7043, 7044, 3, 1468, 734, 0, 7044, 7045, 5, 309, 0, 0, 7045, 7046, 5, 94, 0, 0, 7046, 7047, 3, 1468, 734, 0, 7047, 7124, 1, 0, 0, 0, 7048, 7049, 5, 138, 0, 0, 7049, 7050, 5, 99, 0, 0, 7050, 7051, 3, 1468, 734, 0, 7051, 7052, 5, 309, 0, 0, 7052, 7053, 5, 94, 0, 0, 7053, 7054, 3, 1468, 734, 0, 7054, 7124, 1, 0, 0, 0, 7055, 7056, 5, 138, 0, 0, 7056, 7057, 5, 351, 0, 0, 7057, 7058, 3, 1402, 701, 0, 7058, 7059, 5, 309, 0, 0, 7059, 7060, 5, 94, 0, 0, 7060, 7061, 3, 1400, 700, 0, 7061, 7124, 1, 0, 0, 0, 7062, 7063, 5, 138, 0, 0, 7063, 7064, 5, 342, 0, 0, 7064, 7065, 3, 558, 279, 0, 7065, 7066, 5, 309, 0, 0, 7066, 7067, 5, 94, 0, 0, 7067, 7068, 3, 1436, 718, 0, 7068, 7124, 1, 0, 0, 0, 7069, 7070, 5, 138, 0, 0, 7070, 7071, 5, 355, 0, 0, 7071, 7072, 5, 325, 0, 0, 7072, 7073, 5, 283, 0, 0, 7073, 7074, 3, 558, 279, 0, 7074, 7075, 5, 309, 0, 0, 7075, 7076, 5, 94, 0, 0, 7076, 7077, 3, 1436, 718, 0, 7077, 7124, 1, 0, 0, 0, 7078, 7079, 5, 138, 0, 0, 7079, 7080, 5, 355, 0, 0, 7080, 7081, 5, 325, 0, 0, 7081, 7082, 5, 185, 0, 0, 7082, 7083, 3, 558, 279, 0, 7083, 7084, 5, 309, 0, 0, 7084, 7085, 5, 94, 0, 0, 7085, 7086, 3, 1436, 718, 0, 7086, 7124, 1, 0, 0, 0, 7087, 7088, 5, 138, 0, 0, 7088, 7089, 5, 355, 0, 0, 7089, 7090, 5, 325, 0, 0, 7090, 7091, 5, 353, 0, 0, 7091, 7092, 3, 558, 279, 0, 7092, 7093, 5, 309, 0, 0, 7093, 7094, 5, 94, 0, 0, 7094, 7095, 3, 1436, 718, 0, 7095, 7124, 1, 0, 0, 0, 7096, 7097, 5, 138, 0, 0, 7097, 7098, 5, 355, 0, 0, 7098, 7099, 5, 325, 0, 0, 7099, 7100, 5, 163, 0, 0, 7100, 7101, 3, 558, 279, 0, 7101, 7102, 5, 309, 0, 0, 7102, 7103, 5, 94, 0, 0, 7103, 7104, 3, 1436, 718, 0, 7104, 7124, 1, 0, 0, 0, 7105, 7106, 5, 138, 0, 0, 7106, 7107, 5, 360, 0, 0, 7107, 7108, 3, 558, 279, 0, 7108, 7109, 5, 309, 0, 0, 7109, 7110, 5, 94, 0, 0, 7110, 7111, 3, 1436, 718, 0, 7111, 7124, 1, 0, 0, 0, 7112, 7113, 5, 138, 0, 0, 7113, 7114, 5, 360, 0, 0, 7114, 7115, 3, 558, 279, 0, 7115, 7116, 5, 309, 0, 0, 7116, 7117, 5, 143, 0, 0, 7117, 7118, 3, 1436, 718, 0, 7118, 7119, 5, 94, 0, 0, 7119, 7121, 3, 1436, 718, 0, 7120, 7122, 3, 124, 62, 0, 7121, 7120, 1, 0, 0, 0, 7121, 7122, 1, 0, 0, 0, 7122, 7124, 1, 0, 0, 0, 7123, 6732, 1, 0, 0, 0, 7123, 6739, 1, 0, 0, 0, 7123, 6746, 1, 0, 0, 0, 7123, 6753, 1, 0, 0, 0, 7123, 6760, 1, 0, 0, 0, 7123, 6767, 1, 0, 0, 0, 7123, 6776, 1, 0, 0, 0, 7123, 6785, 1, 0, 0, 0, 7123, 6792, 1, 0, 0, 0, 7123, 6799, 1, 0, 0, 0, 7123, 6809, 1, 0, 0, 0, 7123, 6819, 1, 0, 0, 0, 7123, 6829, 1, 0, 0, 0, 7123, 6841, 1, 0, 0, 0, 7123, 6848, 1, 0, 0, 0, 7123, 6855, 1, 0, 0, 0, 7123, 6862, 1, 0, 0, 0, 7123, 6869, 1, 0, 0, 0, 7123, 6876, 1, 0, 0, 0, 7123, 6883, 1, 0, 0, 0, 7123, 6893, 1, 0, 0, 0, 7123, 6903, 1, 0, 0, 0, 7123, 6913, 1, 0, 0, 0, 7123, 6924, 1, 0, 0, 0, 7123, 6934, 1, 0, 0, 0, 7123, 6945, 1, 0, 0, 0, 7123, 6959, 1, 0, 0, 0, 7123, 6973, 1, 0, 0, 0, 7123, 6988, 1, 0, 0, 0, 7123, 7000, 1, 0, 0, 0, 7123, 7015, 1, 0, 0, 0, 7123, 7024, 1, 0, 0, 0, 7123, 7033, 1, 0, 0, 0, 7123, 7041, 1, 0, 0, 0, 7123, 7048, 1, 0, 0, 0, 7123, 7055, 1, 0, 0, 0, 7123, 7062, 1, 0, 0, 0, 7123, 7069, 1, 0, 0, 0, 7123, 7078, 1, 0, 0, 0, 7123, 7087, 1, 0, 0, 0, 7123, 7096, 1, 0, 0, 0, 7123, 7105, 1, 0, 0, 0, 7123, 7112, 1, 0, 0, 0, 7124, 767, 1, 0, 0, 0, 7125, 7126, 5, 333, 0, 0, 7126, 7127, 5, 174, 0, 0, 7127, 769, 1, 0, 0, 0, 7128, 7129, 5, 138, 0, 0, 7129, 7130, 5, 211, 0, 0, 7130, 7132, 3, 674, 337, 0, 7131, 7133, 3, 772, 386, 0, 7132, 7131, 1, 0, 0, 0, 7132, 7133, 1, 0, 0, 0, 7133, 7134, 1, 0, 0, 0, 7134, 7135, 5, 462, 0, 0, 7135, 7136, 5, 80, 0, 0, 7136, 7137, 5, 204, 0, 0, 7137, 7138, 3, 1436, 718, 0, 7138, 7198, 1, 0, 0, 0, 7139, 7140, 5, 138, 0, 0, 7140, 7141, 5, 296, 0, 0, 7141, 7143, 3, 670, 335, 0, 7142, 7144, 3, 772, 386, 0, 7143, 7142, 1, 0, 0, 0, 7143, 7144, 1, 0, 0, 0, 7144, 7145, 1, 0, 0, 0, 7145, 7146, 5, 462, 0, 0, 7146, 7147, 5, 80, 0, 0, 7147, 7148, 5, 204, 0, 0, 7148, 7149, 3, 1436, 718, 0, 7149, 7198, 1, 0, 0, 0, 7150, 7151, 5, 138, 0, 0, 7151, 7152, 5, 442, 0, 0, 7152, 7154, 3, 666, 333, 0, 7153, 7155, 3, 772, 386, 0, 7154, 7153, 1, 0, 0, 0, 7154, 7155, 1, 0, 0, 0, 7155, 7156, 1, 0, 0, 0, 7156, 7157, 5, 462, 0, 0, 7157, 7158, 5, 80, 0, 0, 7158, 7159, 5, 204, 0, 0, 7159, 7160, 3, 1436, 718, 0, 7160, 7198, 1, 0, 0, 0, 7161, 7162, 5, 138, 0, 0, 7162, 7163, 5, 357, 0, 0, 7163, 7164, 3, 1436, 718, 0, 7164, 7165, 5, 80, 0, 0, 7165, 7167, 3, 1412, 706, 0, 7166, 7168, 3, 772, 386, 0, 7167, 7166, 1, 0, 0, 0, 7167, 7168, 1, 0, 0, 0, 7168, 7169, 1, 0, 0, 0, 7169, 7170, 5, 462, 0, 0, 7170, 7171, 5, 80, 0, 0, 7171, 7172, 5, 204, 0, 0, 7172, 7173, 3, 1436, 718, 0, 7173, 7198, 1, 0, 0, 0, 7174, 7175, 5, 138, 0, 0, 7175, 7176, 5, 259, 0, 0, 7176, 7177, 5, 376, 0, 0, 7177, 7179, 3, 1410, 705, 0, 7178, 7180, 3, 772, 386, 0, 7179, 7178, 1, 0, 0, 0, 7179, 7180, 1, 0, 0, 0, 7180, 7181, 1, 0, 0, 0, 7181, 7182, 5, 462, 0, 0, 7182, 7183, 5, 80, 0, 0, 7183, 7184, 5, 204, 0, 0, 7184, 7185, 3, 1436, 718, 0, 7185, 7198, 1, 0, 0, 0, 7186, 7187, 5, 138, 0, 0, 7187, 7188, 5, 226, 0, 0, 7188, 7190, 3, 1412, 706, 0, 7189, 7191, 3, 772, 386, 0, 7190, 7189, 1, 0, 0, 0, 7190, 7191, 1, 0, 0, 0, 7191, 7192, 1, 0, 0, 0, 7192, 7193, 5, 462, 0, 0, 7193, 7194, 5, 80, 0, 0, 7194, 7195, 5, 204, 0, 0, 7195, 7196, 3, 1436, 718, 0, 7196, 7198, 1, 0, 0, 0, 7197, 7128, 1, 0, 0, 0, 7197, 7139, 1, 0, 0, 0, 7197, 7150, 1, 0, 0, 0, 7197, 7161, 1, 0, 0, 0, 7197, 7174, 1, 0, 0, 0, 7197, 7186, 1, 0, 0, 0, 7198, 771, 1, 0, 0, 0, 7199, 7200, 5, 269, 0, 0, 7200, 773, 1, 0, 0, 0, 7201, 7202, 5, 138, 0, 0, 7202, 7203, 5, 136, 0, 0, 7203, 7204, 3, 698, 349, 0, 7204, 7205, 5, 333, 0, 0, 7205, 7206, 5, 323, 0, 0, 7206, 7207, 3, 1422, 711, 0, 7207, 7387, 1, 0, 0, 0, 7208, 7209, 5, 138, 0, 0, 7209, 7210, 5, 108, 0, 0, 7210, 7211, 3, 558, 279, 0, 7211, 7212, 5, 333, 0, 0, 7212, 7213, 5, 323, 0, 0, 7213, 7214, 3, 1422, 711, 0, 7214, 7387, 1, 0, 0, 0, 7215, 7216, 5, 138, 0, 0, 7216, 7217, 5, 168, 0, 0, 7217, 7218, 3, 558, 279, 0, 7218, 7219, 5, 333, 0, 0, 7219, 7220, 5, 323, 0, 0, 7220, 7221, 3, 1422, 711, 0, 7221, 7387, 1, 0, 0, 0, 7222, 7223, 5, 138, 0, 0, 7223, 7224, 5, 189, 0, 0, 7224, 7225, 3, 558, 279, 0, 7225, 7226, 5, 333, 0, 0, 7226, 7227, 5, 323, 0, 0, 7227, 7228, 3, 1422, 711, 0, 7228, 7387, 1, 0, 0, 0, 7229, 7230, 5, 138, 0, 0, 7230, 7231, 5, 204, 0, 0, 7231, 7232, 3, 1436, 718, 0, 7232, 7233, 5, 333, 0, 0, 7233, 7234, 5, 323, 0, 0, 7234, 7235, 3, 1422, 711, 0, 7235, 7387, 1, 0, 0, 0, 7236, 7237, 5, 138, 0, 0, 7237, 7238, 5, 211, 0, 0, 7238, 7239, 3, 674, 337, 0, 7239, 7240, 5, 333, 0, 0, 7240, 7241, 5, 323, 0, 0, 7241, 7242, 3, 1422, 711, 0, 7242, 7387, 1, 0, 0, 0, 7243, 7244, 5, 138, 0, 0, 7244, 7245, 5, 278, 0, 0, 7245, 7246, 3, 736, 368, 0, 7246, 7247, 5, 333, 0, 0, 7247, 7248, 5, 323, 0, 0, 7248, 7249, 3, 1422, 711, 0, 7249, 7387, 1, 0, 0, 0, 7250, 7251, 5, 138, 0, 0, 7251, 7252, 5, 278, 0, 0, 7252, 7253, 5, 156, 0, 0, 7253, 7254, 3, 558, 279, 0, 7254, 7255, 5, 100, 0, 0, 7255, 7256, 3, 1436, 718, 0, 7256, 7257, 5, 333, 0, 0, 7257, 7258, 5, 323, 0, 0, 7258, 7259, 3, 1422, 711, 0, 7259, 7387, 1, 0, 0, 0, 7260, 7261, 5, 138, 0, 0, 7261, 7262, 5, 278, 0, 0, 7262, 7263, 5, 206, 0, 0, 7263, 7264, 3, 558, 279, 0, 7264, 7265, 5, 100, 0, 0, 7265, 7266, 3, 1436, 718, 0, 7266, 7267, 5, 333, 0, 0, 7267, 7268, 5, 323, 0, 0, 7268, 7269, 3, 1422, 711, 0, 7269, 7387, 1, 0, 0, 0, 7270, 7271, 5, 138, 0, 0, 7271, 7272, 5, 296, 0, 0, 7272, 7273, 3, 670, 335, 0, 7273, 7274, 5, 333, 0, 0, 7274, 7275, 5, 323, 0, 0, 7275, 7276, 3, 1422, 711, 0, 7276, 7387, 1, 0, 0, 0, 7277, 7278, 5, 138, 0, 0, 7278, 7279, 5, 442, 0, 0, 7279, 7280, 3, 666, 333, 0, 7280, 7281, 5, 333, 0, 0, 7281, 7282, 5, 323, 0, 0, 7282, 7283, 3, 1422, 711, 0, 7283, 7387, 1, 0, 0, 0, 7284, 7285, 5, 138, 0, 0, 7285, 7287, 5, 92, 0, 0, 7286, 7288, 3, 748, 374, 0, 7287, 7286, 1, 0, 0, 0, 7287, 7288, 1, 0, 0, 0, 7288, 7289, 1, 0, 0, 0, 7289, 7290, 3, 1118, 559, 0, 7290, 7291, 5, 333, 0, 0, 7291, 7292, 5, 323, 0, 0, 7292, 7293, 3, 1422, 711, 0, 7293, 7387, 1, 0, 0, 0, 7294, 7295, 5, 138, 0, 0, 7295, 7296, 5, 342, 0, 0, 7296, 7297, 3, 558, 279, 0, 7297, 7298, 5, 333, 0, 0, 7298, 7299, 5, 323, 0, 0, 7299, 7300, 3, 1422, 711, 0, 7300, 7387, 1, 0, 0, 0, 7301, 7302, 5, 138, 0, 0, 7302, 7303, 5, 355, 0, 0, 7303, 7304, 5, 325, 0, 0, 7304, 7305, 5, 283, 0, 0, 7305, 7306, 3, 558, 279, 0, 7306, 7307, 5, 333, 0, 0, 7307, 7308, 5, 323, 0, 0, 7308, 7309, 3, 1422, 711, 0, 7309, 7387, 1, 0, 0, 0, 7310, 7311, 5, 138, 0, 0, 7311, 7312, 5, 355, 0, 0, 7312, 7313, 5, 325, 0, 0, 7313, 7314, 5, 185, 0, 0, 7314, 7315, 3, 558, 279, 0, 7315, 7316, 5, 333, 0, 0, 7316, 7317, 5, 323, 0, 0, 7317, 7318, 3, 1422, 711, 0, 7318, 7387, 1, 0, 0, 0, 7319, 7320, 5, 138, 0, 0, 7320, 7321, 5, 355, 0, 0, 7321, 7322, 5, 325, 0, 0, 7322, 7323, 5, 353, 0, 0, 7323, 7324, 3, 558, 279, 0, 7324, 7325, 5, 333, 0, 0, 7325, 7326, 5, 323, 0, 0, 7326, 7327, 3, 1422, 711, 0, 7327, 7387, 1, 0, 0, 0, 7328, 7329, 5, 138, 0, 0, 7329, 7330, 5, 355, 0, 0, 7330, 7331, 5, 325, 0, 0, 7331, 7332, 5, 163, 0, 0, 7332, 7333, 3, 558, 279, 0, 7333, 7334, 5, 333, 0, 0, 7334, 7335, 5, 323, 0, 0, 7335, 7336, 3, 1422, 711, 0, 7336, 7387, 1, 0, 0, 0, 7337, 7338, 5, 138, 0, 0, 7338, 7340, 5, 328, 0, 0, 7339, 7341, 3, 748, 374, 0, 7340, 7339, 1, 0, 0, 0, 7340, 7341, 1, 0, 0, 0, 7341, 7342, 1, 0, 0, 0, 7342, 7343, 3, 1412, 706, 0, 7343, 7344, 5, 333, 0, 0, 7344, 7345, 5, 323, 0, 0, 7345, 7346, 3, 1422, 711, 0, 7346, 7387, 1, 0, 0, 0, 7347, 7348, 5, 138, 0, 0, 7348, 7350, 5, 376, 0, 0, 7349, 7351, 3, 748, 374, 0, 7350, 7349, 1, 0, 0, 0, 7350, 7351, 1, 0, 0, 0, 7351, 7352, 1, 0, 0, 0, 7352, 7353, 3, 1410, 705, 0, 7353, 7354, 5, 333, 0, 0, 7354, 7355, 5, 323, 0, 0, 7355, 7356, 3, 1422, 711, 0, 7356, 7387, 1, 0, 0, 0, 7357, 7358, 5, 138, 0, 0, 7358, 7359, 5, 259, 0, 0, 7359, 7361, 5, 376, 0, 0, 7360, 7362, 3, 748, 374, 0, 7361, 7360, 1, 0, 0, 0, 7361, 7362, 1, 0, 0, 0, 7362, 7363, 1, 0, 0, 0, 7363, 7364, 3, 1410, 705, 0, 7364, 7365, 5, 333, 0, 0, 7365, 7366, 5, 323, 0, 0, 7366, 7367, 3, 1422, 711, 0, 7367, 7387, 1, 0, 0, 0, 7368, 7369, 5, 138, 0, 0, 7369, 7370, 5, 63, 0, 0, 7370, 7372, 5, 92, 0, 0, 7371, 7373, 3, 748, 374, 0, 7372, 7371, 1, 0, 0, 0, 7372, 7373, 1, 0, 0, 0, 7373, 7374, 1, 0, 0, 0, 7374, 7375, 3, 1118, 559, 0, 7375, 7376, 5, 333, 0, 0, 7376, 7377, 5, 323, 0, 0, 7377, 7378, 3, 1422, 711, 0, 7378, 7387, 1, 0, 0, 0, 7379, 7380, 5, 138, 0, 0, 7380, 7381, 5, 360, 0, 0, 7381, 7382, 3, 558, 279, 0, 7382, 7383, 5, 333, 0, 0, 7383, 7384, 5, 323, 0, 0, 7384, 7385, 3, 1422, 711, 0, 7385, 7387, 1, 0, 0, 0, 7386, 7201, 1, 0, 0, 0, 7386, 7208, 1, 0, 0, 0, 7386, 7215, 1, 0, 0, 0, 7386, 7222, 1, 0, 0, 0, 7386, 7229, 1, 0, 0, 0, 7386, 7236, 1, 0, 0, 0, 7386, 7243, 1, 0, 0, 0, 7386, 7250, 1, 0, 0, 0, 7386, 7260, 1, 0, 0, 0, 7386, 7270, 1, 0, 0, 0, 7386, 7277, 1, 0, 0, 0, 7386, 7284, 1, 0, 0, 0, 7386, 7294, 1, 0, 0, 0, 7386, 7301, 1, 0, 0, 0, 7386, 7310, 1, 0, 0, 0, 7386, 7319, 1, 0, 0, 0, 7386, 7328, 1, 0, 0, 0, 7386, 7337, 1, 0, 0, 0, 7386, 7347, 1, 0, 0, 0, 7386, 7357, 1, 0, 0, 0, 7386, 7368, 1, 0, 0, 0, 7386, 7379, 1, 0, 0, 0, 7387, 775, 1, 0, 0, 0, 7388, 7389, 5, 138, 0, 0, 7389, 7390, 5, 278, 0, 0, 7390, 7391, 3, 736, 368, 0, 7391, 7392, 5, 333, 0, 0, 7392, 7393, 5, 2, 0, 0, 7393, 7394, 3, 778, 389, 0, 7394, 7395, 5, 3, 0, 0, 7395, 777, 1, 0, 0, 0, 7396, 7401, 3, 780, 390, 0, 7397, 7398, 5, 6, 0, 0, 7398, 7400, 3, 780, 390, 0, 7399, 7397, 1, 0, 0, 0, 7400, 7403, 1, 0, 0, 0, 7401, 7399, 1, 0, 0, 0, 7401, 7402, 1, 0, 0, 0, 7402, 779, 1, 0, 0, 0, 7403, 7401, 1, 0, 0, 0, 7404, 7405, 3, 1490, 745, 0, 7405, 7406, 5, 10, 0, 0, 7406, 7407, 5, 407, 0, 0, 7407, 7413, 1, 0, 0, 0, 7408, 7409, 3, 1490, 745, 0, 7409, 7410, 5, 10, 0, 0, 7410, 7411, 3, 782, 391, 0, 7411, 7413, 1, 0, 0, 0, 7412, 7404, 1, 0, 0, 0, 7412, 7408, 1, 0, 0, 0, 7413, 781, 1, 0, 0, 0, 7414, 7420, 3, 688, 344, 0, 7415, 7420, 3, 1502, 751, 0, 7416, 7420, 3, 1324, 662, 0, 7417, 7420, 3, 322, 161, 0, 7418, 7420, 3, 1458, 729, 0, 7419, 7414, 1, 0, 0, 0, 7419, 7415, 1, 0, 0, 0, 7419, 7416, 1, 0, 0, 0, 7419, 7417, 1, 0, 0, 0, 7419, 7418, 1, 0, 0, 0, 7420, 783, 1, 0, 0, 0, 7421, 7422, 5, 138, 0, 0, 7422, 7423, 5, 360, 0, 0, 7423, 7424, 3, 558, 279, 0, 7424, 7425, 5, 333, 0, 0, 7425, 7426, 5, 2, 0, 0, 7426, 7427, 3, 778, 389, 0, 7427, 7428, 5, 3, 0, 0, 7428, 785, 1, 0, 0, 0, 7429, 7430, 5, 138, 0, 0, 7430, 7431, 5, 136, 0, 0, 7431, 7432, 3, 698, 349, 0, 7432, 7433, 5, 282, 0, 0, 7433, 7434, 5, 94, 0, 0, 7434, 7435, 3, 1470, 735, 0, 7435, 7615, 1, 0, 0, 0, 7436, 7437, 5, 138, 0, 0, 7437, 7438, 5, 108, 0, 0, 7438, 7439, 3, 558, 279, 0, 7439, 7440, 5, 282, 0, 0, 7440, 7441, 5, 94, 0, 0, 7441, 7442, 3, 1470, 735, 0, 7442, 7615, 1, 0, 0, 0, 7443, 7444, 5, 138, 0, 0, 7444, 7445, 5, 168, 0, 0, 7445, 7446, 3, 558, 279, 0, 7446, 7447, 5, 282, 0, 0, 7447, 7448, 5, 94, 0, 0, 7448, 7449, 3, 1470, 735, 0, 7449, 7615, 1, 0, 0, 0, 7450, 7451, 5, 138, 0, 0, 7451, 7452, 5, 175, 0, 0, 7452, 7453, 3, 1420, 710, 0, 7453, 7454, 5, 282, 0, 0, 7454, 7455, 5, 94, 0, 0, 7455, 7456, 3, 1470, 735, 0, 7456, 7615, 1, 0, 0, 0, 7457, 7458, 5, 138, 0, 0, 7458, 7459, 5, 189, 0, 0, 7459, 7460, 3, 558, 279, 0, 7460, 7461, 5, 282, 0, 0, 7461, 7462, 5, 94, 0, 0, 7462, 7463, 3, 1470, 735, 0, 7463, 7615, 1, 0, 0, 0, 7464, 7465, 5, 138, 0, 0, 7465, 7466, 5, 211, 0, 0, 7466, 7467, 3, 674, 337, 0, 7467, 7468, 5, 282, 0, 0, 7468, 7469, 5, 94, 0, 0, 7469, 7470, 3, 1470, 735, 0, 7470, 7615, 1, 0, 0, 0, 7471, 7473, 5, 138, 0, 0, 7472, 7474, 3, 338, 169, 0, 7473, 7472, 1, 0, 0, 0, 7473, 7474, 1, 0, 0, 0, 7474, 7475, 1, 0, 0, 0, 7475, 7476, 5, 247, 0, 0, 7476, 7477, 3, 1436, 718, 0, 7477, 7478, 5, 282, 0, 0, 7478, 7479, 5, 94, 0, 0, 7479, 7480, 3, 1470, 735, 0, 7480, 7615, 1, 0, 0, 0, 7481, 7482, 5, 138, 0, 0, 7482, 7483, 5, 248, 0, 0, 7483, 7484, 5, 274, 0, 0, 7484, 7485, 3, 322, 161, 0, 7485, 7486, 5, 282, 0, 0, 7486, 7487, 5, 94, 0, 0, 7487, 7488, 3, 1470, 735, 0, 7488, 7615, 1, 0, 0, 0, 7489, 7490, 5, 138, 0, 0, 7490, 7491, 5, 278, 0, 0, 7491, 7492, 3, 736, 368, 0, 7492, 7493, 5, 282, 0, 0, 7493, 7494, 5, 94, 0, 0, 7494, 7495, 3, 1470, 735, 0, 7495, 7615, 1, 0, 0, 0, 7496, 7497, 5, 138, 0, 0, 7497, 7498, 5, 278, 0, 0, 7498, 7499, 5, 156, 0, 0, 7499, 7500, 3, 558, 279, 0, 7500, 7501, 5, 100, 0, 0, 7501, 7502, 3, 1436, 718, 0, 7502, 7503, 5, 282, 0, 0, 7503, 7504, 5, 94, 0, 0, 7504, 7505, 3, 1470, 735, 0, 7505, 7615, 1, 0, 0, 0, 7506, 7507, 5, 138, 0, 0, 7507, 7508, 5, 278, 0, 0, 7508, 7509, 5, 206, 0, 0, 7509, 7510, 3, 558, 279, 0, 7510, 7511, 5, 100, 0, 0, 7511, 7512, 3, 1436, 718, 0, 7512, 7513, 5, 282, 0, 0, 7513, 7514, 5, 94, 0, 0, 7514, 7515, 3, 1470, 735, 0, 7515, 7615, 1, 0, 0, 0, 7516, 7517, 5, 138, 0, 0, 7517, 7518, 5, 296, 0, 0, 7518, 7519, 3, 670, 335, 0, 7519, 7520, 5, 282, 0, 0, 7520, 7521, 5, 94, 0, 0, 7521, 7522, 3, 1470, 735, 0, 7522, 7615, 1, 0, 0, 0, 7523, 7524, 5, 138, 0, 0, 7524, 7525, 5, 442, 0, 0, 7525, 7526, 3, 666, 333, 0, 7526, 7527, 5, 282, 0, 0, 7527, 7528, 5, 94, 0, 0, 7528, 7529, 3, 1470, 735, 0, 7529, 7615, 1, 0, 0, 0, 7530, 7531, 5, 138, 0, 0, 7531, 7532, 5, 323, 0, 0, 7532, 7533, 3, 1422, 711, 0, 7533, 7534, 5, 282, 0, 0, 7534, 7535, 5, 94, 0, 0, 7535, 7536, 3, 1470, 735, 0, 7536, 7615, 1, 0, 0, 0, 7537, 7538, 5, 138, 0, 0, 7538, 7539, 5, 360, 0, 0, 7539, 7540, 3, 558, 279, 0, 7540, 7541, 5, 282, 0, 0, 7541, 7542, 5, 94, 0, 0, 7542, 7543, 3, 1470, 735, 0, 7543, 7615, 1, 0, 0, 0, 7544, 7545, 5, 138, 0, 0, 7545, 7546, 5, 351, 0, 0, 7546, 7547, 3, 1402, 701, 0, 7547, 7548, 5, 282, 0, 0, 7548, 7549, 5, 94, 0, 0, 7549, 7550, 3, 1470, 735, 0, 7550, 7615, 1, 0, 0, 0, 7551, 7552, 5, 138, 0, 0, 7552, 7553, 5, 342, 0, 0, 7553, 7554, 3, 558, 279, 0, 7554, 7555, 5, 282, 0, 0, 7555, 7556, 5, 94, 0, 0, 7556, 7557, 3, 1470, 735, 0, 7557, 7615, 1, 0, 0, 0, 7558, 7559, 5, 138, 0, 0, 7559, 7560, 5, 355, 0, 0, 7560, 7561, 5, 325, 0, 0, 7561, 7562, 5, 185, 0, 0, 7562, 7563, 3, 558, 279, 0, 7563, 7564, 5, 282, 0, 0, 7564, 7565, 5, 94, 0, 0, 7565, 7566, 3, 1470, 735, 0, 7566, 7615, 1, 0, 0, 0, 7567, 7568, 5, 138, 0, 0, 7568, 7569, 5, 355, 0, 0, 7569, 7570, 5, 325, 0, 0, 7570, 7571, 5, 163, 0, 0, 7571, 7572, 3, 558, 279, 0, 7572, 7573, 5, 282, 0, 0, 7573, 7574, 5, 94, 0, 0, 7574, 7575, 3, 1470, 735, 0, 7575, 7615, 1, 0, 0, 0, 7576, 7577, 5, 138, 0, 0, 7577, 7578, 5, 63, 0, 0, 7578, 7579, 5, 174, 0, 0, 7579, 7580, 5, 381, 0, 0, 7580, 7581, 3, 1436, 718, 0, 7581, 7582, 5, 282, 0, 0, 7582, 7583, 5, 94, 0, 0, 7583, 7584, 3, 1470, 735, 0, 7584, 7615, 1, 0, 0, 0, 7585, 7586, 5, 138, 0, 0, 7586, 7587, 5, 331, 0, 0, 7587, 7588, 3, 1436, 718, 0, 7588, 7589, 5, 282, 0, 0, 7589, 7590, 5, 94, 0, 0, 7590, 7591, 3, 1470, 735, 0, 7591, 7615, 1, 0, 0, 0, 7592, 7593, 5, 138, 0, 0, 7593, 7594, 5, 198, 0, 0, 7594, 7595, 5, 357, 0, 0, 7595, 7596, 3, 1436, 718, 0, 7596, 7597, 5, 282, 0, 0, 7597, 7598, 5, 94, 0, 0, 7598, 7599, 3, 1470, 735, 0, 7599, 7615, 1, 0, 0, 0, 7600, 7601, 5, 138, 0, 0, 7601, 7602, 5, 452, 0, 0, 7602, 7603, 3, 1436, 718, 0, 7603, 7604, 5, 282, 0, 0, 7604, 7605, 5, 94, 0, 0, 7605, 7606, 3, 1470, 735, 0, 7606, 7615, 1, 0, 0, 0, 7607, 7608, 5, 138, 0, 0, 7608, 7609, 5, 451, 0, 0, 7609, 7610, 3, 1436, 718, 0, 7610, 7611, 5, 282, 0, 0, 7611, 7612, 5, 94, 0, 0, 7612, 7613, 3, 1470, 735, 0, 7613, 7615, 1, 0, 0, 0, 7614, 7429, 1, 0, 0, 0, 7614, 7436, 1, 0, 0, 0, 7614, 7443, 1, 0, 0, 0, 7614, 7450, 1, 0, 0, 0, 7614, 7457, 1, 0, 0, 0, 7614, 7464, 1, 0, 0, 0, 7614, 7471, 1, 0, 0, 0, 7614, 7481, 1, 0, 0, 0, 7614, 7489, 1, 0, 0, 0, 7614, 7496, 1, 0, 0, 0, 7614, 7506, 1, 0, 0, 0, 7614, 7516, 1, 0, 0, 0, 7614, 7523, 1, 0, 0, 0, 7614, 7530, 1, 0, 0, 0, 7614, 7537, 1, 0, 0, 0, 7614, 7544, 1, 0, 0, 0, 7614, 7551, 1, 0, 0, 0, 7614, 7558, 1, 0, 0, 0, 7614, 7567, 1, 0, 0, 0, 7614, 7576, 1, 0, 0, 0, 7614, 7585, 1, 0, 0, 0, 7614, 7592, 1, 0, 0, 0, 7614, 7600, 1, 0, 0, 0, 7614, 7607, 1, 0, 0, 0, 7615, 787, 1, 0, 0, 0, 7616, 7617, 5, 46, 0, 0, 7617, 7618, 5, 452, 0, 0, 7618, 7620, 3, 1436, 718, 0, 7619, 7621, 3, 790, 395, 0, 7620, 7619, 1, 0, 0, 0, 7620, 7621, 1, 0, 0, 0, 7621, 7623, 1, 0, 0, 0, 7622, 7624, 3, 710, 355, 0, 7623, 7622, 1, 0, 0, 0, 7623, 7624, 1, 0, 0, 0, 7624, 789, 1, 0, 0, 0, 7625, 7626, 3, 792, 396, 0, 7626, 791, 1, 0, 0, 0, 7627, 7628, 5, 62, 0, 0, 7628, 7629, 5, 92, 0, 0, 7629, 7634, 3, 1124, 562, 0, 7630, 7631, 5, 62, 0, 0, 7631, 7632, 5, 30, 0, 0, 7632, 7634, 5, 350, 0, 0, 7633, 7627, 1, 0, 0, 0, 7633, 7630, 1, 0, 0, 0, 7634, 793, 1, 0, 0, 0, 7635, 7636, 5, 138, 0, 0, 7636, 7637, 5, 452, 0, 0, 7637, 7638, 3, 1436, 718, 0, 7638, 7639, 5, 333, 0, 0, 7639, 7640, 3, 496, 248, 0, 7640, 7674, 1, 0, 0, 0, 7641, 7642, 5, 138, 0, 0, 7642, 7643, 5, 452, 0, 0, 7643, 7644, 3, 1436, 718, 0, 7644, 7645, 5, 133, 0, 0, 7645, 7646, 3, 1126, 563, 0, 7646, 7674, 1, 0, 0, 0, 7647, 7648, 5, 138, 0, 0, 7648, 7649, 5, 452, 0, 0, 7649, 7650, 3, 1436, 718, 0, 7650, 7651, 5, 333, 0, 0, 7651, 7652, 3, 1126, 563, 0, 7652, 7674, 1, 0, 0, 0, 7653, 7654, 5, 138, 0, 0, 7654, 7655, 5, 452, 0, 0, 7655, 7656, 3, 1436, 718, 0, 7656, 7657, 5, 191, 0, 0, 7657, 7658, 3, 1126, 563, 0, 7658, 7674, 1, 0, 0, 0, 7659, 7660, 5, 138, 0, 0, 7660, 7661, 5, 452, 0, 0, 7661, 7662, 3, 1436, 718, 0, 7662, 7663, 5, 282, 0, 0, 7663, 7664, 5, 94, 0, 0, 7664, 7665, 3, 1470, 735, 0, 7665, 7674, 1, 0, 0, 0, 7666, 7667, 5, 138, 0, 0, 7667, 7668, 5, 452, 0, 0, 7668, 7669, 3, 1436, 718, 0, 7669, 7670, 5, 309, 0, 0, 7670, 7671, 5, 94, 0, 0, 7671, 7672, 3, 1436, 718, 0, 7672, 7674, 1, 0, 0, 0, 7673, 7635, 1, 0, 0, 0, 7673, 7641, 1, 0, 0, 0, 7673, 7647, 1, 0, 0, 0, 7673, 7653, 1, 0, 0, 0, 7673, 7659, 1, 0, 0, 0, 7673, 7666, 1, 0, 0, 0, 7674, 795, 1, 0, 0, 0, 7675, 7676, 5, 46, 0, 0, 7676, 7677, 5, 451, 0, 0, 7677, 7678, 3, 1436, 718, 0, 7678, 7679, 5, 164, 0, 0, 7679, 7680, 3, 1458, 729, 0, 7680, 7681, 5, 452, 0, 0, 7681, 7683, 3, 798, 399, 0, 7682, 7684, 3, 710, 355, 0, 7683, 7682, 1, 0, 0, 0, 7683, 7684, 1, 0, 0, 0, 7684, 797, 1, 0, 0, 0, 7685, 7690, 3, 800, 400, 0, 7686, 7687, 5, 6, 0, 0, 7687, 7689, 3, 800, 400, 0, 7688, 7686, 1, 0, 0, 0, 7689, 7692, 1, 0, 0, 0, 7690, 7688, 1, 0, 0, 0, 7690, 7691, 1, 0, 0, 0, 7691, 799, 1, 0, 0, 0, 7692, 7690, 1, 0, 0, 0, 7693, 7694, 3, 1490, 745, 0, 7694, 801, 1, 0, 0, 0, 7695, 7696, 5, 138, 0, 0, 7696, 7697, 5, 451, 0, 0, 7697, 7698, 3, 1436, 718, 0, 7698, 7699, 5, 333, 0, 0, 7699, 7700, 3, 496, 248, 0, 7700, 7774, 1, 0, 0, 0, 7701, 7702, 5, 138, 0, 0, 7702, 7703, 5, 451, 0, 0, 7703, 7704, 3, 1436, 718, 0, 7704, 7705, 5, 164, 0, 0, 7705, 7706, 3, 1458, 729, 0, 7706, 7774, 1, 0, 0, 0, 7707, 7708, 5, 138, 0, 0, 7708, 7709, 5, 451, 0, 0, 7709, 7710, 3, 1436, 718, 0, 7710, 7711, 5, 305, 0, 0, 7711, 7713, 5, 452, 0, 0, 7712, 7714, 3, 710, 355, 0, 7713, 7712, 1, 0, 0, 0, 7713, 7714, 1, 0, 0, 0, 7714, 7774, 1, 0, 0, 0, 7715, 7716, 5, 138, 0, 0, 7716, 7717, 5, 451, 0, 0, 7717, 7718, 3, 1436, 718, 0, 7718, 7719, 5, 333, 0, 0, 7719, 7720, 5, 452, 0, 0, 7720, 7722, 3, 798, 399, 0, 7721, 7723, 3, 710, 355, 0, 7722, 7721, 1, 0, 0, 0, 7722, 7723, 1, 0, 0, 0, 7723, 7774, 1, 0, 0, 0, 7724, 7725, 5, 138, 0, 0, 7725, 7726, 5, 451, 0, 0, 7726, 7727, 3, 1436, 718, 0, 7727, 7728, 5, 133, 0, 0, 7728, 7729, 5, 452, 0, 0, 7729, 7731, 3, 798, 399, 0, 7730, 7732, 3, 710, 355, 0, 7731, 7730, 1, 0, 0, 0, 7731, 7732, 1, 0, 0, 0, 7732, 7774, 1, 0, 0, 0, 7733, 7734, 5, 138, 0, 0, 7734, 7735, 5, 451, 0, 0, 7735, 7736, 3, 1436, 718, 0, 7736, 7737, 5, 191, 0, 0, 7737, 7738, 5, 452, 0, 0, 7738, 7740, 3, 798, 399, 0, 7739, 7741, 3, 710, 355, 0, 7740, 7739, 1, 0, 0, 0, 7740, 7741, 1, 0, 0, 0, 7741, 7774, 1, 0, 0, 0, 7742, 7743, 5, 138, 0, 0, 7743, 7744, 5, 451, 0, 0, 7744, 7745, 3, 1436, 718, 0, 7745, 7746, 5, 193, 0, 0, 7746, 7774, 1, 0, 0, 0, 7747, 7748, 5, 138, 0, 0, 7748, 7749, 5, 451, 0, 0, 7749, 7750, 3, 1436, 718, 0, 7750, 7751, 5, 186, 0, 0, 7751, 7774, 1, 0, 0, 0, 7752, 7753, 5, 138, 0, 0, 7753, 7754, 5, 451, 0, 0, 7754, 7755, 3, 1436, 718, 0, 7755, 7756, 5, 333, 0, 0, 7756, 7757, 3, 496, 248, 0, 7757, 7774, 1, 0, 0, 0, 7758, 7759, 5, 138, 0, 0, 7759, 7760, 5, 451, 0, 0, 7760, 7761, 3, 1436, 718, 0, 7761, 7762, 5, 465, 0, 0, 7762, 7763, 5, 2, 0, 0, 7763, 7764, 3, 508, 254, 0, 7764, 7765, 5, 3, 0, 0, 7765, 7774, 1, 0, 0, 0, 7766, 7767, 5, 138, 0, 0, 7767, 7768, 5, 451, 0, 0, 7768, 7769, 3, 1436, 718, 0, 7769, 7770, 5, 282, 0, 0, 7770, 7771, 5, 94, 0, 0, 7771, 7772, 3, 1470, 735, 0, 7772, 7774, 1, 0, 0, 0, 7773, 7695, 1, 0, 0, 0, 7773, 7701, 1, 0, 0, 0, 7773, 7707, 1, 0, 0, 0, 7773, 7715, 1, 0, 0, 0, 7773, 7724, 1, 0, 0, 0, 7773, 7733, 1, 0, 0, 0, 7773, 7742, 1, 0, 0, 0, 7773, 7747, 1, 0, 0, 0, 7773, 7752, 1, 0, 0, 0, 7773, 7758, 1, 0, 0, 0, 7773, 7766, 1, 0, 0, 0, 7774, 803, 1, 0, 0, 0, 7775, 7777, 5, 46, 0, 0, 7776, 7778, 3, 658, 329, 0, 7777, 7776, 1, 0, 0, 0, 7777, 7778, 1, 0, 0, 0, 7778, 7779, 1, 0, 0, 0, 7779, 7780, 5, 321, 0, 0, 7780, 7781, 3, 1436, 718, 0, 7781, 7782, 5, 36, 0, 0, 7782, 7783, 5, 80, 0, 0, 7783, 7784, 3, 814, 407, 0, 7784, 7785, 5, 94, 0, 0, 7785, 7787, 3, 1412, 706, 0, 7786, 7788, 3, 1144, 572, 0, 7787, 7786, 1, 0, 0, 0, 7787, 7788, 1, 0, 0, 0, 7788, 7789, 1, 0, 0, 0, 7789, 7791, 5, 57, 0, 0, 7790, 7792, 3, 816, 408, 0, 7791, 7790, 1, 0, 0, 0, 7791, 7792, 1, 0, 0, 0, 7792, 7793, 1, 0, 0, 0, 7793, 7794, 3, 806, 403, 0, 7794, 805, 1, 0, 0, 0, 7795, 7802, 5, 270, 0, 0, 7796, 7802, 3, 810, 405, 0, 7797, 7798, 5, 2, 0, 0, 7798, 7799, 3, 808, 404, 0, 7799, 7800, 5, 3, 0, 0, 7800, 7802, 1, 0, 0, 0, 7801, 7795, 1, 0, 0, 0, 7801, 7796, 1, 0, 0, 0, 7801, 7797, 1, 0, 0, 0, 7802, 807, 1, 0, 0, 0, 7803, 7805, 3, 812, 406, 0, 7804, 7803, 1, 0, 0, 0, 7804, 7805, 1, 0, 0, 0, 7805, 7812, 1, 0, 0, 0, 7806, 7808, 5, 7, 0, 0, 7807, 7809, 3, 812, 406, 0, 7808, 7807, 1, 0, 0, 0, 7808, 7809, 1, 0, 0, 0, 7809, 7811, 1, 0, 0, 0, 7810, 7806, 1, 0, 0, 0, 7811, 7814, 1, 0, 0, 0, 7812, 7810, 1, 0, 0, 0, 7812, 7813, 1, 0, 0, 0, 7813, 809, 1, 0, 0, 0, 7814, 7812, 1, 0, 0, 0, 7815, 7821, 3, 1000, 500, 0, 7816, 7821, 3, 950, 475, 0, 7817, 7821, 3, 982, 491, 0, 7818, 7821, 3, 968, 484, 0, 7819, 7821, 3, 818, 409, 0, 7820, 7815, 1, 0, 0, 0, 7820, 7816, 1, 0, 0, 0, 7820, 7817, 1, 0, 0, 0, 7820, 7818, 1, 0, 0, 0, 7820, 7819, 1, 0, 0, 0, 7821, 811, 1, 0, 0, 0, 7822, 7823, 3, 810, 405, 0, 7823, 813, 1, 0, 0, 0, 7824, 7825, 7, 47, 0, 0, 7825, 815, 1, 0, 0, 0, 7826, 7827, 7, 48, 0, 0, 7827, 817, 1, 0, 0, 0, 7828, 7829, 5, 271, 0, 0, 7829, 7831, 3, 1474, 737, 0, 7830, 7832, 3, 820, 410, 0, 7831, 7830, 1, 0, 0, 0, 7831, 7832, 1, 0, 0, 0, 7832, 819, 1, 0, 0, 0, 7833, 7834, 5, 6, 0, 0, 7834, 7835, 3, 1458, 729, 0, 7835, 821, 1, 0, 0, 0, 7836, 7837, 5, 252, 0, 0, 7837, 7838, 3, 1474, 737, 0, 7838, 823, 1, 0, 0, 0, 7839, 7840, 5, 366, 0, 0, 7840, 7844, 3, 1474, 737, 0, 7841, 7842, 5, 366, 0, 0, 7842, 7844, 5, 9, 0, 0, 7843, 7839, 1, 0, 0, 0, 7843, 7841, 1, 0, 0, 0, 7844, 825, 1, 0, 0, 0, 7845, 7847, 5, 129, 0, 0, 7846, 7848, 3, 828, 414, 0, 7847, 7846, 1, 0, 0, 0, 7847, 7848, 1, 0, 0, 0, 7848, 7850, 1, 0, 0, 0, 7849, 7851, 3, 836, 418, 0, 7850, 7849, 1, 0, 0, 0, 7850, 7851, 1, 0, 0, 0, 7851, 7911, 1, 0, 0, 0, 7852, 7854, 5, 146, 0, 0, 7853, 7855, 3, 828, 414, 0, 7854, 7853, 1, 0, 0, 0, 7854, 7855, 1, 0, 0, 0, 7855, 7857, 1, 0, 0, 0, 7856, 7858, 3, 834, 417, 0, 7857, 7856, 1, 0, 0, 0, 7857, 7858, 1, 0, 0, 0, 7858, 7911, 1, 0, 0, 0, 7859, 7860, 5, 340, 0, 0, 7860, 7862, 5, 356, 0, 0, 7861, 7863, 3, 834, 417, 0, 7862, 7861, 1, 0, 0, 0, 7862, 7863, 1, 0, 0, 0, 7863, 7911, 1, 0, 0, 0, 7864, 7866, 5, 454, 0, 0, 7865, 7867, 3, 828, 414, 0, 7866, 7865, 1, 0, 0, 0, 7866, 7867, 1, 0, 0, 0, 7867, 7869, 1, 0, 0, 0, 7868, 7870, 3, 836, 418, 0, 7869, 7868, 1, 0, 0, 0, 7869, 7870, 1, 0, 0, 0, 7870, 7911, 1, 0, 0, 0, 7871, 7872, 5, 322, 0, 0, 7872, 7911, 3, 1474, 737, 0, 7873, 7875, 5, 308, 0, 0, 7874, 7876, 5, 322, 0, 0, 7875, 7874, 1, 0, 0, 0, 7875, 7876, 1, 0, 0, 0, 7876, 7877, 1, 0, 0, 0, 7877, 7911, 3, 1474, 737, 0, 7878, 7879, 5, 290, 0, 0, 7879, 7880, 5, 356, 0, 0, 7880, 7911, 3, 1458, 729, 0, 7881, 7882, 5, 161, 0, 0, 7882, 7883, 5, 291, 0, 0, 7883, 7911, 3, 1458, 729, 0, 7884, 7886, 5, 161, 0, 0, 7885, 7887, 3, 828, 414, 0, 7886, 7885, 1, 0, 0, 0, 7886, 7887, 1, 0, 0, 0, 7887, 7889, 1, 0, 0, 0, 7888, 7890, 3, 836, 418, 0, 7889, 7888, 1, 0, 0, 0, 7889, 7890, 1, 0, 0, 0, 7890, 7911, 1, 0, 0, 0, 7891, 7892, 5, 319, 0, 0, 7892, 7893, 5, 291, 0, 0, 7893, 7911, 3, 1458, 729, 0, 7894, 7896, 5, 319, 0, 0, 7895, 7897, 3, 828, 414, 0, 7896, 7895, 1, 0, 0, 0, 7896, 7897, 1, 0, 0, 0, 7897, 7898, 1, 0, 0, 0, 7898, 7900, 5, 94, 0, 0, 7899, 7901, 5, 322, 0, 0, 7900, 7899, 1, 0, 0, 0, 7900, 7901, 1, 0, 0, 0, 7901, 7902, 1, 0, 0, 0, 7902, 7911, 3, 1474, 737, 0, 7903, 7905, 5, 319, 0, 0, 7904, 7906, 3, 828, 414, 0, 7905, 7904, 1, 0, 0, 0, 7905, 7906, 1, 0, 0, 0, 7906, 7908, 1, 0, 0, 0, 7907, 7909, 3, 836, 418, 0, 7908, 7907, 1, 0, 0, 0, 7908, 7909, 1, 0, 0, 0, 7909, 7911, 1, 0, 0, 0, 7910, 7845, 1, 0, 0, 0, 7910, 7852, 1, 0, 0, 0, 7910, 7859, 1, 0, 0, 0, 7910, 7864, 1, 0, 0, 0, 7910, 7871, 1, 0, 0, 0, 7910, 7873, 1, 0, 0, 0, 7910, 7878, 1, 0, 0, 0, 7910, 7881, 1, 0, 0, 0, 7910, 7884, 1, 0, 0, 0, 7910, 7891, 1, 0, 0, 0, 7910, 7894, 1, 0, 0, 0, 7910, 7903, 1, 0, 0, 0, 7911, 827, 1, 0, 0, 0, 7912, 7913, 7, 49, 0, 0, 7913, 829, 1, 0, 0, 0, 7914, 7915, 5, 244, 0, 0, 7915, 7916, 5, 251, 0, 0, 7916, 7925, 3, 68, 34, 0, 7917, 7918, 5, 300, 0, 0, 7918, 7925, 5, 81, 0, 0, 7919, 7920, 5, 300, 0, 0, 7920, 7925, 5, 382, 0, 0, 7921, 7925, 5, 54, 0, 0, 7922, 7923, 5, 77, 0, 0, 7923, 7925, 5, 54, 0, 0, 7924, 7914, 1, 0, 0, 0, 7924, 7917, 1, 0, 0, 0, 7924, 7919, 1, 0, 0, 0, 7924, 7921, 1, 0, 0, 0, 7924, 7922, 1, 0, 0, 0, 7925, 831, 1, 0, 0, 0, 7926, 7933, 3, 830, 415, 0, 7927, 7929, 5, 6, 0, 0, 7928, 7927, 1, 0, 0, 0, 7928, 7929, 1, 0, 0, 0, 7929, 7930, 1, 0, 0, 0, 7930, 7932, 3, 830, 415, 0, 7931, 7928, 1, 0, 0, 0, 7932, 7935, 1, 0, 0, 0, 7933, 7931, 1, 0, 0, 0, 7933, 7934, 1, 0, 0, 0, 7934, 833, 1, 0, 0, 0, 7935, 7933, 1, 0, 0, 0, 7936, 7937, 3, 832, 416, 0, 7937, 835, 1, 0, 0, 0, 7938, 7940, 5, 33, 0, 0, 7939, 7941, 5, 269, 0, 0, 7940, 7939, 1, 0, 0, 0, 7940, 7941, 1, 0, 0, 0, 7941, 7942, 1, 0, 0, 0, 7942, 7943, 5, 153, 0, 0, 7943, 837, 1, 0, 0, 0, 7944, 7947, 5, 46, 0, 0, 7945, 7946, 5, 82, 0, 0, 7946, 7948, 5, 311, 0, 0, 7947, 7945, 1, 0, 0, 0, 7947, 7948, 1, 0, 0, 0, 7948, 7950, 1, 0, 0, 0, 7949, 7951, 3, 190, 95, 0, 7950, 7949, 1, 0, 0, 0, 7950, 7951, 1, 0, 0, 0, 7951, 7969, 1, 0, 0, 0, 7952, 7953, 5, 376, 0, 0, 7953, 7955, 3, 1408, 704, 0, 7954, 7956, 3, 242, 121, 0, 7955, 7954, 1, 0, 0, 0, 7955, 7956, 1, 0, 0, 0, 7956, 7958, 1, 0, 0, 0, 7957, 7959, 3, 134, 67, 0, 7958, 7957, 1, 0, 0, 0, 7958, 7959, 1, 0, 0, 0, 7959, 7970, 1, 0, 0, 0, 7960, 7961, 5, 303, 0, 0, 7961, 7962, 5, 376, 0, 0, 7962, 7963, 3, 1408, 704, 0, 7963, 7964, 5, 2, 0, 0, 7964, 7965, 3, 244, 122, 0, 7965, 7967, 5, 3, 0, 0, 7966, 7968, 3, 134, 67, 0, 7967, 7966, 1, 0, 0, 0, 7967, 7968, 1, 0, 0, 0, 7968, 7970, 1, 0, 0, 0, 7969, 7952, 1, 0, 0, 0, 7969, 7960, 1, 0, 0, 0, 7970, 7971, 1, 0, 0, 0, 7971, 7972, 5, 36, 0, 0, 7972, 7974, 3, 1000, 500, 0, 7973, 7975, 3, 840, 420, 0, 7974, 7973, 1, 0, 0, 0, 7974, 7975, 1, 0, 0, 0, 7975, 839, 1, 0, 0, 0, 7976, 7978, 5, 105, 0, 0, 7977, 7979, 7, 50, 0, 0, 7978, 7977, 1, 0, 0, 0, 7978, 7979, 1, 0, 0, 0, 7979, 7980, 1, 0, 0, 0, 7980, 7981, 5, 42, 0, 0, 7981, 7982, 5, 279, 0, 0, 7982, 841, 1, 0, 0, 0, 7983, 7984, 5, 253, 0, 0, 7984, 7985, 3, 1440, 720, 0, 7985, 843, 1, 0, 0, 0, 7986, 7987, 5, 46, 0, 0, 7987, 7988, 5, 175, 0, 0, 7988, 7990, 3, 1418, 709, 0, 7989, 7991, 3, 14, 7, 0, 7990, 7989, 1, 0, 0, 0, 7990, 7991, 1, 0, 0, 0, 7991, 7993, 1, 0, 0, 0, 7992, 7994, 3, 846, 423, 0, 7993, 7992, 1, 0, 0, 0, 7993, 7994, 1, 0, 0, 0, 7994, 845, 1, 0, 0, 0, 7995, 7996, 3, 848, 424, 0, 7996, 847, 1, 0, 0, 0, 7997, 7999, 3, 850, 425, 0, 7998, 7997, 1, 0, 0, 0, 7999, 8000, 1, 0, 0, 0, 8000, 7998, 1, 0, 0, 0, 8000, 8001, 1, 0, 0, 0, 8001, 849, 1, 0, 0, 0, 8002, 8004, 3, 852, 426, 0, 8003, 8005, 3, 854, 427, 0, 8004, 8003, 1, 0, 0, 0, 8004, 8005, 1, 0, 0, 0, 8005, 8009, 1, 0, 0, 0, 8006, 8010, 3, 1464, 732, 0, 8007, 8010, 3, 72, 36, 0, 8008, 8010, 5, 53, 0, 0, 8009, 8006, 1, 0, 0, 0, 8009, 8007, 1, 0, 0, 0, 8009, 8008, 1, 0, 0, 0, 8010, 851, 1, 0, 0, 0, 8011, 8012, 5, 164, 0, 0, 8012, 8020, 5, 74, 0, 0, 8013, 8020, 5, 194, 0, 0, 8014, 8020, 5, 255, 0, 0, 8015, 8020, 5, 282, 0, 0, 8016, 8020, 5, 351, 0, 0, 8017, 8020, 5, 353, 0, 0, 8018, 8020, 3, 1492, 746, 0, 8019, 8011, 1, 0, 0, 0, 8019, 8013, 1, 0, 0, 0, 8019, 8014, 1, 0, 0, 0, 8019, 8015, 1, 0, 0, 0, 8019, 8016, 1, 0, 0, 0, 8019, 8017, 1, 0, 0, 0, 8019, 8018, 1, 0, 0, 0, 8020, 853, 1, 0, 0, 0, 8021, 8022, 5, 10, 0, 0, 8022, 855, 1, 0, 0, 0, 8023, 8024, 5, 138, 0, 0, 8024, 8025, 5, 175, 0, 0, 8025, 8037, 3, 1420, 710, 0, 8026, 8027, 5, 333, 0, 0, 8027, 8028, 5, 351, 0, 0, 8028, 8030, 3, 1400, 700, 0, 8029, 8026, 1, 0, 0, 0, 8029, 8030, 1, 0, 0, 0, 8030, 8038, 1, 0, 0, 0, 8031, 8033, 5, 105, 0, 0, 8032, 8031, 1, 0, 0, 0, 8032, 8033, 1, 0, 0, 0, 8033, 8034, 1, 0, 0, 0, 8034, 8036, 3, 846, 423, 0, 8035, 8032, 1, 0, 0, 0, 8035, 8036, 1, 0, 0, 0, 8036, 8038, 1, 0, 0, 0, 8037, 8029, 1, 0, 0, 0, 8037, 8035, 1, 0, 0, 0, 8038, 857, 1, 0, 0, 0, 8039, 8040, 5, 138, 0, 0, 8040, 8041, 5, 175, 0, 0, 8041, 8043, 3, 1420, 710, 0, 8042, 8044, 3, 88, 44, 0, 8043, 8042, 1, 0, 0, 0, 8043, 8044, 1, 0, 0, 0, 8044, 859, 1, 0, 0, 0, 8045, 8050, 3, 862, 431, 0, 8046, 8047, 5, 6, 0, 0, 8047, 8049, 3, 862, 431, 0, 8048, 8046, 1, 0, 0, 0, 8049, 8052, 1, 0, 0, 0, 8050, 8048, 1, 0, 0, 0, 8050, 8051, 1, 0, 0, 0, 8051, 861, 1, 0, 0, 0, 8052, 8050, 1, 0, 0, 0, 8053, 8054, 5, 209, 0, 0, 8054, 863, 1, 0, 0, 0, 8055, 8056, 5, 138, 0, 0, 8056, 8057, 5, 108, 0, 0, 8057, 8058, 3, 558, 279, 0, 8058, 8059, 5, 305, 0, 0, 8059, 8060, 5, 375, 0, 0, 8060, 865, 1, 0, 0, 0, 8061, 8062, 5, 138, 0, 0, 8062, 8063, 5, 349, 0, 0, 8063, 8064, 7, 22, 0, 0, 8064, 8065, 3, 58, 29, 0, 8065, 867, 1, 0, 0, 0, 8066, 8067, 5, 46, 0, 0, 8067, 8068, 5, 189, 0, 0, 8068, 8070, 3, 558, 279, 0, 8069, 8071, 3, 872, 436, 0, 8070, 8069, 1, 0, 0, 0, 8070, 8071, 1, 0, 0, 0, 8071, 8072, 1, 0, 0, 0, 8072, 8073, 3, 1168, 584, 0, 8073, 8074, 3, 214, 107, 0, 8074, 869, 1, 0, 0, 0, 8075, 8076, 5, 138, 0, 0, 8076, 8077, 5, 189, 0, 0, 8077, 8099, 3, 558, 279, 0, 8078, 8100, 3, 122, 61, 0, 8079, 8080, 5, 191, 0, 0, 8080, 8081, 5, 77, 0, 0, 8081, 8100, 5, 78, 0, 0, 8082, 8083, 5, 333, 0, 0, 8083, 8084, 5, 77, 0, 0, 8084, 8100, 5, 78, 0, 0, 8085, 8086, 5, 133, 0, 0, 8086, 8100, 3, 234, 117, 0, 8087, 8088, 5, 191, 0, 0, 8088, 8090, 5, 45, 0, 0, 8089, 8091, 3, 748, 374, 0, 8090, 8089, 1, 0, 0, 0, 8090, 8091, 1, 0, 0, 0, 8091, 8092, 1, 0, 0, 0, 8092, 8094, 3, 1436, 718, 0, 8093, 8095, 3, 124, 62, 0, 8094, 8093, 1, 0, 0, 0, 8094, 8095, 1, 0, 0, 0, 8095, 8100, 1, 0, 0, 0, 8096, 8097, 5, 372, 0, 0, 8097, 8098, 5, 45, 0, 0, 8098, 8100, 3, 1436, 718, 0, 8099, 8078, 1, 0, 0, 0, 8099, 8079, 1, 0, 0, 0, 8099, 8082, 1, 0, 0, 0, 8099, 8085, 1, 0, 0, 0, 8099, 8087, 1, 0, 0, 0, 8099, 8096, 1, 0, 0, 0, 8100, 871, 1, 0, 0, 0, 8101, 8102, 5, 36, 0, 0, 8102, 873, 1, 0, 0, 0, 8103, 8104, 5, 138, 0, 0, 8104, 8105, 5, 355, 0, 0, 8105, 8106, 5, 325, 0, 0, 8106, 8107, 5, 185, 0, 0, 8107, 8108, 3, 558, 279, 0, 8108, 8109, 3, 496, 248, 0, 8109, 875, 1, 0, 0, 0, 8110, 8111, 5, 138, 0, 0, 8111, 8112, 5, 355, 0, 0, 8112, 8113, 5, 325, 0, 0, 8113, 8114, 5, 163, 0, 0, 8114, 8115, 3, 558, 279, 0, 8115, 8116, 5, 133, 0, 0, 8116, 8117, 5, 257, 0, 0, 8117, 8118, 5, 62, 0, 0, 8118, 8119, 3, 1416, 708, 0, 8119, 8120, 3, 878, 439, 0, 8120, 8121, 3, 552, 276, 0, 8121, 8174, 1, 0, 0, 0, 8122, 8123, 5, 138, 0, 0, 8123, 8124, 5, 355, 0, 0, 8124, 8125, 5, 325, 0, 0, 8125, 8126, 5, 163, 0, 0, 8126, 8127, 3, 558, 279, 0, 8127, 8128, 5, 138, 0, 0, 8128, 8129, 5, 257, 0, 0, 8129, 8130, 5, 62, 0, 0, 8130, 8131, 3, 1416, 708, 0, 8131, 8132, 3, 878, 439, 0, 8132, 8133, 3, 552, 276, 0, 8133, 8174, 1, 0, 0, 0, 8134, 8135, 5, 138, 0, 0, 8135, 8136, 5, 355, 0, 0, 8136, 8137, 5, 325, 0, 0, 8137, 8138, 5, 163, 0, 0, 8138, 8139, 3, 558, 279, 0, 8139, 8140, 5, 138, 0, 0, 8140, 8141, 5, 257, 0, 0, 8141, 8142, 5, 311, 0, 0, 8142, 8143, 3, 558, 279, 0, 8143, 8144, 3, 878, 439, 0, 8144, 8145, 3, 558, 279, 0, 8145, 8174, 1, 0, 0, 0, 8146, 8147, 5, 138, 0, 0, 8147, 8148, 5, 355, 0, 0, 8148, 8149, 5, 325, 0, 0, 8149, 8150, 5, 163, 0, 0, 8150, 8151, 3, 558, 279, 0, 8151, 8152, 5, 138, 0, 0, 8152, 8153, 5, 257, 0, 0, 8153, 8154, 5, 62, 0, 0, 8154, 8155, 3, 1416, 708, 0, 8155, 8156, 5, 311, 0, 0, 8156, 8157, 3, 558, 279, 0, 8157, 8158, 3, 878, 439, 0, 8158, 8159, 3, 558, 279, 0, 8159, 8174, 1, 0, 0, 0, 8160, 8161, 5, 138, 0, 0, 8161, 8162, 5, 355, 0, 0, 8162, 8163, 5, 325, 0, 0, 8163, 8164, 5, 163, 0, 0, 8164, 8165, 3, 558, 279, 0, 8165, 8166, 5, 191, 0, 0, 8166, 8168, 5, 257, 0, 0, 8167, 8169, 3, 748, 374, 0, 8168, 8167, 1, 0, 0, 0, 8168, 8169, 1, 0, 0, 0, 8169, 8170, 1, 0, 0, 0, 8170, 8171, 5, 62, 0, 0, 8171, 8172, 3, 1416, 708, 0, 8172, 8174, 1, 0, 0, 0, 8173, 8110, 1, 0, 0, 0, 8173, 8122, 1, 0, 0, 0, 8173, 8134, 1, 0, 0, 0, 8173, 8146, 1, 0, 0, 0, 8173, 8160, 1, 0, 0, 0, 8174, 877, 1, 0, 0, 0, 8175, 8176, 5, 105, 0, 0, 8176, 879, 1, 0, 0, 0, 8177, 8179, 5, 46, 0, 0, 8178, 8180, 3, 524, 262, 0, 8179, 8178, 1, 0, 0, 0, 8179, 8180, 1, 0, 0, 0, 8180, 8181, 1, 0, 0, 0, 8181, 8182, 5, 168, 0, 0, 8182, 8183, 3, 558, 279, 0, 8183, 8184, 5, 62, 0, 0, 8184, 8185, 3, 1458, 729, 0, 8185, 8186, 5, 94, 0, 0, 8186, 8187, 3, 1458, 729, 0, 8187, 8188, 5, 64, 0, 0, 8188, 8189, 3, 558, 279, 0, 8189, 881, 1, 0, 0, 0, 8190, 8192, 5, 158, 0, 0, 8191, 8193, 3, 908, 454, 0, 8192, 8191, 1, 0, 0, 0, 8192, 8193, 1, 0, 0, 0, 8193, 8194, 1, 0, 0, 0, 8194, 8196, 3, 1406, 703, 0, 8195, 8197, 3, 886, 443, 0, 8196, 8195, 1, 0, 0, 0, 8196, 8197, 1, 0, 0, 0, 8197, 8209, 1, 0, 0, 0, 8198, 8200, 5, 158, 0, 0, 8199, 8201, 3, 908, 454, 0, 8200, 8199, 1, 0, 0, 0, 8200, 8201, 1, 0, 0, 0, 8201, 8209, 1, 0, 0, 0, 8202, 8203, 5, 158, 0, 0, 8203, 8204, 3, 884, 442, 0, 8204, 8206, 3, 1406, 703, 0, 8205, 8207, 3, 886, 443, 0, 8206, 8205, 1, 0, 0, 0, 8206, 8207, 1, 0, 0, 0, 8207, 8209, 1, 0, 0, 0, 8208, 8190, 1, 0, 0, 0, 8208, 8198, 1, 0, 0, 0, 8208, 8202, 1, 0, 0, 0, 8209, 883, 1, 0, 0, 0, 8210, 8211, 5, 2, 0, 0, 8211, 8216, 3, 908, 454, 0, 8212, 8213, 5, 6, 0, 0, 8213, 8215, 3, 908, 454, 0, 8214, 8212, 1, 0, 0, 0, 8215, 8218, 1, 0, 0, 0, 8216, 8214, 1, 0, 0, 0, 8216, 8217, 1, 0, 0, 0, 8217, 8219, 1, 0, 0, 0, 8218, 8216, 1, 0, 0, 0, 8219, 8220, 5, 3, 0, 0, 8220, 885, 1, 0, 0, 0, 8221, 8222, 5, 100, 0, 0, 8222, 8223, 3, 1436, 718, 0, 8223, 887, 1, 0, 0, 0, 8224, 8226, 5, 370, 0, 0, 8225, 8227, 3, 914, 457, 0, 8226, 8225, 1, 0, 0, 0, 8226, 8227, 1, 0, 0, 0, 8227, 8229, 1, 0, 0, 0, 8228, 8230, 3, 916, 458, 0, 8229, 8228, 1, 0, 0, 0, 8229, 8230, 1, 0, 0, 0, 8230, 8232, 1, 0, 0, 0, 8231, 8233, 3, 908, 454, 0, 8232, 8231, 1, 0, 0, 0, 8232, 8233, 1, 0, 0, 0, 8233, 8235, 1, 0, 0, 0, 8234, 8236, 3, 902, 451, 0, 8235, 8234, 1, 0, 0, 0, 8235, 8236, 1, 0, 0, 0, 8236, 8238, 1, 0, 0, 0, 8237, 8239, 3, 924, 462, 0, 8238, 8237, 1, 0, 0, 0, 8238, 8239, 1, 0, 0, 0, 8239, 8251, 1, 0, 0, 0, 8240, 8245, 5, 370, 0, 0, 8241, 8242, 5, 2, 0, 0, 8242, 8243, 3, 892, 446, 0, 8243, 8244, 5, 3, 0, 0, 8244, 8246, 1, 0, 0, 0, 8245, 8241, 1, 0, 0, 0, 8245, 8246, 1, 0, 0, 0, 8246, 8248, 1, 0, 0, 0, 8247, 8249, 3, 924, 462, 0, 8248, 8247, 1, 0, 0, 0, 8248, 8249, 1, 0, 0, 0, 8249, 8251, 1, 0, 0, 0, 8250, 8224, 1, 0, 0, 0, 8250, 8240, 1, 0, 0, 0, 8251, 889, 1, 0, 0, 0, 8252, 8254, 3, 894, 447, 0, 8253, 8255, 3, 908, 454, 0, 8254, 8253, 1, 0, 0, 0, 8254, 8255, 1, 0, 0, 0, 8255, 8257, 1, 0, 0, 0, 8256, 8258, 3, 924, 462, 0, 8257, 8256, 1, 0, 0, 0, 8257, 8258, 1, 0, 0, 0, 8258, 8267, 1, 0, 0, 0, 8259, 8260, 3, 894, 447, 0, 8260, 8261, 5, 2, 0, 0, 8261, 8262, 3, 904, 452, 0, 8262, 8264, 5, 3, 0, 0, 8263, 8265, 3, 924, 462, 0, 8264, 8263, 1, 0, 0, 0, 8264, 8265, 1, 0, 0, 0, 8265, 8267, 1, 0, 0, 0, 8266, 8252, 1, 0, 0, 0, 8266, 8259, 1, 0, 0, 0, 8267, 891, 1, 0, 0, 0, 8268, 8273, 3, 896, 448, 0, 8269, 8270, 5, 6, 0, 0, 8270, 8272, 3, 896, 448, 0, 8271, 8269, 1, 0, 0, 0, 8272, 8275, 1, 0, 0, 0, 8273, 8271, 1, 0, 0, 0, 8273, 8274, 1, 0, 0, 0, 8274, 893, 1, 0, 0, 0, 8275, 8273, 1, 0, 0, 0, 8276, 8277, 7, 51, 0, 0, 8277, 895, 1, 0, 0, 0, 8278, 8280, 3, 898, 449, 0, 8279, 8281, 3, 900, 450, 0, 8280, 8279, 1, 0, 0, 0, 8280, 8281, 1, 0, 0, 0, 8281, 897, 1, 0, 0, 0, 8282, 8285, 3, 1488, 744, 0, 8283, 8285, 3, 894, 447, 0, 8284, 8282, 1, 0, 0, 0, 8284, 8283, 1, 0, 0, 0, 8285, 899, 1, 0, 0, 0, 8286, 8289, 3, 72, 36, 0, 8287, 8289, 3, 322, 161, 0, 8288, 8286, 1, 0, 0, 0, 8288, 8287, 1, 0, 0, 0, 8289, 901, 1, 0, 0, 0, 8290, 8291, 3, 894, 447, 0, 8291, 903, 1, 0, 0, 0, 8292, 8297, 3, 906, 453, 0, 8293, 8294, 5, 6, 0, 0, 8294, 8296, 3, 906, 453, 0, 8295, 8293, 1, 0, 0, 0, 8296, 8299, 1, 0, 0, 0, 8297, 8295, 1, 0, 0, 0, 8297, 8298, 1, 0, 0, 0, 8298, 905, 1, 0, 0, 0, 8299, 8297, 1, 0, 0, 0, 8300, 8304, 3, 908, 454, 0, 8301, 8304, 3, 910, 455, 0, 8302, 8304, 3, 912, 456, 0, 8303, 8300, 1, 0, 0, 0, 8303, 8301, 1, 0, 0, 0, 8303, 8302, 1, 0, 0, 0, 8304, 907, 1, 0, 0, 0, 8305, 8307, 5, 128, 0, 0, 8306, 8308, 7, 52, 0, 0, 8307, 8306, 1, 0, 0, 0, 8307, 8308, 1, 0, 0, 0, 8308, 909, 1, 0, 0, 0, 8309, 8311, 5, 547, 0, 0, 8310, 8312, 7, 52, 0, 0, 8311, 8310, 1, 0, 0, 0, 8311, 8312, 1, 0, 0, 0, 8312, 911, 1, 0, 0, 0, 8313, 8316, 5, 548, 0, 0, 8314, 8317, 3, 322, 161, 0, 8315, 8317, 3, 1458, 729, 0, 8316, 8314, 1, 0, 0, 0, 8316, 8315, 1, 0, 0, 0, 8317, 913, 1, 0, 0, 0, 8318, 8319, 5, 113, 0, 0, 8319, 915, 1, 0, 0, 0, 8320, 8321, 5, 112, 0, 0, 8321, 917, 1, 0, 0, 0, 8322, 8323, 5, 2, 0, 0, 8323, 8324, 3, 244, 122, 0, 8324, 8325, 5, 3, 0, 0, 8325, 919, 1, 0, 0, 0, 8326, 8328, 3, 1406, 703, 0, 8327, 8329, 3, 918, 459, 0, 8328, 8327, 1, 0, 0, 0, 8328, 8329, 1, 0, 0, 0, 8329, 921, 1, 0, 0, 0, 8330, 8335, 3, 920, 460, 0, 8331, 8332, 5, 6, 0, 0, 8332, 8334, 3, 920, 460, 0, 8333, 8331, 1, 0, 0, 0, 8334, 8337, 1, 0, 0, 0, 8335, 8333, 1, 0, 0, 0, 8335, 8336, 1, 0, 0, 0, 8336, 923, 1, 0, 0, 0, 8337, 8335, 1, 0, 0, 0, 8338, 8339, 3, 922, 461, 0, 8339, 925, 1, 0, 0, 0, 8340, 8341, 5, 203, 0, 0, 8341, 8359, 3, 928, 464, 0, 8342, 8343, 5, 203, 0, 0, 8343, 8345, 3, 894, 447, 0, 8344, 8346, 3, 908, 454, 0, 8345, 8344, 1, 0, 0, 0, 8345, 8346, 1, 0, 0, 0, 8346, 8347, 1, 0, 0, 0, 8347, 8348, 3, 928, 464, 0, 8348, 8359, 1, 0, 0, 0, 8349, 8350, 5, 203, 0, 0, 8350, 8351, 5, 128, 0, 0, 8351, 8359, 3, 928, 464, 0, 8352, 8353, 5, 203, 0, 0, 8353, 8354, 5, 2, 0, 0, 8354, 8355, 3, 930, 465, 0, 8355, 8356, 5, 3, 0, 0, 8356, 8357, 3, 928, 464, 0, 8357, 8359, 1, 0, 0, 0, 8358, 8340, 1, 0, 0, 0, 8358, 8342, 1, 0, 0, 0, 8358, 8349, 1, 0, 0, 0, 8358, 8352, 1, 0, 0, 0, 8359, 927, 1, 0, 0, 0, 8360, 8370, 3, 1000, 500, 0, 8361, 8370, 3, 950, 475, 0, 8362, 8370, 3, 982, 491, 0, 8363, 8370, 3, 968, 484, 0, 8364, 8370, 3, 992, 496, 0, 8365, 8370, 3, 294, 147, 0, 8366, 8370, 3, 300, 150, 0, 8367, 8370, 3, 306, 153, 0, 8368, 8370, 3, 944, 472, 0, 8369, 8360, 1, 0, 0, 0, 8369, 8361, 1, 0, 0, 0, 8369, 8362, 1, 0, 0, 0, 8369, 8363, 1, 0, 0, 0, 8369, 8364, 1, 0, 0, 0, 8369, 8365, 1, 0, 0, 0, 8369, 8366, 1, 0, 0, 0, 8369, 8367, 1, 0, 0, 0, 8369, 8368, 1, 0, 0, 0, 8370, 929, 1, 0, 0, 0, 8371, 8376, 3, 932, 466, 0, 8372, 8373, 5, 6, 0, 0, 8373, 8375, 3, 932, 466, 0, 8374, 8372, 1, 0, 0, 0, 8375, 8378, 1, 0, 0, 0, 8376, 8374, 1, 0, 0, 0, 8376, 8377, 1, 0, 0, 0, 8377, 931, 1, 0, 0, 0, 8378, 8376, 1, 0, 0, 0, 8379, 8381, 3, 934, 467, 0, 8380, 8382, 3, 936, 468, 0, 8381, 8380, 1, 0, 0, 0, 8381, 8382, 1, 0, 0, 0, 8382, 933, 1, 0, 0, 0, 8383, 8386, 3, 1488, 744, 0, 8384, 8386, 3, 894, 447, 0, 8385, 8383, 1, 0, 0, 0, 8385, 8384, 1, 0, 0, 0, 8386, 935, 1, 0, 0, 0, 8387, 8390, 3, 72, 36, 0, 8388, 8390, 3, 322, 161, 0, 8389, 8387, 1, 0, 0, 0, 8389, 8388, 1, 0, 0, 0, 8390, 937, 1, 0, 0, 0, 8391, 8392, 5, 290, 0, 0, 8392, 8394, 3, 1436, 718, 0, 8393, 8395, 3, 940, 470, 0, 8394, 8393, 1, 0, 0, 0, 8394, 8395, 1, 0, 0, 0, 8395, 8396, 1, 0, 0, 0, 8396, 8397, 5, 36, 0, 0, 8397, 8398, 3, 942, 471, 0, 8398, 939, 1, 0, 0, 0, 8399, 8400, 5, 2, 0, 0, 8400, 8401, 3, 1342, 671, 0, 8401, 8402, 5, 3, 0, 0, 8402, 941, 1, 0, 0, 0, 8403, 8408, 3, 1000, 500, 0, 8404, 8408, 3, 950, 475, 0, 8405, 8408, 3, 982, 491, 0, 8406, 8408, 3, 968, 484, 0, 8407, 8403, 1, 0, 0, 0, 8407, 8404, 1, 0, 0, 0, 8407, 8405, 1, 0, 0, 0, 8407, 8406, 1, 0, 0, 0, 8408, 943, 1, 0, 0, 0, 8409, 8410, 5, 202, 0, 0, 8410, 8412, 3, 1436, 718, 0, 8411, 8413, 3, 946, 473, 0, 8412, 8411, 1, 0, 0, 0, 8412, 8413, 1, 0, 0, 0, 8413, 8433, 1, 0, 0, 0, 8414, 8416, 5, 46, 0, 0, 8415, 8417, 3, 190, 95, 0, 8416, 8415, 1, 0, 0, 0, 8416, 8417, 1, 0, 0, 0, 8417, 8418, 1, 0, 0, 0, 8418, 8420, 5, 92, 0, 0, 8419, 8421, 3, 516, 258, 0, 8420, 8419, 1, 0, 0, 0, 8420, 8421, 1, 0, 0, 0, 8421, 8422, 1, 0, 0, 0, 8422, 8423, 3, 296, 148, 0, 8423, 8424, 5, 36, 0, 0, 8424, 8425, 5, 202, 0, 0, 8425, 8427, 3, 1436, 718, 0, 8426, 8428, 3, 946, 473, 0, 8427, 8426, 1, 0, 0, 0, 8427, 8428, 1, 0, 0, 0, 8428, 8430, 1, 0, 0, 0, 8429, 8431, 3, 298, 149, 0, 8430, 8429, 1, 0, 0, 0, 8430, 8431, 1, 0, 0, 0, 8431, 8433, 1, 0, 0, 0, 8432, 8409, 1, 0, 0, 0, 8432, 8414, 1, 0, 0, 0, 8433, 945, 1, 0, 0, 0, 8434, 8435, 5, 2, 0, 0, 8435, 8436, 3, 1328, 664, 0, 8436, 8437, 5, 3, 0, 0, 8437, 947, 1, 0, 0, 0, 8438, 8440, 5, 177, 0, 0, 8439, 8441, 5, 290, 0, 0, 8440, 8439, 1, 0, 0, 0, 8440, 8441, 1, 0, 0, 0, 8441, 8444, 1, 0, 0, 0, 8442, 8445, 3, 1436, 718, 0, 8443, 8445, 5, 30, 0, 0, 8444, 8442, 1, 0, 0, 0, 8444, 8443, 1, 0, 0, 0, 8445, 949, 1, 0, 0, 0, 8446, 8448, 3, 1026, 513, 0, 8447, 8446, 1, 0, 0, 0, 8447, 8448, 1, 0, 0, 0, 8448, 8449, 1, 0, 0, 0, 8449, 8450, 5, 241, 0, 0, 8450, 8451, 5, 71, 0, 0, 8451, 8452, 3, 952, 476, 0, 8452, 8454, 3, 954, 477, 0, 8453, 8455, 3, 962, 481, 0, 8454, 8453, 1, 0, 0, 0, 8454, 8455, 1, 0, 0, 0, 8455, 8457, 1, 0, 0, 0, 8456, 8458, 3, 966, 483, 0, 8457, 8456, 1, 0, 0, 0, 8457, 8458, 1, 0, 0, 0, 8458, 951, 1, 0, 0, 0, 8459, 8462, 3, 1406, 703, 0, 8460, 8461, 5, 36, 0, 0, 8461, 8463, 3, 1474, 737, 0, 8462, 8460, 1, 0, 0, 0, 8462, 8463, 1, 0, 0, 0, 8463, 953, 1, 0, 0, 0, 8464, 8465, 5, 2, 0, 0, 8465, 8466, 3, 958, 479, 0, 8466, 8467, 5, 3, 0, 0, 8467, 8469, 1, 0, 0, 0, 8468, 8464, 1, 0, 0, 0, 8468, 8469, 1, 0, 0, 0, 8469, 8474, 1, 0, 0, 0, 8470, 8471, 5, 463, 0, 0, 8471, 8472, 3, 956, 478, 0, 8472, 8473, 5, 450, 0, 0, 8473, 8475, 1, 0, 0, 0, 8474, 8470, 1, 0, 0, 0, 8474, 8475, 1, 0, 0, 0, 8475, 8478, 1, 0, 0, 0, 8476, 8479, 3, 1694, 847, 0, 8477, 8479, 3, 1000, 500, 0, 8478, 8476, 1, 0, 0, 0, 8478, 8477, 1, 0, 0, 0, 8479, 955, 1, 0, 0, 0, 8480, 8481, 7, 53, 0, 0, 8481, 957, 1, 0, 0, 0, 8482, 8487, 3, 960, 480, 0, 8483, 8484, 5, 6, 0, 0, 8484, 8486, 3, 960, 480, 0, 8485, 8483, 1, 0, 0, 0, 8486, 8489, 1, 0, 0, 0, 8487, 8485, 1, 0, 0, 0, 8487, 8488, 1, 0, 0, 0, 8488, 959, 1, 0, 0, 0, 8489, 8487, 1, 0, 0, 0, 8490, 8491, 3, 1432, 716, 0, 8491, 8492, 3, 1382, 691, 0, 8492, 961, 1, 0, 0, 0, 8493, 8494, 5, 80, 0, 0, 8494, 8496, 5, 464, 0, 0, 8495, 8497, 3, 964, 482, 0, 8496, 8495, 1, 0, 0, 0, 8496, 8497, 1, 0, 0, 0, 8497, 8498, 1, 0, 0, 0, 8498, 8506, 5, 57, 0, 0, 8499, 8500, 5, 369, 0, 0, 8500, 8501, 5, 333, 0, 0, 8501, 8503, 3, 984, 492, 0, 8502, 8504, 3, 1144, 572, 0, 8503, 8502, 1, 0, 0, 0, 8503, 8504, 1, 0, 0, 0, 8504, 8507, 1, 0, 0, 0, 8505, 8507, 5, 270, 0, 0, 8506, 8499, 1, 0, 0, 0, 8506, 8505, 1, 0, 0, 0, 8507, 963, 1, 0, 0, 0, 8508, 8509, 5, 2, 0, 0, 8509, 8510, 3, 636, 318, 0, 8510, 8512, 5, 3, 0, 0, 8511, 8513, 3, 1144, 572, 0, 8512, 8511, 1, 0, 0, 0, 8512, 8513, 1, 0, 0, 0, 8513, 8518, 1, 0, 0, 0, 8514, 8515, 5, 80, 0, 0, 8515, 8516, 5, 45, 0, 0, 8516, 8518, 3, 1436, 718, 0, 8517, 8508, 1, 0, 0, 0, 8517, 8514, 1, 0, 0, 0, 8518, 965, 1, 0, 0, 0, 8519, 8520, 5, 87, 0, 0, 8520, 8521, 3, 1386, 693, 0, 8521, 967, 1, 0, 0, 0, 8522, 8524, 3, 1026, 513, 0, 8523, 8522, 1, 0, 0, 0, 8523, 8524, 1, 0, 0, 0, 8524, 8525, 1, 0, 0, 0, 8525, 8526, 5, 182, 0, 0, 8526, 8527, 5, 64, 0, 0, 8527, 8529, 3, 1128, 564, 0, 8528, 8530, 3, 970, 485, 0, 8529, 8528, 1, 0, 0, 0, 8529, 8530, 1, 0, 0, 0, 8530, 8532, 1, 0, 0, 0, 8531, 8533, 3, 1146, 573, 0, 8532, 8531, 1, 0, 0, 0, 8532, 8533, 1, 0, 0, 0, 8533, 8535, 1, 0, 0, 0, 8534, 8536, 3, 966, 483, 0, 8535, 8534, 1, 0, 0, 0, 8535, 8536, 1, 0, 0, 0, 8536, 969, 1, 0, 0, 0, 8537, 8538, 5, 100, 0, 0, 8538, 8539, 3, 1104, 552, 0, 8539, 971, 1, 0, 0, 0, 8540, 8542, 5, 256, 0, 0, 8541, 8543, 3, 1034, 517, 0, 8542, 8541, 1, 0, 0, 0, 8542, 8543, 1, 0, 0, 0, 8543, 8544, 1, 0, 0, 0, 8544, 8546, 3, 1124, 562, 0, 8545, 8547, 3, 974, 487, 0, 8546, 8545, 1, 0, 0, 0, 8546, 8547, 1, 0, 0, 0, 8547, 8549, 1, 0, 0, 0, 8548, 8550, 3, 978, 489, 0, 8549, 8548, 1, 0, 0, 0, 8549, 8550, 1, 0, 0, 0, 8550, 973, 1, 0, 0, 0, 8551, 8552, 5, 68, 0, 0, 8552, 8553, 3, 976, 488, 0, 8553, 8554, 5, 263, 0, 0, 8554, 975, 1, 0, 0, 0, 8555, 8556, 5, 131, 0, 0, 8556, 8568, 7, 54, 0, 0, 8557, 8558, 5, 414, 0, 0, 8558, 8568, 7, 54, 0, 0, 8559, 8564, 5, 334, 0, 0, 8560, 8561, 5, 369, 0, 0, 8561, 8565, 5, 201, 0, 0, 8562, 8563, 5, 414, 0, 0, 8563, 8565, 5, 201, 0, 0, 8564, 8560, 1, 0, 0, 0, 8564, 8562, 1, 0, 0, 0, 8564, 8565, 1, 0, 0, 0, 8565, 8568, 1, 0, 0, 0, 8566, 8568, 5, 201, 0, 0, 8567, 8555, 1, 0, 0, 0, 8567, 8557, 1, 0, 0, 0, 8567, 8559, 1, 0, 0, 0, 8567, 8566, 1, 0, 0, 0, 8568, 977, 1, 0, 0, 0, 8569, 8570, 5, 272, 0, 0, 8570, 979, 1, 0, 0, 0, 8571, 8575, 5, 272, 0, 0, 8572, 8573, 5, 465, 0, 0, 8573, 8575, 5, 466, 0, 0, 8574, 8571, 1, 0, 0, 0, 8574, 8572, 1, 0, 0, 0, 8575, 981, 1, 0, 0, 0, 8576, 8578, 3, 1026, 513, 0, 8577, 8576, 1, 0, 0, 0, 8577, 8578, 1, 0, 0, 0, 8578, 8579, 1, 0, 0, 0, 8579, 8580, 5, 369, 0, 0, 8580, 8581, 3, 1128, 564, 0, 8581, 8582, 5, 333, 0, 0, 8582, 8584, 3, 984, 492, 0, 8583, 8585, 3, 1102, 551, 0, 8584, 8583, 1, 0, 0, 0, 8584, 8585, 1, 0, 0, 0, 8585, 8587, 1, 0, 0, 0, 8586, 8588, 3, 1146, 573, 0, 8587, 8586, 1, 0, 0, 0, 8587, 8588, 1, 0, 0, 0, 8588, 8590, 1, 0, 0, 0, 8589, 8591, 3, 966, 483, 0, 8590, 8589, 1, 0, 0, 0, 8590, 8591, 1, 0, 0, 0, 8591, 983, 1, 0, 0, 0, 8592, 8597, 3, 986, 493, 0, 8593, 8594, 5, 6, 0, 0, 8594, 8596, 3, 986, 493, 0, 8595, 8593, 1, 0, 0, 0, 8596, 8599, 1, 0, 0, 0, 8597, 8595, 1, 0, 0, 0, 8597, 8598, 1, 0, 0, 0, 8598, 985, 1, 0, 0, 0, 8599, 8597, 1, 0, 0, 0, 8600, 8601, 3, 988, 494, 0, 8601, 8602, 5, 10, 0, 0, 8602, 8603, 3, 1212, 606, 0, 8603, 8619, 1, 0, 0, 0, 8604, 8605, 5, 2, 0, 0, 8605, 8606, 3, 990, 495, 0, 8606, 8607, 5, 3, 0, 0, 8607, 8616, 5, 10, 0, 0, 8608, 8610, 5, 414, 0, 0, 8609, 8608, 1, 0, 0, 0, 8609, 8610, 1, 0, 0, 0, 8610, 8611, 1, 0, 0, 0, 8611, 8617, 3, 1212, 606, 0, 8612, 8613, 5, 2, 0, 0, 8613, 8614, 3, 1006, 503, 0, 8614, 8615, 5, 3, 0, 0, 8615, 8617, 1, 0, 0, 0, 8616, 8609, 1, 0, 0, 0, 8616, 8612, 1, 0, 0, 0, 8617, 8619, 1, 0, 0, 0, 8618, 8600, 1, 0, 0, 0, 8618, 8604, 1, 0, 0, 0, 8619, 987, 1, 0, 0, 0, 8620, 8621, 3, 1432, 716, 0, 8621, 8622, 3, 1382, 691, 0, 8622, 989, 1, 0, 0, 0, 8623, 8628, 3, 988, 494, 0, 8624, 8625, 5, 6, 0, 0, 8625, 8627, 3, 988, 494, 0, 8626, 8624, 1, 0, 0, 0, 8627, 8630, 1, 0, 0, 0, 8628, 8626, 1, 0, 0, 0, 8628, 8629, 1, 0, 0, 0, 8629, 991, 1, 0, 0, 0, 8630, 8628, 1, 0, 0, 0, 8631, 8632, 5, 178, 0, 0, 8632, 8633, 3, 994, 497, 0, 8633, 8634, 3, 996, 498, 0, 8634, 8635, 5, 172, 0, 0, 8635, 8636, 3, 998, 499, 0, 8636, 8637, 5, 62, 0, 0, 8637, 8638, 3, 1000, 500, 0, 8638, 993, 1, 0, 0, 0, 8639, 8640, 3, 1436, 718, 0, 8640, 995, 1, 0, 0, 0, 8641, 8642, 5, 269, 0, 0, 8642, 8647, 5, 324, 0, 0, 8643, 8647, 5, 324, 0, 0, 8644, 8647, 5, 107, 0, 0, 8645, 8647, 5, 240, 0, 0, 8646, 8641, 1, 0, 0, 0, 8646, 8643, 1, 0, 0, 0, 8646, 8644, 1, 0, 0, 0, 8646, 8645, 1, 0, 0, 0, 8647, 8650, 1, 0, 0, 0, 8648, 8646, 1, 0, 0, 0, 8648, 8649, 1, 0, 0, 0, 8649, 997, 1, 0, 0, 0, 8650, 8648, 1, 0, 0, 0, 8651, 8657, 1, 0, 0, 0, 8652, 8653, 5, 105, 0, 0, 8653, 8657, 5, 217, 0, 0, 8654, 8655, 5, 379, 0, 0, 8655, 8657, 5, 217, 0, 0, 8656, 8651, 1, 0, 0, 0, 8656, 8652, 1, 0, 0, 0, 8656, 8654, 1, 0, 0, 0, 8657, 999, 1, 0, 0, 0, 8658, 8661, 3, 1004, 502, 0, 8659, 8661, 3, 1002, 501, 0, 8660, 8658, 1, 0, 0, 0, 8660, 8659, 1, 0, 0, 0, 8661, 1001, 1, 0, 0, 0, 8662, 8663, 5, 2, 0, 0, 8663, 8664, 3, 1004, 502, 0, 8664, 8665, 5, 3, 0, 0, 8665, 8671, 1, 0, 0, 0, 8666, 8667, 5, 2, 0, 0, 8667, 8668, 3, 1002, 501, 0, 8668, 8669, 5, 3, 0, 0, 8669, 8671, 1, 0, 0, 0, 8670, 8662, 1, 0, 0, 0, 8670, 8666, 1, 0, 0, 0, 8671, 1003, 1, 0, 0, 0, 8672, 8674, 3, 1006, 503, 0, 8673, 8675, 3, 1042, 521, 0, 8674, 8673, 1, 0, 0, 0, 8674, 8675, 1, 0, 0, 0, 8675, 8684, 1, 0, 0, 0, 8676, 8678, 3, 1088, 544, 0, 8677, 8679, 3, 1052, 526, 0, 8678, 8677, 1, 0, 0, 0, 8678, 8679, 1, 0, 0, 0, 8679, 8685, 1, 0, 0, 0, 8680, 8682, 3, 1050, 525, 0, 8681, 8683, 3, 1090, 545, 0, 8682, 8681, 1, 0, 0, 0, 8682, 8683, 1, 0, 0, 0, 8683, 8685, 1, 0, 0, 0, 8684, 8676, 1, 0, 0, 0, 8684, 8680, 1, 0, 0, 0, 8684, 8685, 1, 0, 0, 0, 8685, 8702, 1, 0, 0, 0, 8686, 8687, 3, 1014, 507, 0, 8687, 8689, 3, 1006, 503, 0, 8688, 8690, 3, 1042, 521, 0, 8689, 8688, 1, 0, 0, 0, 8689, 8690, 1, 0, 0, 0, 8690, 8699, 1, 0, 0, 0, 8691, 8693, 3, 1088, 544, 0, 8692, 8694, 3, 1052, 526, 0, 8693, 8692, 1, 0, 0, 0, 8693, 8694, 1, 0, 0, 0, 8694, 8700, 1, 0, 0, 0, 8695, 8697, 3, 1050, 525, 0, 8696, 8698, 3, 1090, 545, 0, 8697, 8696, 1, 0, 0, 0, 8697, 8698, 1, 0, 0, 0, 8698, 8700, 1, 0, 0, 0, 8699, 8691, 1, 0, 0, 0, 8699, 8695, 1, 0, 0, 0, 8699, 8700, 1, 0, 0, 0, 8700, 8702, 1, 0, 0, 0, 8701, 8672, 1, 0, 0, 0, 8701, 8686, 1, 0, 0, 0, 8702, 1005, 1, 0, 0, 0, 8703, 8706, 3, 1008, 504, 0, 8704, 8706, 3, 1002, 501, 0, 8705, 8703, 1, 0, 0, 0, 8705, 8704, 1, 0, 0, 0, 8706, 1007, 1, 0, 0, 0, 8707, 8723, 5, 88, 0, 0, 8708, 8710, 3, 1040, 520, 0, 8709, 8708, 1, 0, 0, 0, 8709, 8710, 1, 0, 0, 0, 8710, 8712, 1, 0, 0, 0, 8711, 8713, 3, 1028, 514, 0, 8712, 8711, 1, 0, 0, 0, 8712, 8713, 1, 0, 0, 0, 8713, 8715, 1, 0, 0, 0, 8714, 8716, 3, 1384, 692, 0, 8715, 8714, 1, 0, 0, 0, 8715, 8716, 1, 0, 0, 0, 8716, 8724, 1, 0, 0, 0, 8717, 8719, 3, 1038, 519, 0, 8718, 8717, 1, 0, 0, 0, 8718, 8719, 1, 0, 0, 0, 8719, 8721, 1, 0, 0, 0, 8720, 8722, 3, 1386, 693, 0, 8721, 8720, 1, 0, 0, 0, 8721, 8722, 1, 0, 0, 0, 8722, 8724, 1, 0, 0, 0, 8723, 8709, 1, 0, 0, 0, 8723, 8718, 1, 0, 0, 0, 8724, 8726, 1, 0, 0, 0, 8725, 8727, 3, 1028, 514, 0, 8726, 8725, 1, 0, 0, 0, 8726, 8727, 1, 0, 0, 0, 8727, 8729, 1, 0, 0, 0, 8728, 8730, 3, 1102, 551, 0, 8729, 8728, 1, 0, 0, 0, 8729, 8730, 1, 0, 0, 0, 8730, 8732, 1, 0, 0, 0, 8731, 8733, 3, 1144, 572, 0, 8732, 8731, 1, 0, 0, 0, 8732, 8733, 1, 0, 0, 0, 8733, 8735, 1, 0, 0, 0, 8734, 8736, 3, 1072, 536, 0, 8735, 8734, 1, 0, 0, 0, 8735, 8736, 1, 0, 0, 0, 8736, 8738, 1, 0, 0, 0, 8737, 8739, 3, 1086, 543, 0, 8738, 8737, 1, 0, 0, 0, 8738, 8739, 1, 0, 0, 0, 8739, 8741, 1, 0, 0, 0, 8740, 8742, 3, 1288, 644, 0, 8741, 8740, 1, 0, 0, 0, 8741, 8742, 1, 0, 0, 0, 8742, 8753, 1, 0, 0, 0, 8743, 8753, 3, 1100, 550, 0, 8744, 8745, 5, 92, 0, 0, 8745, 8753, 3, 1118, 559, 0, 8746, 8747, 3, 1002, 501, 0, 8747, 8750, 3, 1012, 506, 0, 8748, 8751, 3, 1008, 504, 0, 8749, 8751, 3, 1002, 501, 0, 8750, 8748, 1, 0, 0, 0, 8750, 8749, 1, 0, 0, 0, 8751, 8753, 1, 0, 0, 0, 8752, 8707, 1, 0, 0, 0, 8752, 8743, 1, 0, 0, 0, 8752, 8744, 1, 0, 0, 0, 8752, 8746, 1, 0, 0, 0, 8753, 8761, 1, 0, 0, 0, 8754, 8757, 3, 1012, 506, 0, 8755, 8758, 3, 1008, 504, 0, 8756, 8758, 3, 1002, 501, 0, 8757, 8755, 1, 0, 0, 0, 8757, 8756, 1, 0, 0, 0, 8758, 8760, 1, 0, 0, 0, 8759, 8754, 1, 0, 0, 0, 8760, 8763, 1, 0, 0, 0, 8761, 8759, 1, 0, 0, 0, 8761, 8762, 1, 0, 0, 0, 8762, 1009, 1, 0, 0, 0, 8763, 8761, 1, 0, 0, 0, 8764, 8768, 5, 97, 0, 0, 8765, 8768, 5, 70, 0, 0, 8766, 8768, 5, 59, 0, 0, 8767, 8764, 1, 0, 0, 0, 8767, 8765, 1, 0, 0, 0, 8767, 8766, 1, 0, 0, 0, 8768, 1011, 1, 0, 0, 0, 8769, 8771, 3, 1010, 505, 0, 8770, 8772, 3, 1036, 518, 0, 8771, 8770, 1, 0, 0, 0, 8771, 8772, 1, 0, 0, 0, 8772, 1013, 1, 0, 0, 0, 8773, 8775, 5, 105, 0, 0, 8774, 8776, 5, 303, 0, 0, 8775, 8774, 1, 0, 0, 0, 8775, 8776, 1, 0, 0, 0, 8776, 8777, 1, 0, 0, 0, 8777, 8778, 3, 1016, 508, 0, 8778, 1015, 1, 0, 0, 0, 8779, 8784, 3, 1018, 509, 0, 8780, 8781, 5, 6, 0, 0, 8781, 8783, 3, 1018, 509, 0, 8782, 8780, 1, 0, 0, 0, 8783, 8786, 1, 0, 0, 0, 8784, 8782, 1, 0, 0, 0, 8784, 8785, 1, 0, 0, 0, 8785, 1017, 1, 0, 0, 0, 8786, 8784, 1, 0, 0, 0, 8787, 8789, 3, 1436, 718, 0, 8788, 8790, 3, 918, 459, 0, 8789, 8788, 1, 0, 0, 0, 8789, 8790, 1, 0, 0, 0, 8790, 8791, 1, 0, 0, 0, 8791, 8793, 5, 36, 0, 0, 8792, 8794, 3, 1024, 512, 0, 8793, 8792, 1, 0, 0, 0, 8793, 8794, 1, 0, 0, 0, 8794, 8795, 1, 0, 0, 0, 8795, 8796, 5, 2, 0, 0, 8796, 8797, 3, 942, 471, 0, 8797, 8799, 5, 3, 0, 0, 8798, 8800, 3, 1020, 510, 0, 8799, 8798, 1, 0, 0, 0, 8799, 8800, 1, 0, 0, 0, 8800, 8802, 1, 0, 0, 0, 8801, 8803, 3, 1022, 511, 0, 8802, 8801, 1, 0, 0, 0, 8802, 8803, 1, 0, 0, 0, 8803, 1019, 1, 0, 0, 0, 8804, 8805, 5, 325, 0, 0, 8805, 8806, 7, 55, 0, 0, 8806, 8807, 5, 207, 0, 0, 8807, 8808, 5, 147, 0, 0, 8808, 8809, 3, 244, 122, 0, 8809, 8810, 5, 333, 0, 0, 8810, 8811, 3, 1432, 716, 0, 8811, 1021, 1, 0, 0, 0, 8812, 8813, 5, 173, 0, 0, 8813, 8814, 3, 244, 122, 0, 8814, 8815, 5, 333, 0, 0, 8815, 8821, 3, 1432, 716, 0, 8816, 8817, 5, 94, 0, 0, 8817, 8818, 3, 1436, 718, 0, 8818, 8819, 5, 53, 0, 0, 8819, 8820, 3, 1436, 718, 0, 8820, 8822, 1, 0, 0, 0, 8821, 8816, 1, 0, 0, 0, 8821, 8822, 1, 0, 0, 0, 8822, 8823, 1, 0, 0, 0, 8823, 8824, 5, 100, 0, 0, 8824, 8825, 3, 1432, 716, 0, 8825, 1023, 1, 0, 0, 0, 8826, 8830, 5, 259, 0, 0, 8827, 8828, 5, 77, 0, 0, 8828, 8830, 5, 259, 0, 0, 8829, 8826, 1, 0, 0, 0, 8829, 8827, 1, 0, 0, 0, 8830, 1025, 1, 0, 0, 0, 8831, 8832, 3, 1014, 507, 0, 8832, 1027, 1, 0, 0, 0, 8833, 8838, 5, 71, 0, 0, 8834, 8835, 3, 1030, 515, 0, 8835, 8836, 3, 1032, 516, 0, 8836, 8839, 1, 0, 0, 0, 8837, 8839, 3, 1674, 837, 0, 8838, 8834, 1, 0, 0, 0, 8838, 8837, 1, 0, 0, 0, 8839, 1029, 1, 0, 0, 0, 8840, 8843, 1, 0, 0, 0, 8841, 8843, 5, 346, 0, 0, 8842, 8840, 1, 0, 0, 0, 8842, 8841, 1, 0, 0, 0, 8843, 1031, 1, 0, 0, 0, 8844, 8846, 7, 56, 0, 0, 8845, 8844, 1, 0, 0, 0, 8845, 8846, 1, 0, 0, 0, 8846, 8847, 1, 0, 0, 0, 8847, 8849, 7, 25, 0, 0, 8848, 8850, 3, 1034, 517, 0, 8849, 8848, 1, 0, 0, 0, 8849, 8850, 1, 0, 0, 0, 8850, 8851, 1, 0, 0, 0, 8851, 8861, 3, 1404, 702, 0, 8852, 8854, 5, 367, 0, 0, 8853, 8855, 3, 1034, 517, 0, 8854, 8853, 1, 0, 0, 0, 8854, 8855, 1, 0, 0, 0, 8855, 8856, 1, 0, 0, 0, 8856, 8861, 3, 1404, 702, 0, 8857, 8858, 5, 92, 0, 0, 8858, 8861, 3, 1404, 702, 0, 8859, 8861, 3, 1404, 702, 0, 8860, 8845, 1, 0, 0, 0, 8860, 8852, 1, 0, 0, 0, 8860, 8857, 1, 0, 0, 0, 8860, 8859, 1, 0, 0, 0, 8861, 1033, 1, 0, 0, 0, 8862, 8863, 5, 92, 0, 0, 8863, 1035, 1, 0, 0, 0, 8864, 8865, 7, 57, 0, 0, 8865, 1037, 1, 0, 0, 0, 8866, 8872, 5, 56, 0, 0, 8867, 8868, 5, 80, 0, 0, 8868, 8869, 5, 2, 0, 0, 8869, 8870, 3, 1328, 664, 0, 8870, 8871, 5, 3, 0, 0, 8871, 8873, 1, 0, 0, 0, 8872, 8867, 1, 0, 0, 0, 8872, 8873, 1, 0, 0, 0, 8873, 1039, 1, 0, 0, 0, 8874, 8875, 5, 30, 0, 0, 8875, 1041, 1, 0, 0, 0, 8876, 8877, 3, 1044, 522, 0, 8877, 1043, 1, 0, 0, 0, 8878, 8879, 5, 83, 0, 0, 8879, 8880, 5, 147, 0, 0, 8880, 8881, 3, 1046, 523, 0, 8881, 1045, 1, 0, 0, 0, 8882, 8887, 3, 1048, 524, 0, 8883, 8884, 5, 6, 0, 0, 8884, 8886, 3, 1048, 524, 0, 8885, 8883, 1, 0, 0, 0, 8886, 8889, 1, 0, 0, 0, 8887, 8885, 1, 0, 0, 0, 8887, 8888, 1, 0, 0, 0, 8888, 1047, 1, 0, 0, 0, 8889, 8887, 1, 0, 0, 0, 8890, 8894, 3, 1336, 668, 0, 8891, 8892, 5, 100, 0, 0, 8892, 8895, 3, 1324, 662, 0, 8893, 8895, 3, 650, 325, 0, 8894, 8891, 1, 0, 0, 0, 8894, 8893, 1, 0, 0, 0, 8894, 8895, 1, 0, 0, 0, 8895, 8897, 1, 0, 0, 0, 8896, 8898, 3, 652, 326, 0, 8897, 8896, 1, 0, 0, 0, 8897, 8898, 1, 0, 0, 0, 8898, 1049, 1, 0, 0, 0, 8899, 8901, 3, 1054, 527, 0, 8900, 8902, 3, 1058, 529, 0, 8901, 8900, 1, 0, 0, 0, 8901, 8902, 1, 0, 0, 0, 8902, 8912, 1, 0, 0, 0, 8903, 8905, 3, 1058, 529, 0, 8904, 8906, 3, 1056, 528, 0, 8905, 8904, 1, 0, 0, 0, 8905, 8906, 1, 0, 0, 0, 8906, 8912, 1, 0, 0, 0, 8907, 8909, 3, 1056, 528, 0, 8908, 8910, 3, 1058, 529, 0, 8909, 8908, 1, 0, 0, 0, 8909, 8910, 1, 0, 0, 0, 8910, 8912, 1, 0, 0, 0, 8911, 8899, 1, 0, 0, 0, 8911, 8903, 1, 0, 0, 0, 8911, 8907, 1, 0, 0, 0, 8912, 1051, 1, 0, 0, 0, 8913, 8914, 3, 1050, 525, 0, 8914, 1053, 1, 0, 0, 0, 8915, 8916, 5, 74, 0, 0, 8916, 8919, 3, 1060, 530, 0, 8917, 8918, 5, 6, 0, 0, 8918, 8920, 3, 1062, 531, 0, 8919, 8917, 1, 0, 0, 0, 8919, 8920, 1, 0, 0, 0, 8920, 1055, 1, 0, 0, 0, 8921, 8922, 5, 61, 0, 0, 8922, 8936, 3, 1070, 535, 0, 8923, 8924, 3, 1064, 532, 0, 8924, 8928, 3, 1068, 534, 0, 8925, 8929, 5, 81, 0, 0, 8926, 8927, 5, 105, 0, 0, 8927, 8929, 5, 467, 0, 0, 8928, 8925, 1, 0, 0, 0, 8928, 8926, 1, 0, 0, 0, 8929, 8937, 1, 0, 0, 0, 8930, 8934, 3, 1068, 534, 0, 8931, 8935, 5, 81, 0, 0, 8932, 8933, 5, 105, 0, 0, 8933, 8935, 5, 467, 0, 0, 8934, 8931, 1, 0, 0, 0, 8934, 8932, 1, 0, 0, 0, 8935, 8937, 1, 0, 0, 0, 8936, 8923, 1, 0, 0, 0, 8936, 8930, 1, 0, 0, 0, 8937, 1057, 1, 0, 0, 0, 8938, 8943, 5, 79, 0, 0, 8939, 8940, 3, 1064, 532, 0, 8940, 8941, 3, 1068, 534, 0, 8941, 8944, 1, 0, 0, 0, 8942, 8944, 3, 1062, 531, 0, 8943, 8939, 1, 0, 0, 0, 8943, 8942, 1, 0, 0, 0, 8944, 1059, 1, 0, 0, 0, 8945, 8948, 3, 1212, 606, 0, 8946, 8948, 5, 30, 0, 0, 8947, 8945, 1, 0, 0, 0, 8947, 8946, 1, 0, 0, 0, 8948, 1061, 1, 0, 0, 0, 8949, 8950, 3, 1212, 606, 0, 8950, 1063, 1, 0, 0, 0, 8951, 8952, 5, 12, 0, 0, 8952, 8957, 3, 1066, 533, 0, 8953, 8954, 5, 13, 0, 0, 8954, 8957, 3, 1066, 533, 0, 8955, 8957, 3, 1254, 627, 0, 8956, 8951, 1, 0, 0, 0, 8956, 8953, 1, 0, 0, 0, 8956, 8955, 1, 0, 0, 0, 8957, 1065, 1, 0, 0, 0, 8958, 8961, 3, 1456, 728, 0, 8959, 8961, 3, 1454, 727, 0, 8960, 8958, 1, 0, 0, 0, 8960, 8959, 1, 0, 0, 0, 8961, 1067, 1, 0, 0, 0, 8962, 8963, 7, 58, 0, 0, 8963, 1069, 1, 0, 0, 0, 8964, 8965, 7, 59, 0, 0, 8965, 1071, 1, 0, 0, 0, 8966, 8967, 5, 66, 0, 0, 8967, 8969, 5, 147, 0, 0, 8968, 8970, 3, 1036, 518, 0, 8969, 8968, 1, 0, 0, 0, 8969, 8970, 1, 0, 0, 0, 8970, 8971, 1, 0, 0, 0, 8971, 8972, 3, 1074, 537, 0, 8972, 1073, 1, 0, 0, 0, 8973, 8978, 3, 1076, 538, 0, 8974, 8975, 5, 6, 0, 0, 8975, 8977, 3, 1076, 538, 0, 8976, 8974, 1, 0, 0, 0, 8977, 8980, 1, 0, 0, 0, 8978, 8976, 1, 0, 0, 0, 8978, 8979, 1, 0, 0, 0, 8979, 1075, 1, 0, 0, 0, 8980, 8978, 1, 0, 0, 0, 8981, 8991, 3, 1336, 668, 0, 8982, 8991, 3, 1078, 539, 0, 8983, 8991, 3, 1082, 541, 0, 8984, 8991, 3, 1080, 540, 0, 8985, 8991, 3, 1084, 542, 0, 8986, 8987, 5, 2, 0, 0, 8987, 8988, 3, 1330, 665, 0, 8988, 8989, 5, 3, 0, 0, 8989, 8991, 1, 0, 0, 0, 8990, 8981, 1, 0, 0, 0, 8990, 8982, 1, 0, 0, 0, 8990, 8983, 1, 0, 0, 0, 8990, 8984, 1, 0, 0, 0, 8990, 8985, 1, 0, 0, 0, 8990, 8986, 1, 0, 0, 0, 8991, 1077, 1, 0, 0, 0, 8992, 8993, 5, 2, 0, 0, 8993, 8994, 5, 3, 0, 0, 8994, 1079, 1, 0, 0, 0, 8995, 8996, 5, 468, 0, 0, 8996, 8997, 5, 2, 0, 0, 8997, 8998, 3, 1330, 665, 0, 8998, 8999, 5, 3, 0, 0, 8999, 1081, 1, 0, 0, 0, 9000, 9001, 5, 469, 0, 0, 9001, 9002, 5, 2, 0, 0, 9002, 9003, 3, 1330, 665, 0, 9003, 9004, 5, 3, 0, 0, 9004, 1083, 1, 0, 0, 0, 9005, 9006, 5, 470, 0, 0, 9006, 9007, 5, 471, 0, 0, 9007, 9008, 5, 2, 0, 0, 9008, 9009, 3, 1074, 537, 0, 9009, 9010, 5, 3, 0, 0, 9010, 1085, 1, 0, 0, 0, 9011, 9012, 5, 67, 0, 0, 9012, 9013, 3, 1212, 606, 0, 9013, 1087, 1, 0, 0, 0, 9014, 9019, 3, 1092, 546, 0, 9015, 9016, 5, 62, 0, 0, 9016, 9017, 5, 300, 0, 0, 9017, 9019, 5, 81, 0, 0, 9018, 9014, 1, 0, 0, 0, 9018, 9015, 1, 0, 0, 0, 9019, 1089, 1, 0, 0, 0, 9020, 9021, 3, 1088, 544, 0, 9021, 1091, 1, 0, 0, 0, 9022, 9024, 3, 1094, 547, 0, 9023, 9022, 1, 0, 0, 0, 9024, 9025, 1, 0, 0, 0, 9025, 9023, 1, 0, 0, 0, 9025, 9026, 1, 0, 0, 0, 9026, 1093, 1, 0, 0, 0, 9027, 9029, 3, 1096, 548, 0, 9028, 9030, 3, 1098, 549, 0, 9029, 9028, 1, 0, 0, 0, 9029, 9030, 1, 0, 0, 0, 9030, 9032, 1, 0, 0, 0, 9031, 9033, 3, 980, 490, 0, 9032, 9031, 1, 0, 0, 0, 9032, 9033, 1, 0, 0, 0, 9033, 1095, 1, 0, 0, 0, 9034, 9044, 5, 62, 0, 0, 9035, 9036, 5, 269, 0, 0, 9036, 9038, 5, 245, 0, 0, 9037, 9035, 1, 0, 0, 0, 9037, 9038, 1, 0, 0, 0, 9038, 9039, 1, 0, 0, 0, 9039, 9045, 5, 369, 0, 0, 9040, 9042, 5, 245, 0, 0, 9041, 9040, 1, 0, 0, 0, 9041, 9042, 1, 0, 0, 0, 9042, 9043, 1, 0, 0, 0, 9043, 9045, 5, 334, 0, 0, 9044, 9037, 1, 0, 0, 0, 9044, 9041, 1, 0, 0, 0, 9045, 1097, 1, 0, 0, 0, 9046, 9047, 5, 275, 0, 0, 9047, 9048, 3, 1390, 695, 0, 9048, 1099, 1, 0, 0, 0, 9049, 9050, 5, 422, 0, 0, 9050, 9051, 5, 2, 0, 0, 9051, 9052, 3, 1328, 664, 0, 9052, 9060, 5, 3, 0, 0, 9053, 9054, 5, 6, 0, 0, 9054, 9055, 5, 2, 0, 0, 9055, 9056, 3, 1328, 664, 0, 9056, 9057, 5, 3, 0, 0, 9057, 9059, 1, 0, 0, 0, 9058, 9053, 1, 0, 0, 0, 9059, 9062, 1, 0, 0, 0, 9060, 9058, 1, 0, 0, 0, 9060, 9061, 1, 0, 0, 0, 9061, 1101, 1, 0, 0, 0, 9062, 9060, 1, 0, 0, 0, 9063, 9064, 5, 64, 0, 0, 9064, 9065, 3, 1104, 552, 0, 9065, 1103, 1, 0, 0, 0, 9066, 9071, 3, 1106, 553, 0, 9067, 9068, 5, 6, 0, 0, 9068, 9070, 3, 1106, 553, 0, 9069, 9067, 1, 0, 0, 0, 9070, 9073, 1, 0, 0, 0, 9071, 9069, 1, 0, 0, 0, 9071, 9072, 1, 0, 0, 0, 9072, 1105, 1, 0, 0, 0, 9073, 9071, 1, 0, 0, 0, 9074, 9077, 3, 1118, 559, 0, 9075, 9077, 3, 1120, 560, 0, 9076, 9074, 1, 0, 0, 0, 9076, 9075, 1, 0, 0, 0, 9077, 9079, 1, 0, 0, 0, 9078, 9080, 3, 1110, 555, 0, 9079, 9078, 1, 0, 0, 0, 9079, 9080, 1, 0, 0, 0, 9080, 9082, 1, 0, 0, 0, 9081, 9083, 3, 1130, 565, 0, 9082, 9081, 1, 0, 0, 0, 9082, 9083, 1, 0, 0, 0, 9083, 9136, 1, 0, 0, 0, 9084, 9086, 3, 1134, 567, 0, 9085, 9087, 3, 1112, 556, 0, 9086, 9085, 1, 0, 0, 0, 9086, 9087, 1, 0, 0, 0, 9087, 9136, 1, 0, 0, 0, 9088, 9090, 3, 1154, 577, 0, 9089, 9091, 3, 1110, 555, 0, 9090, 9089, 1, 0, 0, 0, 9090, 9091, 1, 0, 0, 0, 9091, 9136, 1, 0, 0, 0, 9092, 9094, 3, 1002, 501, 0, 9093, 9095, 3, 1110, 555, 0, 9094, 9093, 1, 0, 0, 0, 9094, 9095, 1, 0, 0, 0, 9095, 9136, 1, 0, 0, 0, 9096, 9109, 5, 72, 0, 0, 9097, 9099, 3, 1154, 577, 0, 9098, 9100, 3, 1110, 555, 0, 9099, 9098, 1, 0, 0, 0, 9099, 9100, 1, 0, 0, 0, 9100, 9110, 1, 0, 0, 0, 9101, 9103, 3, 1134, 567, 0, 9102, 9104, 3, 1112, 556, 0, 9103, 9102, 1, 0, 0, 0, 9103, 9104, 1, 0, 0, 0, 9104, 9110, 1, 0, 0, 0, 9105, 9107, 3, 1002, 501, 0, 9106, 9108, 3, 1110, 555, 0, 9107, 9106, 1, 0, 0, 0, 9107, 9108, 1, 0, 0, 0, 9108, 9110, 1, 0, 0, 0, 9109, 9097, 1, 0, 0, 0, 9109, 9101, 1, 0, 0, 0, 9109, 9105, 1, 0, 0, 0, 9110, 9136, 1, 0, 0, 0, 9111, 9112, 5, 2, 0, 0, 9112, 9129, 3, 1106, 553, 0, 9113, 9114, 5, 110, 0, 0, 9114, 9115, 5, 118, 0, 0, 9115, 9130, 3, 1106, 553, 0, 9116, 9118, 5, 121, 0, 0, 9117, 9119, 3, 1114, 557, 0, 9118, 9117, 1, 0, 0, 0, 9118, 9119, 1, 0, 0, 0, 9119, 9120, 1, 0, 0, 0, 9120, 9121, 5, 118, 0, 0, 9121, 9130, 3, 1106, 553, 0, 9122, 9124, 3, 1114, 557, 0, 9123, 9122, 1, 0, 0, 0, 9123, 9124, 1, 0, 0, 0, 9124, 9125, 1, 0, 0, 0, 9125, 9126, 5, 118, 0, 0, 9126, 9127, 3, 1106, 553, 0, 9127, 9128, 3, 1116, 558, 0, 9128, 9130, 1, 0, 0, 0, 9129, 9113, 1, 0, 0, 0, 9129, 9116, 1, 0, 0, 0, 9129, 9123, 1, 0, 0, 0, 9129, 9130, 1, 0, 0, 0, 9130, 9131, 1, 0, 0, 0, 9131, 9133, 5, 3, 0, 0, 9132, 9134, 3, 1110, 555, 0, 9133, 9132, 1, 0, 0, 0, 9133, 9134, 1, 0, 0, 0, 9134, 9136, 1, 0, 0, 0, 9135, 9076, 1, 0, 0, 0, 9135, 9084, 1, 0, 0, 0, 9135, 9088, 1, 0, 0, 0, 9135, 9092, 1, 0, 0, 0, 9135, 9096, 1, 0, 0, 0, 9135, 9111, 1, 0, 0, 0, 9136, 9155, 1, 0, 0, 0, 9137, 9138, 5, 110, 0, 0, 9138, 9139, 5, 118, 0, 0, 9139, 9154, 3, 1106, 553, 0, 9140, 9142, 5, 121, 0, 0, 9141, 9143, 3, 1114, 557, 0, 9142, 9141, 1, 0, 0, 0, 9142, 9143, 1, 0, 0, 0, 9143, 9144, 1, 0, 0, 0, 9144, 9145, 5, 118, 0, 0, 9145, 9154, 3, 1106, 553, 0, 9146, 9148, 3, 1114, 557, 0, 9147, 9146, 1, 0, 0, 0, 9147, 9148, 1, 0, 0, 0, 9148, 9149, 1, 0, 0, 0, 9149, 9150, 5, 118, 0, 0, 9150, 9151, 3, 1106, 553, 0, 9151, 9152, 3, 1116, 558, 0, 9152, 9154, 1, 0, 0, 0, 9153, 9137, 1, 0, 0, 0, 9153, 9140, 1, 0, 0, 0, 9153, 9147, 1, 0, 0, 0, 9154, 9157, 1, 0, 0, 0, 9155, 9153, 1, 0, 0, 0, 9155, 9156, 1, 0, 0, 0, 9156, 1107, 1, 0, 0, 0, 9157, 9155, 1, 0, 0, 0, 9158, 9160, 5, 36, 0, 0, 9159, 9158, 1, 0, 0, 0, 9159, 9160, 1, 0, 0, 0, 9160, 9161, 1, 0, 0, 0, 9161, 9166, 3, 1474, 737, 0, 9162, 9163, 5, 2, 0, 0, 9163, 9164, 3, 1416, 708, 0, 9164, 9165, 5, 3, 0, 0, 9165, 9167, 1, 0, 0, 0, 9166, 9162, 1, 0, 0, 0, 9166, 9167, 1, 0, 0, 0, 9167, 1109, 1, 0, 0, 0, 9168, 9169, 3, 1108, 554, 0, 9169, 1111, 1, 0, 0, 0, 9170, 9183, 3, 1108, 554, 0, 9171, 9173, 5, 36, 0, 0, 9172, 9174, 3, 1474, 737, 0, 9173, 9172, 1, 0, 0, 0, 9173, 9174, 1, 0, 0, 0, 9174, 9177, 1, 0, 0, 0, 9175, 9177, 3, 1474, 737, 0, 9176, 9171, 1, 0, 0, 0, 9176, 9175, 1, 0, 0, 0, 9177, 9178, 1, 0, 0, 0, 9178, 9179, 5, 2, 0, 0, 9179, 9180, 3, 1150, 575, 0, 9180, 9181, 5, 3, 0, 0, 9181, 9183, 1, 0, 0, 0, 9182, 9170, 1, 0, 0, 0, 9182, 9176, 1, 0, 0, 0, 9183, 1113, 1, 0, 0, 0, 9184, 9186, 7, 60, 0, 0, 9185, 9187, 5, 123, 0, 0, 9186, 9185, 1, 0, 0, 0, 9186, 9187, 1, 0, 0, 0, 9187, 1115, 1, 0, 0, 0, 9188, 9189, 5, 100, 0, 0, 9189, 9190, 5, 2, 0, 0, 9190, 9191, 3, 244, 122, 0, 9191, 9192, 5, 3, 0, 0, 9192, 9196, 1, 0, 0, 0, 9193, 9194, 5, 80, 0, 0, 9194, 9196, 3, 1212, 606, 0, 9195, 9188, 1, 0, 0, 0, 9195, 9193, 1, 0, 0, 0, 9196, 1117, 1, 0, 0, 0, 9197, 9199, 5, 81, 0, 0, 9198, 9197, 1, 0, 0, 0, 9198, 9199, 1, 0, 0, 0, 9199, 9200, 1, 0, 0, 0, 9200, 9202, 3, 1406, 703, 0, 9201, 9203, 5, 9, 0, 0, 9202, 9201, 1, 0, 0, 0, 9202, 9203, 1, 0, 0, 0, 9203, 9219, 1, 0, 0, 0, 9204, 9210, 5, 81, 0, 0, 9205, 9211, 3, 1406, 703, 0, 9206, 9207, 5, 2, 0, 0, 9207, 9208, 3, 1406, 703, 0, 9208, 9209, 5, 3, 0, 0, 9209, 9211, 1, 0, 0, 0, 9210, 9205, 1, 0, 0, 0, 9210, 9206, 1, 0, 0, 0, 9211, 9219, 1, 0, 0, 0, 9212, 9213, 5, 68, 0, 0, 9213, 9216, 5, 323, 0, 0, 9214, 9217, 3, 1422, 711, 0, 9215, 9217, 5, 111, 0, 0, 9216, 9214, 1, 0, 0, 0, 9216, 9215, 1, 0, 0, 0, 9217, 9219, 1, 0, 0, 0, 9218, 9198, 1, 0, 0, 0, 9218, 9204, 1, 0, 0, 0, 9218, 9212, 1, 0, 0, 0, 9219, 1119, 1, 0, 0, 0, 9220, 9222, 5, 81, 0, 0, 9221, 9220, 1, 0, 0, 0, 9221, 9222, 1, 0, 0, 0, 9222, 9223, 1, 0, 0, 0, 9223, 9225, 3, 1410, 705, 0, 9224, 9226, 5, 9, 0, 0, 9225, 9224, 1, 0, 0, 0, 9225, 9226, 1, 0, 0, 0, 9226, 9228, 1, 0, 0, 0, 9227, 9229, 3, 244, 122, 0, 9228, 9227, 1, 0, 0, 0, 9228, 9229, 1, 0, 0, 0, 9229, 9231, 1, 0, 0, 0, 9230, 9232, 3, 1144, 572, 0, 9231, 9230, 1, 0, 0, 0, 9231, 9232, 1, 0, 0, 0, 9232, 1121, 1, 0, 0, 0, 9233, 9235, 5, 92, 0, 0, 9234, 9236, 5, 81, 0, 0, 9235, 9234, 1, 0, 0, 0, 9235, 9236, 1, 0, 0, 0, 9236, 9237, 1, 0, 0, 0, 9237, 9239, 3, 1406, 703, 0, 9238, 9240, 5, 9, 0, 0, 9239, 9238, 1, 0, 0, 0, 9239, 9240, 1, 0, 0, 0, 9240, 9245, 1, 0, 0, 0, 9241, 9242, 5, 2, 0, 0, 9242, 9243, 3, 244, 122, 0, 9243, 9244, 5, 3, 0, 0, 9244, 9246, 1, 0, 0, 0, 9245, 9241, 1, 0, 0, 0, 9245, 9246, 1, 0, 0, 0, 9246, 9248, 1, 0, 0, 0, 9247, 9249, 3, 1144, 572, 0, 9248, 9247, 1, 0, 0, 0, 9248, 9249, 1, 0, 0, 0, 9249, 9267, 1, 0, 0, 0, 9250, 9251, 5, 92, 0, 0, 9251, 9257, 5, 81, 0, 0, 9252, 9258, 3, 1406, 703, 0, 9253, 9254, 5, 2, 0, 0, 9254, 9255, 3, 1406, 703, 0, 9255, 9256, 5, 3, 0, 0, 9256, 9258, 1, 0, 0, 0, 9257, 9252, 1, 0, 0, 0, 9257, 9253, 1, 0, 0, 0, 9258, 9267, 1, 0, 0, 0, 9259, 9260, 5, 350, 0, 0, 9260, 9261, 5, 68, 0, 0, 9261, 9264, 5, 323, 0, 0, 9262, 9265, 3, 1422, 711, 0, 9263, 9265, 5, 111, 0, 0, 9264, 9262, 1, 0, 0, 0, 9264, 9263, 1, 0, 0, 0, 9265, 9267, 1, 0, 0, 0, 9266, 9233, 1, 0, 0, 0, 9266, 9250, 1, 0, 0, 0, 9266, 9259, 1, 0, 0, 0, 9267, 1123, 1, 0, 0, 0, 9268, 9273, 3, 1118, 559, 0, 9269, 9270, 5, 6, 0, 0, 9270, 9272, 3, 1118, 559, 0, 9271, 9269, 1, 0, 0, 0, 9272, 9275, 1, 0, 0, 0, 9273, 9271, 1, 0, 0, 0, 9273, 9274, 1, 0, 0, 0, 9274, 1125, 1, 0, 0, 0, 9275, 9273, 1, 0, 0, 0, 9276, 9281, 3, 1122, 561, 0, 9277, 9278, 5, 6, 0, 0, 9278, 9280, 3, 1122, 561, 0, 9279, 9277, 1, 0, 0, 0, 9280, 9283, 1, 0, 0, 0, 9281, 9279, 1, 0, 0, 0, 9281, 9282, 1, 0, 0, 0, 9282, 1127, 1, 0, 0, 0, 9283, 9281, 1, 0, 0, 0, 9284, 9289, 3, 1118, 559, 0, 9285, 9287, 5, 36, 0, 0, 9286, 9285, 1, 0, 0, 0, 9286, 9287, 1, 0, 0, 0, 9287, 9288, 1, 0, 0, 0, 9288, 9290, 3, 1474, 737, 0, 9289, 9286, 1, 0, 0, 0, 9289, 9290, 1, 0, 0, 0, 9290, 1129, 1, 0, 0, 0, 9291, 9292, 5, 472, 0, 0, 9292, 9293, 3, 1444, 722, 0, 9293, 9294, 5, 2, 0, 0, 9294, 9295, 3, 1328, 664, 0, 9295, 9297, 5, 3, 0, 0, 9296, 9298, 3, 1132, 566, 0, 9297, 9296, 1, 0, 0, 0, 9297, 9298, 1, 0, 0, 0, 9298, 1131, 1, 0, 0, 0, 9299, 9300, 5, 310, 0, 0, 9300, 9301, 5, 2, 0, 0, 9301, 9302, 3, 1212, 606, 0, 9302, 9303, 5, 3, 0, 0, 9303, 1133, 1, 0, 0, 0, 9304, 9306, 3, 1262, 631, 0, 9305, 9307, 3, 1142, 571, 0, 9306, 9305, 1, 0, 0, 0, 9306, 9307, 1, 0, 0, 0, 9307, 9317, 1, 0, 0, 0, 9308, 9309, 5, 320, 0, 0, 9309, 9310, 5, 64, 0, 0, 9310, 9311, 5, 2, 0, 0, 9311, 9312, 3, 1138, 569, 0, 9312, 9314, 5, 3, 0, 0, 9313, 9315, 3, 1142, 571, 0, 9314, 9313, 1, 0, 0, 0, 9314, 9315, 1, 0, 0, 0, 9315, 9317, 1, 0, 0, 0, 9316, 9304, 1, 0, 0, 0, 9316, 9308, 1, 0, 0, 0, 9317, 1135, 1, 0, 0, 0, 9318, 9320, 3, 1262, 631, 0, 9319, 9321, 3, 1140, 570, 0, 9320, 9319, 1, 0, 0, 0, 9320, 9321, 1, 0, 0, 0, 9321, 1137, 1, 0, 0, 0, 9322, 9327, 3, 1136, 568, 0, 9323, 9324, 5, 6, 0, 0, 9324, 9326, 3, 1136, 568, 0, 9325, 9323, 1, 0, 0, 0, 9326, 9329, 1, 0, 0, 0, 9327, 9325, 1, 0, 0, 0, 9327, 9328, 1, 0, 0, 0, 9328, 1139, 1, 0, 0, 0, 9329, 9327, 1, 0, 0, 0, 9330, 9331, 5, 36, 0, 0, 9331, 9332, 5, 2, 0, 0, 9332, 9333, 3, 1150, 575, 0, 9333, 9334, 5, 3, 0, 0, 9334, 1141, 1, 0, 0, 0, 9335, 9336, 5, 105, 0, 0, 9336, 9337, 5, 473, 0, 0, 9337, 1143, 1, 0, 0, 0, 9338, 9339, 5, 103, 0, 0, 9339, 9340, 3, 1336, 668, 0, 9340, 1145, 1, 0, 0, 0, 9341, 9346, 5, 103, 0, 0, 9342, 9343, 5, 434, 0, 0, 9343, 9344, 5, 275, 0, 0, 9344, 9347, 3, 994, 497, 0, 9345, 9347, 3, 1212, 606, 0, 9346, 9342, 1, 0, 0, 0, 9346, 9345, 1, 0, 0, 0, 9347, 1147, 1, 0, 0, 0, 9348, 9349, 3, 1150, 575, 0, 9349, 1149, 1, 0, 0, 0, 9350, 9355, 3, 1152, 576, 0, 9351, 9352, 5, 6, 0, 0, 9352, 9354, 3, 1152, 576, 0, 9353, 9351, 1, 0, 0, 0, 9354, 9357, 1, 0, 0, 0, 9355, 9353, 1, 0, 0, 0, 9355, 9356, 1, 0, 0, 0, 9356, 1151, 1, 0, 0, 0, 9357, 9355, 1, 0, 0, 0, 9358, 9359, 3, 1474, 737, 0, 9359, 9361, 3, 1168, 584, 0, 9360, 9362, 3, 126, 63, 0, 9361, 9360, 1, 0, 0, 0, 9361, 9362, 1, 0, 0, 0, 9362, 1153, 1, 0, 0, 0, 9363, 9364, 5, 474, 0, 0, 9364, 9380, 5, 2, 0, 0, 9365, 9366, 3, 1254, 627, 0, 9366, 9367, 3, 1280, 640, 0, 9367, 9368, 5, 475, 0, 0, 9368, 9369, 3, 1156, 578, 0, 9369, 9381, 1, 0, 0, 0, 9370, 9371, 5, 476, 0, 0, 9371, 9372, 5, 2, 0, 0, 9372, 9373, 3, 1164, 582, 0, 9373, 9374, 5, 3, 0, 0, 9374, 9375, 5, 6, 0, 0, 9375, 9376, 3, 1254, 627, 0, 9376, 9377, 3, 1280, 640, 0, 9377, 9378, 5, 475, 0, 0, 9378, 9379, 3, 1156, 578, 0, 9379, 9381, 1, 0, 0, 0, 9380, 9365, 1, 0, 0, 0, 9380, 9370, 1, 0, 0, 0, 9381, 9382, 1, 0, 0, 0, 9382, 9383, 5, 3, 0, 0, 9383, 1155, 1, 0, 0, 0, 9384, 9389, 3, 1158, 579, 0, 9385, 9386, 5, 6, 0, 0, 9386, 9388, 3, 1158, 579, 0, 9387, 9385, 1, 0, 0, 0, 9388, 9391, 1, 0, 0, 0, 9389, 9387, 1, 0, 0, 0, 9389, 9390, 1, 0, 0, 0, 9390, 1157, 1, 0, 0, 0, 9391, 9389, 1, 0, 0, 0, 9392, 9399, 3, 1474, 737, 0, 9393, 9395, 3, 1168, 584, 0, 9394, 9396, 3, 1160, 580, 0, 9395, 9394, 1, 0, 0, 0, 9395, 9396, 1, 0, 0, 0, 9396, 9400, 1, 0, 0, 0, 9397, 9398, 5, 62, 0, 0, 9398, 9400, 5, 473, 0, 0, 9399, 9393, 1, 0, 0, 0, 9399, 9397, 1, 0, 0, 0, 9400, 1159, 1, 0, 0, 0, 9401, 9403, 3, 1162, 581, 0, 9402, 9401, 1, 0, 0, 0, 9403, 9404, 1, 0, 0, 0, 9404, 9402, 1, 0, 0, 0, 9404, 9405, 1, 0, 0, 0, 9405, 1161, 1, 0, 0, 0, 9406, 9407, 5, 53, 0, 0, 9407, 9415, 3, 1212, 606, 0, 9408, 9409, 3, 1492, 746, 0, 9409, 9410, 3, 1212, 606, 0, 9410, 9415, 1, 0, 0, 0, 9411, 9412, 5, 77, 0, 0, 9412, 9415, 5, 78, 0, 0, 9413, 9415, 5, 78, 0, 0, 9414, 9406, 1, 0, 0, 0, 9414, 9408, 1, 0, 0, 0, 9414, 9411, 1, 0, 0, 0, 9414, 9413, 1, 0, 0, 0, 9415, 1163, 1, 0, 0, 0, 9416, 9421, 3, 1166, 583, 0, 9417, 9418, 5, 6, 0, 0, 9418, 9420, 3, 1166, 583, 0, 9419, 9417, 1, 0, 0, 0, 9420, 9423, 1, 0, 0, 0, 9421, 9419, 1, 0, 0, 0, 9421, 9422, 1, 0, 0, 0, 9422, 1165, 1, 0, 0, 0, 9423, 9421, 1, 0, 0, 0, 9424, 9425, 3, 1252, 626, 0, 9425, 9426, 5, 36, 0, 0, 9426, 9427, 3, 1490, 745, 0, 9427, 9431, 1, 0, 0, 0, 9428, 9429, 5, 53, 0, 0, 9429, 9431, 3, 1252, 626, 0, 9430, 9424, 1, 0, 0, 0, 9430, 9428, 1, 0, 0, 0, 9431, 1167, 1, 0, 0, 0, 9432, 9434, 5, 415, 0, 0, 9433, 9432, 1, 0, 0, 0, 9433, 9434, 1, 0, 0, 0, 9434, 9435, 1, 0, 0, 0, 9435, 9444, 3, 1172, 586, 0, 9436, 9445, 3, 1170, 585, 0, 9437, 9442, 5, 35, 0, 0, 9438, 9439, 5, 4, 0, 0, 9439, 9440, 3, 1456, 728, 0, 9440, 9441, 5, 5, 0, 0, 9441, 9443, 1, 0, 0, 0, 9442, 9438, 1, 0, 0, 0, 9442, 9443, 1, 0, 0, 0, 9443, 9445, 1, 0, 0, 0, 9444, 9436, 1, 0, 0, 0, 9444, 9437, 1, 0, 0, 0, 9445, 9451, 1, 0, 0, 0, 9446, 9447, 3, 1412, 706, 0, 9447, 9448, 5, 27, 0, 0, 9448, 9449, 7, 61, 0, 0, 9449, 9451, 1, 0, 0, 0, 9450, 9433, 1, 0, 0, 0, 9450, 9446, 1, 0, 0, 0, 9451, 1169, 1, 0, 0, 0, 9452, 9454, 5, 4, 0, 0, 9453, 9455, 3, 1456, 728, 0, 9454, 9453, 1, 0, 0, 0, 9454, 9455, 1, 0, 0, 0, 9455, 9456, 1, 0, 0, 0, 9456, 9458, 5, 5, 0, 0, 9457, 9452, 1, 0, 0, 0, 9458, 9461, 1, 0, 0, 0, 9459, 9457, 1, 0, 0, 0, 9459, 9460, 1, 0, 0, 0, 9460, 1171, 1, 0, 0, 0, 9461, 9459, 1, 0, 0, 0, 9462, 9478, 3, 1176, 588, 0, 9463, 9478, 3, 1180, 590, 0, 9464, 9478, 3, 1184, 592, 0, 9465, 9478, 3, 1192, 596, 0, 9466, 9478, 3, 1200, 600, 0, 9467, 9475, 3, 1202, 601, 0, 9468, 9470, 3, 1206, 603, 0, 9469, 9468, 1, 0, 0, 0, 9469, 9470, 1, 0, 0, 0, 9470, 9476, 1, 0, 0, 0, 9471, 9472, 5, 2, 0, 0, 9472, 9473, 3, 1456, 728, 0, 9473, 9474, 5, 3, 0, 0, 9474, 9476, 1, 0, 0, 0, 9475, 9469, 1, 0, 0, 0, 9475, 9471, 1, 0, 0, 0, 9476, 9478, 1, 0, 0, 0, 9477, 9462, 1, 0, 0, 0, 9477, 9463, 1, 0, 0, 0, 9477, 9464, 1, 0, 0, 0, 9477, 9465, 1, 0, 0, 0, 9477, 9466, 1, 0, 0, 0, 9477, 9467, 1, 0, 0, 0, 9478, 1173, 1, 0, 0, 0, 9479, 9484, 3, 1180, 590, 0, 9480, 9484, 3, 1186, 593, 0, 9481, 9484, 3, 1194, 597, 0, 9482, 9484, 3, 1200, 600, 0, 9483, 9479, 1, 0, 0, 0, 9483, 9480, 1, 0, 0, 0, 9483, 9481, 1, 0, 0, 0, 9483, 9482, 1, 0, 0, 0, 9484, 1175, 1, 0, 0, 0, 9485, 9487, 3, 1482, 741, 0, 9486, 9488, 3, 560, 280, 0, 9487, 9486, 1, 0, 0, 0, 9487, 9488, 1, 0, 0, 0, 9488, 9490, 1, 0, 0, 0, 9489, 9491, 3, 1178, 589, 0, 9490, 9489, 1, 0, 0, 0, 9490, 9491, 1, 0, 0, 0, 9491, 1177, 1, 0, 0, 0, 9492, 9493, 5, 2, 0, 0, 9493, 9494, 3, 1328, 664, 0, 9494, 9495, 5, 3, 0, 0, 9495, 1179, 1, 0, 0, 0, 9496, 9521, 5, 401, 0, 0, 9497, 9521, 5, 402, 0, 0, 9498, 9521, 5, 416, 0, 0, 9499, 9521, 5, 388, 0, 0, 9500, 9521, 5, 413, 0, 0, 9501, 9503, 5, 398, 0, 0, 9502, 9504, 3, 1182, 591, 0, 9503, 9502, 1, 0, 0, 0, 9503, 9504, 1, 0, 0, 0, 9504, 9521, 1, 0, 0, 0, 9505, 9506, 5, 190, 0, 0, 9506, 9521, 5, 412, 0, 0, 9507, 9509, 5, 395, 0, 0, 9508, 9510, 3, 1178, 589, 0, 9509, 9508, 1, 0, 0, 0, 9509, 9510, 1, 0, 0, 0, 9510, 9521, 1, 0, 0, 0, 9511, 9513, 5, 394, 0, 0, 9512, 9514, 3, 1178, 589, 0, 9513, 9512, 1, 0, 0, 0, 9513, 9514, 1, 0, 0, 0, 9514, 9521, 1, 0, 0, 0, 9515, 9517, 5, 409, 0, 0, 9516, 9518, 3, 1178, 589, 0, 9517, 9516, 1, 0, 0, 0, 9517, 9518, 1, 0, 0, 0, 9518, 9521, 1, 0, 0, 0, 9519, 9521, 5, 390, 0, 0, 9520, 9496, 1, 0, 0, 0, 9520, 9497, 1, 0, 0, 0, 9520, 9498, 1, 0, 0, 0, 9520, 9499, 1, 0, 0, 0, 9520, 9500, 1, 0, 0, 0, 9520, 9501, 1, 0, 0, 0, 9520, 9505, 1, 0, 0, 0, 9520, 9507, 1, 0, 0, 0, 9520, 9511, 1, 0, 0, 0, 9520, 9515, 1, 0, 0, 0, 9520, 9519, 1, 0, 0, 0, 9521, 1181, 1, 0, 0, 0, 9522, 9523, 5, 2, 0, 0, 9523, 9524, 3, 1456, 728, 0, 9524, 9525, 5, 3, 0, 0, 9525, 1183, 1, 0, 0, 0, 9526, 9529, 3, 1188, 594, 0, 9527, 9529, 3, 1190, 595, 0, 9528, 9526, 1, 0, 0, 0, 9528, 9527, 1, 0, 0, 0, 9529, 1185, 1, 0, 0, 0, 9530, 9533, 3, 1188, 594, 0, 9531, 9533, 3, 1190, 595, 0, 9532, 9530, 1, 0, 0, 0, 9532, 9531, 1, 0, 0, 0, 9533, 1187, 1, 0, 0, 0, 9534, 9536, 5, 389, 0, 0, 9535, 9537, 3, 1198, 599, 0, 9536, 9535, 1, 0, 0, 0, 9536, 9537, 1, 0, 0, 0, 9537, 9538, 1, 0, 0, 0, 9538, 9539, 5, 2, 0, 0, 9539, 9540, 3, 1328, 664, 0, 9540, 9541, 5, 3, 0, 0, 9541, 1189, 1, 0, 0, 0, 9542, 9544, 5, 389, 0, 0, 9543, 9545, 3, 1198, 599, 0, 9544, 9543, 1, 0, 0, 0, 9544, 9545, 1, 0, 0, 0, 9545, 1191, 1, 0, 0, 0, 9546, 9551, 3, 1196, 598, 0, 9547, 9548, 5, 2, 0, 0, 9548, 9549, 3, 1456, 728, 0, 9549, 9550, 5, 3, 0, 0, 9550, 9552, 1, 0, 0, 0, 9551, 9547, 1, 0, 0, 0, 9551, 9552, 1, 0, 0, 0, 9552, 1193, 1, 0, 0, 0, 9553, 9558, 3, 1196, 598, 0, 9554, 9555, 5, 2, 0, 0, 9555, 9556, 3, 1456, 728, 0, 9556, 9557, 5, 3, 0, 0, 9557, 9559, 1, 0, 0, 0, 9558, 9554, 1, 0, 0, 0, 9558, 9559, 1, 0, 0, 0, 9559, 1195, 1, 0, 0, 0, 9560, 9562, 7, 62, 0, 0, 9561, 9563, 3, 1198, 599, 0, 9562, 9561, 1, 0, 0, 0, 9562, 9563, 1, 0, 0, 0, 9563, 9571, 1, 0, 0, 0, 9564, 9571, 5, 423, 0, 0, 9565, 9566, 5, 405, 0, 0, 9566, 9568, 7, 63, 0, 0, 9567, 9569, 3, 1198, 599, 0, 9568, 9567, 1, 0, 0, 0, 9568, 9569, 1, 0, 0, 0, 9569, 9571, 1, 0, 0, 0, 9570, 9560, 1, 0, 0, 0, 9570, 9564, 1, 0, 0, 0, 9570, 9565, 1, 0, 0, 0, 9571, 1197, 1, 0, 0, 0, 9572, 9573, 5, 374, 0, 0, 9573, 1199, 1, 0, 0, 0, 9574, 9579, 7, 64, 0, 0, 9575, 9576, 5, 2, 0, 0, 9576, 9577, 3, 1456, 728, 0, 9577, 9578, 5, 3, 0, 0, 9578, 9580, 1, 0, 0, 0, 9579, 9575, 1, 0, 0, 0, 9579, 9580, 1, 0, 0, 0, 9580, 9582, 1, 0, 0, 0, 9581, 9583, 3, 1204, 602, 0, 9582, 9581, 1, 0, 0, 0, 9582, 9583, 1, 0, 0, 0, 9583, 1201, 1, 0, 0, 0, 9584, 9585, 5, 403, 0, 0, 9585, 1203, 1, 0, 0, 0, 9586, 9587, 5, 105, 0, 0, 9587, 9588, 5, 418, 0, 0, 9588, 9593, 5, 386, 0, 0, 9589, 9590, 5, 379, 0, 0, 9590, 9591, 5, 418, 0, 0, 9591, 9593, 5, 386, 0, 0, 9592, 9586, 1, 0, 0, 0, 9592, 9589, 1, 0, 0, 0, 9593, 1205, 1, 0, 0, 0, 9594, 9620, 5, 384, 0, 0, 9595, 9620, 5, 264, 0, 0, 9596, 9620, 5, 176, 0, 0, 9597, 9620, 5, 218, 0, 0, 9598, 9620, 5, 261, 0, 0, 9599, 9620, 3, 1208, 604, 0, 9600, 9601, 5, 384, 0, 0, 9601, 9602, 5, 94, 0, 0, 9602, 9620, 5, 264, 0, 0, 9603, 9604, 5, 176, 0, 0, 9604, 9608, 5, 94, 0, 0, 9605, 9609, 5, 218, 0, 0, 9606, 9609, 5, 261, 0, 0, 9607, 9609, 3, 1208, 604, 0, 9608, 9605, 1, 0, 0, 0, 9608, 9606, 1, 0, 0, 0, 9608, 9607, 1, 0, 0, 0, 9609, 9620, 1, 0, 0, 0, 9610, 9611, 5, 218, 0, 0, 9611, 9614, 5, 94, 0, 0, 9612, 9615, 5, 261, 0, 0, 9613, 9615, 3, 1208, 604, 0, 9614, 9612, 1, 0, 0, 0, 9614, 9613, 1, 0, 0, 0, 9615, 9620, 1, 0, 0, 0, 9616, 9617, 5, 261, 0, 0, 9617, 9618, 5, 94, 0, 0, 9618, 9620, 3, 1208, 604, 0, 9619, 9594, 1, 0, 0, 0, 9619, 9595, 1, 0, 0, 0, 9619, 9596, 1, 0, 0, 0, 9619, 9597, 1, 0, 0, 0, 9619, 9598, 1, 0, 0, 0, 9619, 9599, 1, 0, 0, 0, 9619, 9600, 1, 0, 0, 0, 9619, 9603, 1, 0, 0, 0, 9619, 9610, 1, 0, 0, 0, 9619, 9616, 1, 0, 0, 0, 9620, 1207, 1, 0, 0, 0, 9621, 9626, 5, 326, 0, 0, 9622, 9623, 5, 2, 0, 0, 9623, 9624, 3, 1456, 728, 0, 9624, 9625, 5, 3, 0, 0, 9625, 9627, 1, 0, 0, 0, 9626, 9622, 1, 0, 0, 0, 9626, 9627, 1, 0, 0, 0, 9627, 1209, 1, 0, 0, 0, 9628, 9629, 5, 197, 0, 0, 9629, 9630, 3, 1212, 606, 0, 9630, 1211, 1, 0, 0, 0, 9631, 9632, 3, 1214, 607, 0, 9632, 1213, 1, 0, 0, 0, 9633, 9635, 3, 1216, 608, 0, 9634, 9636, 3, 1322, 661, 0, 9635, 9634, 1, 0, 0, 0, 9635, 9636, 1, 0, 0, 0, 9636, 1215, 1, 0, 0, 0, 9637, 9642, 3, 1218, 609, 0, 9638, 9639, 7, 65, 0, 0, 9639, 9641, 3, 1218, 609, 0, 9640, 9638, 1, 0, 0, 0, 9641, 9644, 1, 0, 0, 0, 9642, 9640, 1, 0, 0, 0, 9642, 9643, 1, 0, 0, 0, 9643, 1217, 1, 0, 0, 0, 9644, 9642, 1, 0, 0, 0, 9645, 9650, 3, 1220, 610, 0, 9646, 9647, 5, 82, 0, 0, 9647, 9649, 3, 1220, 610, 0, 9648, 9646, 1, 0, 0, 0, 9649, 9652, 1, 0, 0, 0, 9650, 9648, 1, 0, 0, 0, 9650, 9651, 1, 0, 0, 0, 9651, 1219, 1, 0, 0, 0, 9652, 9650, 1, 0, 0, 0, 9653, 9658, 3, 1222, 611, 0, 9654, 9655, 5, 33, 0, 0, 9655, 9657, 3, 1222, 611, 0, 9656, 9654, 1, 0, 0, 0, 9657, 9660, 1, 0, 0, 0, 9658, 9656, 1, 0, 0, 0, 9658, 9659, 1, 0, 0, 0, 9659, 1221, 1, 0, 0, 0, 9660, 9658, 1, 0, 0, 0, 9661, 9667, 3, 1224, 612, 0, 9662, 9664, 5, 77, 0, 0, 9663, 9662, 1, 0, 0, 0, 9663, 9664, 1, 0, 0, 0, 9664, 9665, 1, 0, 0, 0, 9665, 9666, 5, 68, 0, 0, 9666, 9668, 3, 1362, 681, 0, 9667, 9663, 1, 0, 0, 0, 9667, 9668, 1, 0, 0, 0, 9668, 1223, 1, 0, 0, 0, 9669, 9671, 5, 77, 0, 0, 9670, 9669, 1, 0, 0, 0, 9670, 9671, 1, 0, 0, 0, 9671, 9672, 1, 0, 0, 0, 9672, 9673, 3, 1226, 613, 0, 9673, 1225, 1, 0, 0, 0, 9674, 9676, 3, 1228, 614, 0, 9675, 9677, 7, 66, 0, 0, 9676, 9675, 1, 0, 0, 0, 9676, 9677, 1, 0, 0, 0, 9677, 1227, 1, 0, 0, 0, 9678, 9702, 3, 1230, 615, 0, 9679, 9681, 5, 116, 0, 0, 9680, 9682, 5, 77, 0, 0, 9681, 9680, 1, 0, 0, 0, 9681, 9682, 1, 0, 0, 0, 9682, 9700, 1, 0, 0, 0, 9683, 9701, 5, 78, 0, 0, 9684, 9701, 5, 96, 0, 0, 9685, 9701, 5, 60, 0, 0, 9686, 9701, 5, 365, 0, 0, 9687, 9688, 5, 56, 0, 0, 9688, 9689, 5, 64, 0, 0, 9689, 9701, 3, 1212, 606, 0, 9690, 9691, 5, 275, 0, 0, 9691, 9692, 5, 2, 0, 0, 9692, 9693, 3, 1342, 671, 0, 9693, 9694, 5, 3, 0, 0, 9694, 9701, 1, 0, 0, 0, 9695, 9701, 5, 188, 0, 0, 9696, 9698, 3, 1352, 676, 0, 9697, 9696, 1, 0, 0, 0, 9697, 9698, 1, 0, 0, 0, 9698, 9699, 1, 0, 0, 0, 9699, 9701, 5, 478, 0, 0, 9700, 9683, 1, 0, 0, 0, 9700, 9684, 1, 0, 0, 0, 9700, 9685, 1, 0, 0, 0, 9700, 9686, 1, 0, 0, 0, 9700, 9687, 1, 0, 0, 0, 9700, 9690, 1, 0, 0, 0, 9700, 9695, 1, 0, 0, 0, 9700, 9697, 1, 0, 0, 0, 9701, 9703, 1, 0, 0, 0, 9702, 9679, 1, 0, 0, 0, 9702, 9703, 1, 0, 0, 0, 9703, 1229, 1, 0, 0, 0, 9704, 9716, 3, 1232, 616, 0, 9705, 9706, 7, 67, 0, 0, 9706, 9717, 3, 1232, 616, 0, 9707, 9708, 3, 1326, 663, 0, 9708, 9714, 3, 1316, 658, 0, 9709, 9715, 3, 1002, 501, 0, 9710, 9711, 5, 2, 0, 0, 9711, 9712, 3, 1212, 606, 0, 9712, 9713, 5, 3, 0, 0, 9713, 9715, 1, 0, 0, 0, 9714, 9709, 1, 0, 0, 0, 9714, 9710, 1, 0, 0, 0, 9715, 9717, 1, 0, 0, 0, 9716, 9705, 1, 0, 0, 0, 9716, 9707, 1, 0, 0, 0, 9716, 9717, 1, 0, 0, 0, 9717, 1231, 1, 0, 0, 0, 9718, 9736, 3, 1234, 617, 0, 9719, 9721, 5, 77, 0, 0, 9720, 9719, 1, 0, 0, 0, 9720, 9721, 1, 0, 0, 0, 9721, 9730, 1, 0, 0, 0, 9722, 9731, 5, 120, 0, 0, 9723, 9731, 5, 114, 0, 0, 9724, 9725, 5, 127, 0, 0, 9725, 9731, 5, 94, 0, 0, 9726, 9728, 5, 387, 0, 0, 9727, 9729, 5, 91, 0, 0, 9728, 9727, 1, 0, 0, 0, 9728, 9729, 1, 0, 0, 0, 9729, 9731, 1, 0, 0, 0, 9730, 9722, 1, 0, 0, 0, 9730, 9723, 1, 0, 0, 0, 9730, 9724, 1, 0, 0, 0, 9730, 9726, 1, 0, 0, 0, 9731, 9732, 1, 0, 0, 0, 9732, 9734, 3, 1234, 617, 0, 9733, 9735, 3, 1210, 605, 0, 9734, 9733, 1, 0, 0, 0, 9734, 9735, 1, 0, 0, 0, 9735, 9737, 1, 0, 0, 0, 9736, 9720, 1, 0, 0, 0, 9736, 9737, 1, 0, 0, 0, 9737, 1233, 1, 0, 0, 0, 9738, 9744, 3, 1236, 618, 0, 9739, 9740, 3, 1322, 661, 0, 9740, 9741, 3, 1236, 618, 0, 9741, 9743, 1, 0, 0, 0, 9742, 9739, 1, 0, 0, 0, 9743, 9746, 1, 0, 0, 0, 9744, 9742, 1, 0, 0, 0, 9744, 9745, 1, 0, 0, 0, 9745, 1235, 1, 0, 0, 0, 9746, 9744, 1, 0, 0, 0, 9747, 9749, 3, 1322, 661, 0, 9748, 9747, 1, 0, 0, 0, 9748, 9749, 1, 0, 0, 0, 9749, 9750, 1, 0, 0, 0, 9750, 9751, 3, 1238, 619, 0, 9751, 1237, 1, 0, 0, 0, 9752, 9757, 3, 1240, 620, 0, 9753, 9754, 7, 68, 0, 0, 9754, 9756, 3, 1240, 620, 0, 9755, 9753, 1, 0, 0, 0, 9756, 9759, 1, 0, 0, 0, 9757, 9755, 1, 0, 0, 0, 9757, 9758, 1, 0, 0, 0, 9758, 1239, 1, 0, 0, 0, 9759, 9757, 1, 0, 0, 0, 9760, 9765, 3, 1242, 621, 0, 9761, 9762, 7, 69, 0, 0, 9762, 9764, 3, 1242, 621, 0, 9763, 9761, 1, 0, 0, 0, 9764, 9767, 1, 0, 0, 0, 9765, 9763, 1, 0, 0, 0, 9765, 9766, 1, 0, 0, 0, 9766, 1241, 1, 0, 0, 0, 9767, 9765, 1, 0, 0, 0, 9768, 9771, 3, 1244, 622, 0, 9769, 9770, 5, 15, 0, 0, 9770, 9772, 3, 1212, 606, 0, 9771, 9769, 1, 0, 0, 0, 9771, 9772, 1, 0, 0, 0, 9772, 1243, 1, 0, 0, 0, 9773, 9775, 7, 68, 0, 0, 9774, 9773, 1, 0, 0, 0, 9774, 9775, 1, 0, 0, 0, 9775, 9776, 1, 0, 0, 0, 9776, 9777, 3, 1246, 623, 0, 9777, 1245, 1, 0, 0, 0, 9778, 9783, 3, 1248, 624, 0, 9779, 9780, 5, 142, 0, 0, 9780, 9781, 5, 418, 0, 0, 9781, 9782, 5, 386, 0, 0, 9782, 9784, 3, 1212, 606, 0, 9783, 9779, 1, 0, 0, 0, 9783, 9784, 1, 0, 0, 0, 9784, 1247, 1, 0, 0, 0, 9785, 9788, 3, 1250, 625, 0, 9786, 9787, 5, 43, 0, 0, 9787, 9789, 3, 558, 279, 0, 9788, 9786, 1, 0, 0, 0, 9788, 9789, 1, 0, 0, 0, 9789, 1249, 1, 0, 0, 0, 9790, 9795, 3, 1254, 627, 0, 9791, 9792, 5, 26, 0, 0, 9792, 9794, 3, 1168, 584, 0, 9793, 9791, 1, 0, 0, 0, 9794, 9797, 1, 0, 0, 0, 9795, 9793, 1, 0, 0, 0, 9795, 9796, 1, 0, 0, 0, 9796, 1251, 1, 0, 0, 0, 9797, 9795, 1, 0, 0, 0, 9798, 9799, 6, 626, -1, 0, 9799, 9806, 3, 1254, 627, 0, 9800, 9801, 7, 68, 0, 0, 9801, 9806, 3, 1252, 626, 9, 9802, 9803, 3, 1322, 661, 0, 9803, 9804, 3, 1252, 626, 3, 9804, 9806, 1, 0, 0, 0, 9805, 9798, 1, 0, 0, 0, 9805, 9800, 1, 0, 0, 0, 9805, 9802, 1, 0, 0, 0, 9806, 9846, 1, 0, 0, 0, 9807, 9808, 10, 8, 0, 0, 9808, 9809, 5, 15, 0, 0, 9809, 9845, 3, 1252, 626, 9, 9810, 9811, 10, 7, 0, 0, 9811, 9812, 7, 69, 0, 0, 9812, 9845, 3, 1252, 626, 8, 9813, 9814, 10, 6, 0, 0, 9814, 9815, 7, 68, 0, 0, 9815, 9845, 3, 1252, 626, 7, 9816, 9817, 10, 5, 0, 0, 9817, 9818, 3, 1322, 661, 0, 9818, 9819, 3, 1252, 626, 6, 9819, 9845, 1, 0, 0, 0, 9820, 9821, 10, 4, 0, 0, 9821, 9822, 7, 67, 0, 0, 9822, 9845, 3, 1252, 626, 5, 9823, 9824, 10, 10, 0, 0, 9824, 9825, 5, 26, 0, 0, 9825, 9845, 3, 1168, 584, 0, 9826, 9827, 10, 2, 0, 0, 9827, 9845, 3, 1322, 661, 0, 9828, 9829, 10, 1, 0, 0, 9829, 9831, 5, 116, 0, 0, 9830, 9832, 5, 77, 0, 0, 9831, 9830, 1, 0, 0, 0, 9831, 9832, 1, 0, 0, 0, 9832, 9842, 1, 0, 0, 0, 9833, 9834, 5, 56, 0, 0, 9834, 9835, 5, 64, 0, 0, 9835, 9843, 3, 1252, 626, 0, 9836, 9837, 5, 275, 0, 0, 9837, 9838, 5, 2, 0, 0, 9838, 9839, 3, 1342, 671, 0, 9839, 9840, 5, 3, 0, 0, 9840, 9843, 1, 0, 0, 0, 9841, 9843, 5, 188, 0, 0, 9842, 9833, 1, 0, 0, 0, 9842, 9836, 1, 0, 0, 0, 9842, 9841, 1, 0, 0, 0, 9843, 9845, 1, 0, 0, 0, 9844, 9807, 1, 0, 0, 0, 9844, 9810, 1, 0, 0, 0, 9844, 9813, 1, 0, 0, 0, 9844, 9816, 1, 0, 0, 0, 9844, 9820, 1, 0, 0, 0, 9844, 9823, 1, 0, 0, 0, 9844, 9826, 1, 0, 0, 0, 9844, 9828, 1, 0, 0, 0, 9845, 9848, 1, 0, 0, 0, 9846, 9844, 1, 0, 0, 0, 9846, 9847, 1, 0, 0, 0, 9847, 1253, 1, 0, 0, 0, 9848, 9846, 1, 0, 0, 0, 9849, 9850, 5, 396, 0, 0, 9850, 9886, 3, 1002, 501, 0, 9851, 9854, 5, 35, 0, 0, 9852, 9855, 3, 1002, 501, 0, 9853, 9855, 3, 1344, 672, 0, 9854, 9852, 1, 0, 0, 0, 9854, 9853, 1, 0, 0, 0, 9855, 9886, 1, 0, 0, 0, 9856, 9857, 5, 28, 0, 0, 9857, 9886, 3, 1382, 691, 0, 9858, 9859, 5, 470, 0, 0, 9859, 9860, 5, 2, 0, 0, 9860, 9861, 3, 1328, 664, 0, 9861, 9862, 5, 3, 0, 0, 9862, 9886, 1, 0, 0, 0, 9863, 9864, 5, 98, 0, 0, 9864, 9886, 3, 1002, 501, 0, 9865, 9886, 3, 1448, 724, 0, 9866, 9886, 3, 1256, 628, 0, 9867, 9868, 5, 2, 0, 0, 9868, 9869, 3, 1212, 606, 0, 9869, 9870, 5, 3, 0, 0, 9870, 9871, 3, 1382, 691, 0, 9871, 9886, 1, 0, 0, 0, 9872, 9886, 3, 1364, 682, 0, 9873, 9886, 3, 1260, 630, 0, 9874, 9876, 3, 1002, 501, 0, 9875, 9877, 3, 1380, 690, 0, 9876, 9875, 1, 0, 0, 0, 9876, 9877, 1, 0, 0, 0, 9877, 9886, 1, 0, 0, 0, 9878, 9886, 3, 1312, 656, 0, 9879, 9886, 3, 1314, 657, 0, 9880, 9881, 3, 1310, 655, 0, 9881, 9882, 5, 125, 0, 0, 9882, 9883, 3, 1310, 655, 0, 9883, 9886, 1, 0, 0, 0, 9884, 9886, 3, 1374, 687, 0, 9885, 9849, 1, 0, 0, 0, 9885, 9851, 1, 0, 0, 0, 9885, 9856, 1, 0, 0, 0, 9885, 9858, 1, 0, 0, 0, 9885, 9863, 1, 0, 0, 0, 9885, 9865, 1, 0, 0, 0, 9885, 9866, 1, 0, 0, 0, 9885, 9867, 1, 0, 0, 0, 9885, 9872, 1, 0, 0, 0, 9885, 9873, 1, 0, 0, 0, 9885, 9874, 1, 0, 0, 0, 9885, 9878, 1, 0, 0, 0, 9885, 9879, 1, 0, 0, 0, 9885, 9880, 1, 0, 0, 0, 9885, 9884, 1, 0, 0, 0, 9886, 1255, 1, 0, 0, 0, 9887, 9888, 5, 574, 0, 0, 9888, 1257, 1, 0, 0, 0, 9889, 9915, 3, 1444, 722, 0, 9890, 9912, 5, 2, 0, 0, 9891, 9895, 3, 1338, 669, 0, 9892, 9893, 5, 6, 0, 0, 9893, 9894, 5, 101, 0, 0, 9894, 9896, 3, 1340, 670, 0, 9895, 9892, 1, 0, 0, 0, 9895, 9896, 1, 0, 0, 0, 9896, 9898, 1, 0, 0, 0, 9897, 9899, 3, 1042, 521, 0, 9898, 9897, 1, 0, 0, 0, 9898, 9899, 1, 0, 0, 0, 9899, 9913, 1, 0, 0, 0, 9900, 9901, 5, 101, 0, 0, 9901, 9903, 3, 1340, 670, 0, 9902, 9904, 3, 1042, 521, 0, 9903, 9902, 1, 0, 0, 0, 9903, 9904, 1, 0, 0, 0, 9904, 9913, 1, 0, 0, 0, 9905, 9906, 7, 57, 0, 0, 9906, 9908, 3, 1338, 669, 0, 9907, 9909, 3, 1042, 521, 0, 9908, 9907, 1, 0, 0, 0, 9908, 9909, 1, 0, 0, 0, 9909, 9913, 1, 0, 0, 0, 9910, 9913, 5, 9, 0, 0, 9911, 9913, 1, 0, 0, 0, 9912, 9891, 1, 0, 0, 0, 9912, 9900, 1, 0, 0, 0, 9912, 9905, 1, 0, 0, 0, 9912, 9910, 1, 0, 0, 0, 9912, 9911, 1, 0, 0, 0, 9913, 9914, 1, 0, 0, 0, 9914, 9916, 5, 3, 0, 0, 9915, 9890, 1, 0, 0, 0, 9915, 9916, 1, 0, 0, 0, 9916, 1259, 1, 0, 0, 0, 9917, 9919, 3, 1258, 629, 0, 9918, 9920, 3, 1284, 642, 0, 9919, 9918, 1, 0, 0, 0, 9919, 9920, 1, 0, 0, 0, 9920, 9922, 1, 0, 0, 0, 9921, 9923, 3, 1286, 643, 0, 9922, 9921, 1, 0, 0, 0, 9922, 9923, 1, 0, 0, 0, 9923, 9925, 1, 0, 0, 0, 9924, 9926, 3, 1294, 647, 0, 9925, 9924, 1, 0, 0, 0, 9925, 9926, 1, 0, 0, 0, 9926, 9929, 1, 0, 0, 0, 9927, 9929, 3, 1264, 632, 0, 9928, 9917, 1, 0, 0, 0, 9928, 9927, 1, 0, 0, 0, 9929, 1261, 1, 0, 0, 0, 9930, 9933, 3, 1258, 629, 0, 9931, 9933, 3, 1264, 632, 0, 9932, 9930, 1, 0, 0, 0, 9932, 9931, 1, 0, 0, 0, 9933, 1263, 1, 0, 0, 0, 9934, 9935, 5, 108, 0, 0, 9935, 9936, 5, 62, 0, 0, 9936, 9937, 5, 2, 0, 0, 9937, 9938, 3, 1212, 606, 0, 9938, 9939, 5, 3, 0, 0, 9939, 10119, 1, 0, 0, 0, 9940, 10119, 5, 48, 0, 0, 9941, 9946, 5, 50, 0, 0, 9942, 9943, 5, 2, 0, 0, 9943, 9944, 3, 1456, 728, 0, 9944, 9945, 5, 3, 0, 0, 9945, 9947, 1, 0, 0, 0, 9946, 9942, 1, 0, 0, 0, 9946, 9947, 1, 0, 0, 0, 9947, 10119, 1, 0, 0, 0, 9948, 9953, 5, 51, 0, 0, 9949, 9950, 5, 2, 0, 0, 9950, 9951, 3, 1456, 728, 0, 9951, 9952, 5, 3, 0, 0, 9952, 9954, 1, 0, 0, 0, 9953, 9949, 1, 0, 0, 0, 9953, 9954, 1, 0, 0, 0, 9954, 10119, 1, 0, 0, 0, 9955, 9960, 5, 75, 0, 0, 9956, 9957, 5, 2, 0, 0, 9957, 9958, 3, 1456, 728, 0, 9958, 9959, 5, 3, 0, 0, 9959, 9961, 1, 0, 0, 0, 9960, 9956, 1, 0, 0, 0, 9960, 9961, 1, 0, 0, 0, 9961, 10119, 1, 0, 0, 0, 9962, 9967, 5, 76, 0, 0, 9963, 9964, 5, 2, 0, 0, 9964, 9965, 3, 1456, 728, 0, 9965, 9966, 5, 3, 0, 0, 9966, 9968, 1, 0, 0, 0, 9967, 9963, 1, 0, 0, 0, 9967, 9968, 1, 0, 0, 0, 9968, 10119, 1, 0, 0, 0, 9969, 10119, 5, 49, 0, 0, 9970, 10119, 5, 52, 0, 0, 9971, 10119, 5, 89, 0, 0, 9972, 10119, 5, 99, 0, 0, 9973, 10119, 5, 47, 0, 0, 9974, 10119, 5, 111, 0, 0, 9975, 9976, 5, 41, 0, 0, 9976, 9977, 5, 2, 0, 0, 9977, 9978, 3, 1212, 606, 0, 9978, 9979, 5, 36, 0, 0, 9979, 9980, 3, 1168, 584, 0, 9980, 9981, 5, 3, 0, 0, 9981, 10119, 1, 0, 0, 0, 9982, 9983, 5, 397, 0, 0, 9983, 9985, 5, 2, 0, 0, 9984, 9986, 3, 1348, 674, 0, 9985, 9984, 1, 0, 0, 0, 9985, 9986, 1, 0, 0, 0, 9986, 9987, 1, 0, 0, 0, 9987, 10119, 5, 3, 0, 0, 9988, 9989, 5, 489, 0, 0, 9989, 9990, 5, 2, 0, 0, 9990, 9993, 3, 1212, 606, 0, 9991, 9992, 5, 6, 0, 0, 9992, 9994, 3, 1352, 676, 0, 9993, 9991, 1, 0, 0, 0, 9993, 9994, 1, 0, 0, 0, 9994, 9995, 1, 0, 0, 0, 9995, 9996, 5, 3, 0, 0, 9996, 10119, 1, 0, 0, 0, 9997, 9998, 5, 410, 0, 0, 9998, 9999, 5, 2, 0, 0, 9999, 10000, 3, 1354, 677, 0, 10000, 10001, 5, 3, 0, 0, 10001, 10119, 1, 0, 0, 0, 10002, 10003, 5, 411, 0, 0, 10003, 10005, 5, 2, 0, 0, 10004, 10006, 3, 1356, 678, 0, 10005, 10004, 1, 0, 0, 0, 10005, 10006, 1, 0, 0, 0, 10006, 10007, 1, 0, 0, 0, 10007, 10119, 5, 3, 0, 0, 10008, 10009, 5, 417, 0, 0, 10009, 10011, 5, 2, 0, 0, 10010, 10012, 3, 1358, 679, 0, 10011, 10010, 1, 0, 0, 0, 10011, 10012, 1, 0, 0, 0, 10012, 10013, 1, 0, 0, 0, 10013, 10119, 5, 3, 0, 0, 10014, 10015, 5, 420, 0, 0, 10015, 10016, 5, 2, 0, 0, 10016, 10017, 3, 1212, 606, 0, 10017, 10018, 5, 36, 0, 0, 10018, 10019, 3, 1168, 584, 0, 10019, 10020, 5, 3, 0, 0, 10020, 10119, 1, 0, 0, 0, 10021, 10022, 5, 421, 0, 0, 10022, 10024, 5, 2, 0, 0, 10023, 10025, 7, 70, 0, 0, 10024, 10023, 1, 0, 0, 0, 10024, 10025, 1, 0, 0, 0, 10025, 10026, 1, 0, 0, 0, 10026, 10027, 3, 1360, 680, 0, 10027, 10028, 5, 3, 0, 0, 10028, 10119, 1, 0, 0, 0, 10029, 10030, 5, 408, 0, 0, 10030, 10031, 5, 2, 0, 0, 10031, 10032, 3, 1212, 606, 0, 10032, 10033, 5, 6, 0, 0, 10033, 10034, 3, 1212, 606, 0, 10034, 10035, 5, 3, 0, 0, 10035, 10119, 1, 0, 0, 0, 10036, 10037, 5, 393, 0, 0, 10037, 10038, 5, 2, 0, 0, 10038, 10039, 3, 1328, 664, 0, 10039, 10040, 5, 3, 0, 0, 10040, 10119, 1, 0, 0, 0, 10041, 10042, 5, 399, 0, 0, 10042, 10043, 5, 2, 0, 0, 10043, 10044, 3, 1328, 664, 0, 10044, 10045, 5, 3, 0, 0, 10045, 10119, 1, 0, 0, 0, 10046, 10047, 5, 404, 0, 0, 10047, 10048, 5, 2, 0, 0, 10048, 10049, 3, 1328, 664, 0, 10049, 10050, 5, 3, 0, 0, 10050, 10119, 1, 0, 0, 0, 10051, 10052, 5, 425, 0, 0, 10052, 10053, 5, 2, 0, 0, 10053, 10054, 3, 1328, 664, 0, 10054, 10055, 5, 3, 0, 0, 10055, 10119, 1, 0, 0, 0, 10056, 10057, 5, 426, 0, 0, 10057, 10058, 5, 2, 0, 0, 10058, 10059, 5, 266, 0, 0, 10059, 10065, 3, 1490, 745, 0, 10060, 10063, 5, 6, 0, 0, 10061, 10064, 3, 1270, 635, 0, 10062, 10064, 3, 1328, 664, 0, 10063, 10061, 1, 0, 0, 0, 10063, 10062, 1, 0, 0, 0, 10064, 10066, 1, 0, 0, 0, 10065, 10060, 1, 0, 0, 0, 10065, 10066, 1, 0, 0, 0, 10066, 10067, 1, 0, 0, 0, 10067, 10068, 5, 3, 0, 0, 10068, 10119, 1, 0, 0, 0, 10069, 10070, 5, 427, 0, 0, 10070, 10071, 5, 2, 0, 0, 10071, 10072, 3, 1254, 627, 0, 10072, 10073, 3, 1280, 640, 0, 10073, 10074, 5, 3, 0, 0, 10074, 10119, 1, 0, 0, 0, 10075, 10076, 5, 428, 0, 0, 10076, 10077, 5, 2, 0, 0, 10077, 10078, 3, 1272, 636, 0, 10078, 10079, 5, 3, 0, 0, 10079, 10119, 1, 0, 0, 0, 10080, 10081, 5, 429, 0, 0, 10081, 10082, 5, 2, 0, 0, 10082, 10083, 3, 1276, 638, 0, 10083, 10085, 3, 1212, 606, 0, 10084, 10086, 3, 1278, 639, 0, 10085, 10084, 1, 0, 0, 0, 10085, 10086, 1, 0, 0, 0, 10086, 10087, 1, 0, 0, 0, 10087, 10088, 5, 3, 0, 0, 10088, 10119, 1, 0, 0, 0, 10089, 10090, 5, 430, 0, 0, 10090, 10091, 5, 2, 0, 0, 10091, 10092, 5, 266, 0, 0, 10092, 10095, 3, 1490, 745, 0, 10093, 10094, 5, 6, 0, 0, 10094, 10096, 3, 1212, 606, 0, 10095, 10093, 1, 0, 0, 0, 10095, 10096, 1, 0, 0, 0, 10096, 10097, 1, 0, 0, 0, 10097, 10098, 5, 3, 0, 0, 10098, 10119, 1, 0, 0, 0, 10099, 10100, 5, 431, 0, 0, 10100, 10101, 5, 2, 0, 0, 10101, 10102, 5, 383, 0, 0, 10102, 10103, 3, 1212, 606, 0, 10103, 10104, 5, 6, 0, 0, 10104, 10106, 3, 1266, 633, 0, 10105, 10107, 3, 1268, 634, 0, 10106, 10105, 1, 0, 0, 0, 10106, 10107, 1, 0, 0, 0, 10107, 10108, 1, 0, 0, 0, 10108, 10109, 5, 3, 0, 0, 10109, 10119, 1, 0, 0, 0, 10110, 10111, 5, 432, 0, 0, 10111, 10112, 5, 2, 0, 0, 10112, 10113, 3, 1276, 638, 0, 10113, 10114, 3, 1212, 606, 0, 10114, 10115, 5, 36, 0, 0, 10115, 10116, 3, 1172, 586, 0, 10116, 10117, 5, 3, 0, 0, 10117, 10119, 1, 0, 0, 0, 10118, 9934, 1, 0, 0, 0, 10118, 9940, 1, 0, 0, 0, 10118, 9941, 1, 0, 0, 0, 10118, 9948, 1, 0, 0, 0, 10118, 9955, 1, 0, 0, 0, 10118, 9962, 1, 0, 0, 0, 10118, 9969, 1, 0, 0, 0, 10118, 9970, 1, 0, 0, 0, 10118, 9971, 1, 0, 0, 0, 10118, 9972, 1, 0, 0, 0, 10118, 9973, 1, 0, 0, 0, 10118, 9974, 1, 0, 0, 0, 10118, 9975, 1, 0, 0, 0, 10118, 9982, 1, 0, 0, 0, 10118, 9988, 1, 0, 0, 0, 10118, 9997, 1, 0, 0, 0, 10118, 10002, 1, 0, 0, 0, 10118, 10008, 1, 0, 0, 0, 10118, 10014, 1, 0, 0, 0, 10118, 10021, 1, 0, 0, 0, 10118, 10029, 1, 0, 0, 0, 10118, 10036, 1, 0, 0, 0, 10118, 10041, 1, 0, 0, 0, 10118, 10046, 1, 0, 0, 0, 10118, 10051, 1, 0, 0, 0, 10118, 10056, 1, 0, 0, 0, 10118, 10069, 1, 0, 0, 0, 10118, 10075, 1, 0, 0, 0, 10118, 10080, 1, 0, 0, 0, 10118, 10089, 1, 0, 0, 0, 10118, 10099, 1, 0, 0, 0, 10118, 10110, 1, 0, 0, 0, 10119, 1265, 1, 0, 0, 0, 10120, 10121, 5, 375, 0, 0, 10121, 10126, 3, 1212, 606, 0, 10122, 10123, 5, 375, 0, 0, 10123, 10124, 5, 269, 0, 0, 10124, 10126, 5, 450, 0, 0, 10125, 10120, 1, 0, 0, 0, 10125, 10122, 1, 0, 0, 0, 10126, 1267, 1, 0, 0, 0, 10127, 10128, 5, 6, 0, 0, 10128, 10129, 5, 339, 0, 0, 10129, 10138, 5, 385, 0, 0, 10130, 10131, 5, 6, 0, 0, 10131, 10132, 5, 339, 0, 0, 10132, 10138, 5, 269, 0, 0, 10133, 10134, 5, 6, 0, 0, 10134, 10135, 5, 339, 0, 0, 10135, 10136, 5, 269, 0, 0, 10136, 10138, 5, 450, 0, 0, 10137, 10127, 1, 0, 0, 0, 10137, 10130, 1, 0, 0, 0, 10137, 10133, 1, 0, 0, 0, 10138, 1269, 1, 0, 0, 0, 10139, 10140, 5, 424, 0, 0, 10140, 10141, 5, 2, 0, 0, 10141, 10142, 3, 1272, 636, 0, 10142, 10143, 5, 3, 0, 0, 10143, 1271, 1, 0, 0, 0, 10144, 10149, 3, 1274, 637, 0, 10145, 10146, 5, 6, 0, 0, 10146, 10148, 3, 1274, 637, 0, 10147, 10145, 1, 0, 0, 0, 10148, 10151, 1, 0, 0, 0, 10149, 10147, 1, 0, 0, 0, 10149, 10150, 1, 0, 0, 0, 10150, 1273, 1, 0, 0, 0, 10151, 10149, 1, 0, 0, 0, 10152, 10155, 3, 1212, 606, 0, 10153, 10154, 5, 36, 0, 0, 10154, 10156, 3, 1490, 745, 0, 10155, 10153, 1, 0, 0, 0, 10155, 10156, 1, 0, 0, 0, 10156, 1275, 1, 0, 0, 0, 10157, 10158, 7, 71, 0, 0, 10158, 1277, 1, 0, 0, 0, 10159, 10160, 5, 292, 0, 0, 10160, 10164, 5, 378, 0, 0, 10161, 10162, 5, 347, 0, 0, 10162, 10164, 5, 378, 0, 0, 10163, 10159, 1, 0, 0, 0, 10163, 10161, 1, 0, 0, 0, 10164, 1279, 1, 0, 0, 0, 10165, 10166, 5, 286, 0, 0, 10166, 10181, 3, 1254, 627, 0, 10167, 10168, 5, 286, 0, 0, 10168, 10169, 3, 1254, 627, 0, 10169, 10170, 3, 1282, 641, 0, 10170, 10181, 1, 0, 0, 0, 10171, 10172, 5, 286, 0, 0, 10172, 10173, 3, 1282, 641, 0, 10173, 10174, 3, 1254, 627, 0, 10174, 10181, 1, 0, 0, 0, 10175, 10176, 5, 286, 0, 0, 10176, 10177, 3, 1282, 641, 0, 10177, 10178, 3, 1254, 627, 0, 10178, 10179, 3, 1282, 641, 0, 10179, 10181, 1, 0, 0, 0, 10180, 10165, 1, 0, 0, 0, 10180, 10167, 1, 0, 0, 0, 10180, 10171, 1, 0, 0, 0, 10180, 10175, 1, 0, 0, 0, 10181, 1281, 1, 0, 0, 0, 10182, 10183, 5, 147, 0, 0, 10183, 10184, 7, 72, 0, 0, 10184, 1283, 1, 0, 0, 0, 10185, 10186, 5, 479, 0, 0, 10186, 10187, 5, 66, 0, 0, 10187, 10188, 5, 2, 0, 0, 10188, 10189, 3, 1044, 522, 0, 10189, 10190, 5, 3, 0, 0, 10190, 1285, 1, 0, 0, 0, 10191, 10192, 5, 480, 0, 0, 10192, 10193, 5, 2, 0, 0, 10193, 10194, 5, 103, 0, 0, 10194, 10195, 3, 1212, 606, 0, 10195, 10196, 5, 3, 0, 0, 10196, 1287, 1, 0, 0, 0, 10197, 10198, 5, 104, 0, 0, 10198, 10199, 3, 1290, 645, 0, 10199, 1289, 1, 0, 0, 0, 10200, 10205, 3, 1292, 646, 0, 10201, 10202, 5, 6, 0, 0, 10202, 10204, 3, 1292, 646, 0, 10203, 10201, 1, 0, 0, 0, 10204, 10207, 1, 0, 0, 0, 10205, 10203, 1, 0, 0, 0, 10205, 10206, 1, 0, 0, 0, 10206, 1291, 1, 0, 0, 0, 10207, 10205, 1, 0, 0, 0, 10208, 10209, 3, 1474, 737, 0, 10209, 10210, 5, 36, 0, 0, 10210, 10211, 3, 1296, 648, 0, 10211, 1293, 1, 0, 0, 0, 10212, 10215, 5, 124, 0, 0, 10213, 10216, 3, 1296, 648, 0, 10214, 10216, 3, 1474, 737, 0, 10215, 10213, 1, 0, 0, 0, 10215, 10214, 1, 0, 0, 0, 10216, 1295, 1, 0, 0, 0, 10217, 10219, 5, 2, 0, 0, 10218, 10220, 3, 1298, 649, 0, 10219, 10218, 1, 0, 0, 0, 10219, 10220, 1, 0, 0, 0, 10220, 10222, 1, 0, 0, 0, 10221, 10223, 3, 1300, 650, 0, 10222, 10221, 1, 0, 0, 0, 10222, 10223, 1, 0, 0, 0, 10223, 10225, 1, 0, 0, 0, 10224, 10226, 3, 1042, 521, 0, 10225, 10224, 1, 0, 0, 0, 10225, 10226, 1, 0, 0, 0, 10226, 10228, 1, 0, 0, 0, 10227, 10229, 3, 1302, 651, 0, 10228, 10227, 1, 0, 0, 0, 10228, 10229, 1, 0, 0, 0, 10229, 10230, 1, 0, 0, 0, 10230, 10231, 5, 3, 0, 0, 10231, 1297, 1, 0, 0, 0, 10232, 10233, 3, 1474, 737, 0, 10233, 1299, 1, 0, 0, 0, 10234, 10235, 5, 285, 0, 0, 10235, 10236, 5, 147, 0, 0, 10236, 10237, 3, 1328, 664, 0, 10237, 1301, 1, 0, 0, 0, 10238, 10239, 5, 299, 0, 0, 10239, 10241, 3, 1304, 652, 0, 10240, 10242, 3, 1308, 654, 0, 10241, 10240, 1, 0, 0, 0, 10241, 10242, 1, 0, 0, 0, 10242, 10254, 1, 0, 0, 0, 10243, 10244, 5, 320, 0, 0, 10244, 10246, 3, 1304, 652, 0, 10245, 10247, 3, 1308, 654, 0, 10246, 10245, 1, 0, 0, 0, 10246, 10247, 1, 0, 0, 0, 10247, 10254, 1, 0, 0, 0, 10248, 10249, 5, 481, 0, 0, 10249, 10251, 3, 1304, 652, 0, 10250, 10252, 3, 1308, 654, 0, 10251, 10250, 1, 0, 0, 0, 10251, 10252, 1, 0, 0, 0, 10252, 10254, 1, 0, 0, 0, 10253, 10238, 1, 0, 0, 0, 10253, 10243, 1, 0, 0, 0, 10253, 10248, 1, 0, 0, 0, 10254, 1303, 1, 0, 0, 0, 10255, 10262, 3, 1306, 653, 0, 10256, 10257, 5, 387, 0, 0, 10257, 10258, 3, 1306, 653, 0, 10258, 10259, 5, 33, 0, 0, 10259, 10260, 3, 1306, 653, 0, 10260, 10262, 1, 0, 0, 0, 10261, 10255, 1, 0, 0, 0, 10261, 10256, 1, 0, 0, 0, 10262, 1305, 1, 0, 0, 0, 10263, 10264, 5, 362, 0, 0, 10264, 10271, 7, 73, 0, 0, 10265, 10266, 5, 434, 0, 0, 10266, 10271, 5, 414, 0, 0, 10267, 10268, 3, 1212, 606, 0, 10268, 10269, 7, 73, 0, 0, 10269, 10271, 1, 0, 0, 0, 10270, 10263, 1, 0, 0, 0, 10270, 10265, 1, 0, 0, 0, 10270, 10267, 1, 0, 0, 0, 10271, 1307, 1, 0, 0, 0, 10272, 10279, 5, 199, 0, 0, 10273, 10274, 5, 434, 0, 0, 10274, 10280, 5, 414, 0, 0, 10275, 10280, 5, 66, 0, 0, 10276, 10280, 5, 467, 0, 0, 10277, 10278, 5, 269, 0, 0, 10278, 10280, 5, 482, 0, 0, 10279, 10273, 1, 0, 0, 0, 10279, 10275, 1, 0, 0, 0, 10279, 10276, 1, 0, 0, 0, 10279, 10277, 1, 0, 0, 0, 10280, 1309, 1, 0, 0, 0, 10281, 10282, 5, 414, 0, 0, 10282, 10284, 5, 2, 0, 0, 10283, 10285, 3, 1328, 664, 0, 10284, 10283, 1, 0, 0, 0, 10284, 10285, 1, 0, 0, 0, 10285, 10286, 1, 0, 0, 0, 10286, 10294, 5, 3, 0, 0, 10287, 10288, 5, 2, 0, 0, 10288, 10289, 3, 1328, 664, 0, 10289, 10290, 5, 6, 0, 0, 10290, 10291, 3, 1212, 606, 0, 10291, 10292, 5, 3, 0, 0, 10292, 10294, 1, 0, 0, 0, 10293, 10281, 1, 0, 0, 0, 10293, 10287, 1, 0, 0, 0, 10294, 1311, 1, 0, 0, 0, 10295, 10296, 5, 414, 0, 0, 10296, 10298, 5, 2, 0, 0, 10297, 10299, 3, 1328, 664, 0, 10298, 10297, 1, 0, 0, 0, 10298, 10299, 1, 0, 0, 0, 10299, 10300, 1, 0, 0, 0, 10300, 10301, 5, 3, 0, 0, 10301, 1313, 1, 0, 0, 0, 10302, 10303, 5, 2, 0, 0, 10303, 10304, 3, 1212, 606, 0, 10304, 10305, 5, 6, 0, 0, 10305, 10306, 3, 1328, 664, 0, 10306, 10307, 5, 3, 0, 0, 10307, 1315, 1, 0, 0, 0, 10308, 10309, 7, 74, 0, 0, 10309, 1317, 1, 0, 0, 0, 10310, 10313, 5, 29, 0, 0, 10311, 10313, 3, 1320, 660, 0, 10312, 10310, 1, 0, 0, 0, 10312, 10311, 1, 0, 0, 0, 10313, 1319, 1, 0, 0, 0, 10314, 10315, 7, 75, 0, 0, 10315, 1321, 1, 0, 0, 0, 10316, 10323, 5, 29, 0, 0, 10317, 10318, 5, 278, 0, 0, 10318, 10319, 5, 2, 0, 0, 10319, 10320, 3, 732, 366, 0, 10320, 10321, 5, 3, 0, 0, 10321, 10323, 1, 0, 0, 0, 10322, 10316, 1, 0, 0, 0, 10322, 10317, 1, 0, 0, 0, 10323, 1323, 1, 0, 0, 0, 10324, 10331, 3, 1318, 659, 0, 10325, 10326, 5, 278, 0, 0, 10326, 10327, 5, 2, 0, 0, 10327, 10328, 3, 732, 366, 0, 10328, 10329, 5, 3, 0, 0, 10329, 10331, 1, 0, 0, 0, 10330, 10324, 1, 0, 0, 0, 10330, 10325, 1, 0, 0, 0, 10331, 1325, 1, 0, 0, 0, 10332, 10345, 3, 1318, 659, 0, 10333, 10334, 5, 278, 0, 0, 10334, 10335, 5, 2, 0, 0, 10335, 10336, 3, 732, 366, 0, 10336, 10337, 5, 3, 0, 0, 10337, 10345, 1, 0, 0, 0, 10338, 10345, 5, 120, 0, 0, 10339, 10340, 5, 77, 0, 0, 10340, 10345, 5, 120, 0, 0, 10341, 10345, 5, 114, 0, 0, 10342, 10343, 5, 77, 0, 0, 10343, 10345, 5, 114, 0, 0, 10344, 10332, 1, 0, 0, 0, 10344, 10333, 1, 0, 0, 0, 10344, 10338, 1, 0, 0, 0, 10344, 10339, 1, 0, 0, 0, 10344, 10341, 1, 0, 0, 0, 10344, 10342, 1, 0, 0, 0, 10345, 1327, 1, 0, 0, 0, 10346, 10351, 3, 1212, 606, 0, 10347, 10348, 5, 6, 0, 0, 10348, 10350, 3, 1212, 606, 0, 10349, 10347, 1, 0, 0, 0, 10350, 10353, 1, 0, 0, 0, 10351, 10349, 1, 0, 0, 0, 10351, 10352, 1, 0, 0, 0, 10352, 1329, 1, 0, 0, 0, 10353, 10351, 1, 0, 0, 0, 10354, 10359, 3, 1336, 668, 0, 10355, 10356, 5, 6, 0, 0, 10356, 10358, 3, 1336, 668, 0, 10357, 10355, 1, 0, 0, 0, 10358, 10361, 1, 0, 0, 0, 10359, 10357, 1, 0, 0, 0, 10359, 10360, 1, 0, 0, 0, 10360, 1331, 1, 0, 0, 0, 10361, 10359, 1, 0, 0, 0, 10362, 10367, 3, 1334, 667, 0, 10363, 10364, 5, 6, 0, 0, 10364, 10366, 3, 1334, 667, 0, 10365, 10363, 1, 0, 0, 0, 10366, 10369, 1, 0, 0, 0, 10367, 10365, 1, 0, 0, 0, 10367, 10368, 1, 0, 0, 0, 10368, 1333, 1, 0, 0, 0, 10369, 10367, 1, 0, 0, 0, 10370, 10371, 5, 2, 0, 0, 10371, 10372, 3, 1212, 606, 0, 10372, 10373, 5, 3, 0, 0, 10373, 10376, 1, 0, 0, 0, 10374, 10376, 3, 1432, 716, 0, 10375, 10370, 1, 0, 0, 0, 10375, 10374, 1, 0, 0, 0, 10376, 1335, 1, 0, 0, 0, 10377, 10380, 3, 1212, 606, 0, 10378, 10380, 3, 1432, 716, 0, 10379, 10377, 1, 0, 0, 0, 10379, 10378, 1, 0, 0, 0, 10380, 1337, 1, 0, 0, 0, 10381, 10386, 3, 1340, 670, 0, 10382, 10383, 5, 6, 0, 0, 10383, 10385, 3, 1340, 670, 0, 10384, 10382, 1, 0, 0, 0, 10385, 10388, 1, 0, 0, 0, 10386, 10384, 1, 0, 0, 0, 10386, 10387, 1, 0, 0, 0, 10387, 1339, 1, 0, 0, 0, 10388, 10386, 1, 0, 0, 0, 10389, 10395, 3, 1212, 606, 0, 10390, 10391, 3, 684, 342, 0, 10391, 10392, 7, 76, 0, 0, 10392, 10393, 3, 1212, 606, 0, 10393, 10395, 1, 0, 0, 0, 10394, 10389, 1, 0, 0, 0, 10394, 10390, 1, 0, 0, 0, 10395, 1341, 1, 0, 0, 0, 10396, 10401, 3, 1168, 584, 0, 10397, 10398, 5, 6, 0, 0, 10398, 10400, 3, 1168, 584, 0, 10399, 10397, 1, 0, 0, 0, 10400, 10403, 1, 0, 0, 0, 10401, 10399, 1, 0, 0, 0, 10401, 10402, 1, 0, 0, 0, 10402, 1343, 1, 0, 0, 0, 10403, 10401, 1, 0, 0, 0, 10404, 10407, 5, 4, 0, 0, 10405, 10408, 3, 1328, 664, 0, 10406, 10408, 3, 1346, 673, 0, 10407, 10405, 1, 0, 0, 0, 10407, 10406, 1, 0, 0, 0, 10407, 10408, 1, 0, 0, 0, 10408, 10409, 1, 0, 0, 0, 10409, 10410, 5, 5, 0, 0, 10410, 1345, 1, 0, 0, 0, 10411, 10416, 3, 1344, 672, 0, 10412, 10413, 5, 6, 0, 0, 10413, 10415, 3, 1344, 672, 0, 10414, 10412, 1, 0, 0, 0, 10415, 10418, 1, 0, 0, 0, 10416, 10414, 1, 0, 0, 0, 10416, 10417, 1, 0, 0, 0, 10417, 1347, 1, 0, 0, 0, 10418, 10416, 1, 0, 0, 0, 10419, 10420, 3, 1350, 675, 0, 10420, 10421, 5, 64, 0, 0, 10421, 10422, 3, 1212, 606, 0, 10422, 1349, 1, 0, 0, 0, 10423, 10432, 3, 1492, 746, 0, 10424, 10432, 5, 384, 0, 0, 10425, 10432, 5, 264, 0, 0, 10426, 10432, 5, 176, 0, 0, 10427, 10432, 5, 218, 0, 0, 10428, 10432, 5, 261, 0, 0, 10429, 10432, 5, 326, 0, 0, 10430, 10432, 3, 1458, 729, 0, 10431, 10423, 1, 0, 0, 0, 10431, 10424, 1, 0, 0, 0, 10431, 10425, 1, 0, 0, 0, 10431, 10426, 1, 0, 0, 0, 10431, 10427, 1, 0, 0, 0, 10431, 10428, 1, 0, 0, 0, 10431, 10429, 1, 0, 0, 0, 10431, 10430, 1, 0, 0, 0, 10432, 1351, 1, 0, 0, 0, 10433, 10434, 7, 77, 0, 0, 10434, 1353, 1, 0, 0, 0, 10435, 10436, 3, 1212, 606, 0, 10436, 10437, 5, 84, 0, 0, 10437, 10438, 3, 1212, 606, 0, 10438, 10439, 5, 64, 0, 0, 10439, 10442, 3, 1212, 606, 0, 10440, 10441, 5, 62, 0, 0, 10441, 10443, 3, 1212, 606, 0, 10442, 10440, 1, 0, 0, 0, 10442, 10443, 1, 0, 0, 0, 10443, 1355, 1, 0, 0, 0, 10444, 10445, 3, 1252, 626, 0, 10445, 10446, 5, 68, 0, 0, 10446, 10447, 3, 1252, 626, 0, 10447, 1357, 1, 0, 0, 0, 10448, 10449, 3, 1212, 606, 0, 10449, 10450, 5, 64, 0, 0, 10450, 10451, 3, 1212, 606, 0, 10451, 10452, 5, 62, 0, 0, 10452, 10453, 3, 1212, 606, 0, 10453, 10476, 1, 0, 0, 0, 10454, 10455, 3, 1212, 606, 0, 10455, 10456, 5, 62, 0, 0, 10456, 10457, 3, 1212, 606, 0, 10457, 10458, 5, 64, 0, 0, 10458, 10459, 3, 1212, 606, 0, 10459, 10476, 1, 0, 0, 0, 10460, 10461, 3, 1212, 606, 0, 10461, 10462, 5, 64, 0, 0, 10462, 10463, 3, 1212, 606, 0, 10463, 10476, 1, 0, 0, 0, 10464, 10465, 3, 1212, 606, 0, 10465, 10466, 5, 62, 0, 0, 10466, 10467, 3, 1212, 606, 0, 10467, 10476, 1, 0, 0, 0, 10468, 10469, 3, 1212, 606, 0, 10469, 10470, 5, 127, 0, 0, 10470, 10471, 3, 1212, 606, 0, 10471, 10472, 5, 197, 0, 0, 10472, 10473, 3, 1212, 606, 0, 10473, 10476, 1, 0, 0, 0, 10474, 10476, 3, 1328, 664, 0, 10475, 10448, 1, 0, 0, 0, 10475, 10454, 1, 0, 0, 0, 10475, 10460, 1, 0, 0, 0, 10475, 10464, 1, 0, 0, 0, 10475, 10468, 1, 0, 0, 0, 10475, 10474, 1, 0, 0, 0, 10476, 1359, 1, 0, 0, 0, 10477, 10478, 3, 1212, 606, 0, 10478, 10479, 5, 64, 0, 0, 10479, 10480, 3, 1328, 664, 0, 10480, 10485, 1, 0, 0, 0, 10481, 10482, 5, 64, 0, 0, 10482, 10485, 3, 1328, 664, 0, 10483, 10485, 3, 1328, 664, 0, 10484, 10477, 1, 0, 0, 0, 10484, 10481, 1, 0, 0, 0, 10484, 10483, 1, 0, 0, 0, 10485, 1361, 1, 0, 0, 0, 10486, 10492, 3, 1002, 501, 0, 10487, 10488, 5, 2, 0, 0, 10488, 10489, 3, 1328, 664, 0, 10489, 10490, 5, 3, 0, 0, 10490, 10492, 1, 0, 0, 0, 10491, 10486, 1, 0, 0, 0, 10491, 10487, 1, 0, 0, 0, 10492, 1363, 1, 0, 0, 0, 10493, 10495, 5, 40, 0, 0, 10494, 10496, 3, 1372, 686, 0, 10495, 10494, 1, 0, 0, 0, 10495, 10496, 1, 0, 0, 0, 10496, 10497, 1, 0, 0, 0, 10497, 10499, 3, 1366, 683, 0, 10498, 10500, 3, 1370, 685, 0, 10499, 10498, 1, 0, 0, 0, 10499, 10500, 1, 0, 0, 0, 10500, 10501, 1, 0, 0, 0, 10501, 10502, 5, 454, 0, 0, 10502, 1365, 1, 0, 0, 0, 10503, 10505, 3, 1368, 684, 0, 10504, 10503, 1, 0, 0, 0, 10505, 10506, 1, 0, 0, 0, 10506, 10504, 1, 0, 0, 0, 10506, 10507, 1, 0, 0, 0, 10507, 1367, 1, 0, 0, 0, 10508, 10509, 5, 102, 0, 0, 10509, 10510, 3, 1212, 606, 0, 10510, 10511, 5, 93, 0, 0, 10511, 10512, 3, 1212, 606, 0, 10512, 1369, 1, 0, 0, 0, 10513, 10514, 5, 58, 0, 0, 10514, 10515, 3, 1212, 606, 0, 10515, 1371, 1, 0, 0, 0, 10516, 10517, 3, 1212, 606, 0, 10517, 1373, 1, 0, 0, 0, 10518, 10520, 3, 1474, 737, 0, 10519, 10521, 3, 1380, 690, 0, 10520, 10519, 1, 0, 0, 0, 10520, 10521, 1, 0, 0, 0, 10521, 1375, 1, 0, 0, 0, 10522, 10525, 5, 11, 0, 0, 10523, 10526, 3, 1438, 719, 0, 10524, 10526, 5, 9, 0, 0, 10525, 10523, 1, 0, 0, 0, 10525, 10524, 1, 0, 0, 0, 10526, 10540, 1, 0, 0, 0, 10527, 10536, 5, 4, 0, 0, 10528, 10537, 3, 1212, 606, 0, 10529, 10531, 3, 1378, 689, 0, 10530, 10529, 1, 0, 0, 0, 10530, 10531, 1, 0, 0, 0, 10531, 10532, 1, 0, 0, 0, 10532, 10534, 5, 8, 0, 0, 10533, 10535, 3, 1378, 689, 0, 10534, 10533, 1, 0, 0, 0, 10534, 10535, 1, 0, 0, 0, 10535, 10537, 1, 0, 0, 0, 10536, 10528, 1, 0, 0, 0, 10536, 10530, 1, 0, 0, 0, 10537, 10538, 1, 0, 0, 0, 10538, 10540, 5, 5, 0, 0, 10539, 10522, 1, 0, 0, 0, 10539, 10527, 1, 0, 0, 0, 10540, 1377, 1, 0, 0, 0, 10541, 10542, 3, 1212, 606, 0, 10542, 1379, 1, 0, 0, 0, 10543, 10545, 3, 1376, 688, 0, 10544, 10543, 1, 0, 0, 0, 10545, 10546, 1, 0, 0, 0, 10546, 10544, 1, 0, 0, 0, 10546, 10547, 1, 0, 0, 0, 10547, 1381, 1, 0, 0, 0, 10548, 10550, 3, 1376, 688, 0, 10549, 10548, 1, 0, 0, 0, 10550, 10553, 1, 0, 0, 0, 10551, 10549, 1, 0, 0, 0, 10551, 10552, 1, 0, 0, 0, 10552, 1383, 1, 0, 0, 0, 10553, 10551, 1, 0, 0, 0, 10554, 10555, 3, 1386, 693, 0, 10555, 1385, 1, 0, 0, 0, 10556, 10561, 3, 1388, 694, 0, 10557, 10558, 5, 6, 0, 0, 10558, 10560, 3, 1388, 694, 0, 10559, 10557, 1, 0, 0, 0, 10560, 10563, 1, 0, 0, 0, 10561, 10559, 1, 0, 0, 0, 10561, 10562, 1, 0, 0, 0, 10562, 1387, 1, 0, 0, 0, 10563, 10561, 1, 0, 0, 0, 10564, 10569, 3, 1336, 668, 0, 10565, 10566, 5, 36, 0, 0, 10566, 10570, 3, 1490, 745, 0, 10567, 10570, 3, 1492, 746, 0, 10568, 10570, 1, 0, 0, 0, 10569, 10565, 1, 0, 0, 0, 10569, 10567, 1, 0, 0, 0, 10569, 10568, 1, 0, 0, 0, 10570, 10573, 1, 0, 0, 0, 10571, 10573, 5, 9, 0, 0, 10572, 10564, 1, 0, 0, 0, 10572, 10571, 1, 0, 0, 0, 10573, 1389, 1, 0, 0, 0, 10574, 10579, 3, 1412, 706, 0, 10575, 10576, 5, 6, 0, 0, 10576, 10578, 3, 1412, 706, 0, 10577, 10575, 1, 0, 0, 0, 10578, 10581, 1, 0, 0, 0, 10579, 10577, 1, 0, 0, 0, 10579, 10580, 1, 0, 0, 0, 10580, 1391, 1, 0, 0, 0, 10581, 10579, 1, 0, 0, 0, 10582, 10587, 3, 1406, 703, 0, 10583, 10584, 5, 6, 0, 0, 10584, 10586, 3, 1406, 703, 0, 10585, 10583, 1, 0, 0, 0, 10586, 10589, 1, 0, 0, 0, 10587, 10585, 1, 0, 0, 0, 10587, 10588, 1, 0, 0, 0, 10588, 1393, 1, 0, 0, 0, 10589, 10587, 1, 0, 0, 0, 10590, 10595, 3, 1422, 711, 0, 10591, 10592, 5, 6, 0, 0, 10592, 10594, 3, 1422, 711, 0, 10593, 10591, 1, 0, 0, 0, 10594, 10597, 1, 0, 0, 0, 10595, 10593, 1, 0, 0, 0, 10595, 10596, 1, 0, 0, 0, 10596, 1395, 1, 0, 0, 0, 10597, 10595, 1, 0, 0, 0, 10598, 10603, 3, 1420, 710, 0, 10599, 10600, 5, 6, 0, 0, 10600, 10602, 3, 1420, 710, 0, 10601, 10599, 1, 0, 0, 0, 10602, 10605, 1, 0, 0, 0, 10603, 10601, 1, 0, 0, 0, 10603, 10604, 1, 0, 0, 0, 10604, 1397, 1, 0, 0, 0, 10605, 10603, 1, 0, 0, 0, 10606, 10611, 3, 1428, 714, 0, 10607, 10608, 5, 6, 0, 0, 10608, 10610, 3, 1428, 714, 0, 10609, 10607, 1, 0, 0, 0, 10610, 10613, 1, 0, 0, 0, 10611, 10609, 1, 0, 0, 0, 10611, 10612, 1, 0, 0, 0, 10612, 1399, 1, 0, 0, 0, 10613, 10611, 1, 0, 0, 0, 10614, 10616, 3, 1474, 737, 0, 10615, 10617, 3, 1380, 690, 0, 10616, 10615, 1, 0, 0, 0, 10616, 10617, 1, 0, 0, 0, 10617, 1401, 1, 0, 0, 0, 10618, 10620, 3, 1474, 737, 0, 10619, 10621, 3, 1380, 690, 0, 10620, 10619, 1, 0, 0, 0, 10620, 10621, 1, 0, 0, 0, 10621, 1403, 1, 0, 0, 0, 10622, 10624, 3, 1474, 737, 0, 10623, 10625, 3, 1380, 690, 0, 10624, 10623, 1, 0, 0, 0, 10624, 10625, 1, 0, 0, 0, 10625, 1405, 1, 0, 0, 0, 10626, 10628, 3, 1474, 737, 0, 10627, 10629, 3, 1380, 690, 0, 10628, 10627, 1, 0, 0, 0, 10628, 10629, 1, 0, 0, 0, 10629, 1407, 1, 0, 0, 0, 10630, 10632, 3, 1474, 737, 0, 10631, 10633, 3, 1380, 690, 0, 10632, 10631, 1, 0, 0, 0, 10632, 10633, 1, 0, 0, 0, 10633, 1409, 1, 0, 0, 0, 10634, 10636, 3, 1474, 737, 0, 10635, 10637, 3, 560, 280, 0, 10636, 10635, 1, 0, 0, 0, 10636, 10637, 1, 0, 0, 0, 10637, 1411, 1, 0, 0, 0, 10638, 10640, 3, 1474, 737, 0, 10639, 10641, 3, 1380, 690, 0, 10640, 10639, 1, 0, 0, 0, 10640, 10641, 1, 0, 0, 0, 10641, 1413, 1, 0, 0, 0, 10642, 10647, 3, 1402, 701, 0, 10643, 10644, 5, 6, 0, 0, 10644, 10646, 3, 1402, 701, 0, 10645, 10643, 1, 0, 0, 0, 10646, 10649, 1, 0, 0, 0, 10647, 10645, 1, 0, 0, 0, 10647, 10648, 1, 0, 0, 0, 10648, 1415, 1, 0, 0, 0, 10649, 10647, 1, 0, 0, 0, 10650, 10655, 3, 1436, 718, 0, 10651, 10652, 5, 6, 0, 0, 10652, 10654, 3, 1436, 718, 0, 10653, 10651, 1, 0, 0, 0, 10654, 10657, 1, 0, 0, 0, 10655, 10653, 1, 0, 0, 0, 10655, 10656, 1, 0, 0, 0, 10656, 1417, 1, 0, 0, 0, 10657, 10655, 1, 0, 0, 0, 10658, 10660, 3, 1474, 737, 0, 10659, 10661, 3, 560, 280, 0, 10660, 10659, 1, 0, 0, 0, 10660, 10661, 1, 0, 0, 0, 10661, 1419, 1, 0, 0, 0, 10662, 10664, 3, 1474, 737, 0, 10663, 10665, 3, 560, 280, 0, 10664, 10663, 1, 0, 0, 0, 10664, 10665, 1, 0, 0, 0, 10665, 1421, 1, 0, 0, 0, 10666, 10668, 3, 1474, 737, 0, 10667, 10669, 3, 560, 280, 0, 10668, 10667, 1, 0, 0, 0, 10668, 10669, 1, 0, 0, 0, 10669, 1423, 1, 0, 0, 0, 10670, 10671, 3, 1474, 737, 0, 10671, 1425, 1, 0, 0, 0, 10672, 10673, 3, 1474, 737, 0, 10673, 1427, 1, 0, 0, 0, 10674, 10679, 3, 1482, 741, 0, 10675, 10676, 3, 1474, 737, 0, 10676, 10677, 3, 1380, 690, 0, 10677, 10679, 1, 0, 0, 0, 10678, 10674, 1, 0, 0, 0, 10678, 10675, 1, 0, 0, 0, 10679, 1429, 1, 0, 0, 0, 10680, 10685, 3, 1482, 741, 0, 10681, 10682, 3, 1474, 737, 0, 10682, 10683, 3, 1380, 690, 0, 10683, 10685, 1, 0, 0, 0, 10684, 10680, 1, 0, 0, 0, 10684, 10681, 1, 0, 0, 0, 10685, 1431, 1, 0, 0, 0, 10686, 10690, 3, 1474, 737, 0, 10687, 10689, 3, 1376, 688, 0, 10688, 10687, 1, 0, 0, 0, 10689, 10692, 1, 0, 0, 0, 10690, 10688, 1, 0, 0, 0, 10690, 10691, 1, 0, 0, 0, 10691, 10695, 1, 0, 0, 0, 10692, 10690, 1, 0, 0, 0, 10693, 10695, 4, 716, 8, 0, 10694, 10686, 1, 0, 0, 0, 10694, 10693, 1, 0, 0, 0, 10695, 1433, 1, 0, 0, 0, 10696, 10697, 3, 1474, 737, 0, 10697, 1435, 1, 0, 0, 0, 10698, 10699, 3, 1474, 737, 0, 10699, 1437, 1, 0, 0, 0, 10700, 10701, 3, 1490, 745, 0, 10701, 1439, 1, 0, 0, 0, 10702, 10703, 3, 1458, 729, 0, 10703, 1441, 1, 0, 0, 0, 10704, 10709, 3, 1482, 741, 0, 10705, 10706, 3, 1474, 737, 0, 10706, 10707, 3, 1380, 690, 0, 10707, 10709, 1, 0, 0, 0, 10708, 10704, 1, 0, 0, 0, 10708, 10705, 1, 0, 0, 0, 10709, 1443, 1, 0, 0, 0, 10710, 10715, 3, 1482, 741, 0, 10711, 10712, 3, 1474, 737, 0, 10712, 10713, 3, 1380, 690, 0, 10713, 10715, 1, 0, 0, 0, 10714, 10710, 1, 0, 0, 0, 10714, 10711, 1, 0, 0, 0, 10715, 1445, 1, 0, 0, 0, 10716, 10721, 3, 1484, 742, 0, 10717, 10718, 3, 1474, 737, 0, 10718, 10719, 3, 1380, 690, 0, 10719, 10721, 1, 0, 0, 0, 10720, 10716, 1, 0, 0, 0, 10720, 10717, 1, 0, 0, 0, 10721, 1447, 1, 0, 0, 0, 10722, 10758, 3, 1456, 728, 0, 10723, 10758, 3, 1454, 727, 0, 10724, 10758, 3, 1458, 729, 0, 10725, 10758, 3, 1452, 726, 0, 10726, 10758, 3, 1450, 725, 0, 10727, 10737, 3, 1444, 722, 0, 10728, 10738, 3, 1458, 729, 0, 10729, 10730, 5, 2, 0, 0, 10730, 10732, 3, 1338, 669, 0, 10731, 10733, 3, 1042, 521, 0, 10732, 10731, 1, 0, 0, 0, 10732, 10733, 1, 0, 0, 0, 10733, 10734, 1, 0, 0, 0, 10734, 10735, 5, 3, 0, 0, 10735, 10736, 3, 1458, 729, 0, 10736, 10738, 1, 0, 0, 0, 10737, 10728, 1, 0, 0, 0, 10737, 10729, 1, 0, 0, 0, 10738, 10758, 1, 0, 0, 0, 10739, 10740, 3, 1174, 587, 0, 10740, 10741, 3, 1458, 729, 0, 10741, 10758, 1, 0, 0, 0, 10742, 10752, 3, 1202, 601, 0, 10743, 10745, 3, 1458, 729, 0, 10744, 10746, 3, 1206, 603, 0, 10745, 10744, 1, 0, 0, 0, 10745, 10746, 1, 0, 0, 0, 10746, 10753, 1, 0, 0, 0, 10747, 10748, 5, 2, 0, 0, 10748, 10749, 3, 1456, 728, 0, 10749, 10750, 5, 3, 0, 0, 10750, 10751, 3, 1458, 729, 0, 10751, 10753, 1, 0, 0, 0, 10752, 10743, 1, 0, 0, 0, 10752, 10747, 1, 0, 0, 0, 10753, 10758, 1, 0, 0, 0, 10754, 10758, 5, 96, 0, 0, 10755, 10758, 5, 60, 0, 0, 10756, 10758, 5, 78, 0, 0, 10757, 10722, 1, 0, 0, 0, 10757, 10723, 1, 0, 0, 0, 10757, 10724, 1, 0, 0, 0, 10757, 10725, 1, 0, 0, 0, 10757, 10726, 1, 0, 0, 0, 10757, 10727, 1, 0, 0, 0, 10757, 10739, 1, 0, 0, 0, 10757, 10742, 1, 0, 0, 0, 10757, 10754, 1, 0, 0, 0, 10757, 10755, 1, 0, 0, 0, 10757, 10756, 1, 0, 0, 0, 10758, 1449, 1, 0, 0, 0, 10759, 10760, 5, 567, 0, 0, 10760, 1451, 1, 0, 0, 0, 10761, 10762, 5, 563, 0, 0, 10762, 1453, 1, 0, 0, 0, 10763, 10764, 5, 573, 0, 0, 10764, 1455, 1, 0, 0, 0, 10765, 10766, 5, 571, 0, 0, 10766, 1457, 1, 0, 0, 0, 10767, 10769, 3, 1460, 730, 0, 10768, 10770, 3, 1462, 731, 0, 10769, 10768, 1, 0, 0, 0, 10769, 10770, 1, 0, 0, 0, 10770, 1459, 1, 0, 0, 0, 10771, 10783, 5, 558, 0, 0, 10772, 10783, 5, 560, 0, 0, 10773, 10777, 5, 562, 0, 0, 10774, 10776, 5, 588, 0, 0, 10775, 10774, 1, 0, 0, 0, 10776, 10779, 1, 0, 0, 0, 10777, 10775, 1, 0, 0, 0, 10777, 10778, 1, 0, 0, 0, 10778, 10780, 1, 0, 0, 0, 10779, 10777, 1, 0, 0, 0, 10780, 10783, 5, 589, 0, 0, 10781, 10783, 5, 584, 0, 0, 10782, 10771, 1, 0, 0, 0, 10782, 10772, 1, 0, 0, 0, 10782, 10773, 1, 0, 0, 0, 10782, 10781, 1, 0, 0, 0, 10783, 1461, 1, 0, 0, 0, 10784, 10785, 5, 487, 0, 0, 10785, 10786, 3, 1460, 730, 0, 10786, 1463, 1, 0, 0, 0, 10787, 10793, 3, 1456, 728, 0, 10788, 10789, 5, 12, 0, 0, 10789, 10793, 3, 1456, 728, 0, 10790, 10791, 5, 13, 0, 0, 10791, 10793, 3, 1456, 728, 0, 10792, 10787, 1, 0, 0, 0, 10792, 10788, 1, 0, 0, 0, 10792, 10790, 1, 0, 0, 0, 10793, 1465, 1, 0, 0, 0, 10794, 10795, 3, 1470, 735, 0, 10795, 1467, 1, 0, 0, 0, 10796, 10797, 3, 1470, 735, 0, 10797, 1469, 1, 0, 0, 0, 10798, 10804, 3, 1488, 744, 0, 10799, 10804, 5, 52, 0, 0, 10800, 10804, 5, 49, 0, 0, 10801, 10804, 5, 89, 0, 0, 10802, 10804, 5, 524, 0, 0, 10803, 10798, 1, 0, 0, 0, 10803, 10799, 1, 0, 0, 0, 10803, 10800, 1, 0, 0, 0, 10803, 10801, 1, 0, 0, 0, 10803, 10802, 1, 0, 0, 0, 10804, 1471, 1, 0, 0, 0, 10805, 10810, 3, 1470, 735, 0, 10806, 10807, 5, 6, 0, 0, 10807, 10809, 3, 1470, 735, 0, 10808, 10806, 1, 0, 0, 0, 10809, 10812, 1, 0, 0, 0, 10810, 10808, 1, 0, 0, 0, 10810, 10811, 1, 0, 0, 0, 10811, 1473, 1, 0, 0, 0, 10812, 10810, 1, 0, 0, 0, 10813, 10818, 3, 1492, 746, 0, 10814, 10818, 3, 1496, 748, 0, 10815, 10818, 3, 1498, 749, 0, 10816, 10818, 3, 1734, 867, 0, 10817, 10813, 1, 0, 0, 0, 10817, 10814, 1, 0, 0, 0, 10817, 10815, 1, 0, 0, 0, 10817, 10816, 1, 0, 0, 0, 10818, 1475, 1, 0, 0, 0, 10819, 10820, 3, 1492, 746, 0, 10820, 1477, 1, 0, 0, 0, 10821, 10834, 3, 710, 355, 0, 10822, 10823, 5, 2, 0, 0, 10823, 10824, 3, 1212, 606, 0, 10824, 10825, 5, 3, 0, 0, 10825, 10826, 1, 0, 0, 0, 10826, 10828, 3, 1492, 746, 0, 10827, 10829, 3, 650, 325, 0, 10828, 10827, 1, 0, 0, 0, 10828, 10829, 1, 0, 0, 0, 10829, 10831, 1, 0, 0, 0, 10830, 10832, 3, 652, 326, 0, 10831, 10830, 1, 0, 0, 0, 10831, 10832, 1, 0, 0, 0, 10832, 10834, 1, 0, 0, 0, 10833, 10821, 1, 0, 0, 0, 10833, 10822, 1, 0, 0, 0, 10834, 1479, 1, 0, 0, 0, 10835, 10836, 5, 105, 0, 0, 10836, 10838, 3, 132, 66, 0, 10837, 10835, 1, 0, 0, 0, 10837, 10838, 1, 0, 0, 0, 10838, 10840, 1, 0, 0, 0, 10839, 10841, 3, 286, 143, 0, 10840, 10839, 1, 0, 0, 0, 10840, 10841, 1, 0, 0, 0, 10841, 1481, 1, 0, 0, 0, 10842, 10847, 3, 1492, 746, 0, 10843, 10847, 3, 1496, 748, 0, 10844, 10847, 3, 1734, 867, 0, 10845, 10847, 3, 1500, 750, 0, 10846, 10842, 1, 0, 0, 0, 10846, 10843, 1, 0, 0, 0, 10846, 10844, 1, 0, 0, 0, 10846, 10845, 1, 0, 0, 0, 10847, 1483, 1, 0, 0, 0, 10848, 10853, 3, 1492, 746, 0, 10849, 10853, 3, 1496, 748, 0, 10850, 10853, 3, 1734, 867, 0, 10851, 10853, 3, 1500, 750, 0, 10852, 10848, 1, 0, 0, 0, 10852, 10849, 1, 0, 0, 0, 10852, 10850, 1, 0, 0, 0, 10852, 10851, 1, 0, 0, 0, 10853, 1485, 1, 0, 0, 0, 10854, 10857, 3, 1432, 716, 0, 10855, 10857, 3, 1500, 750, 0, 10856, 10854, 1, 0, 0, 0, 10856, 10855, 1, 0, 0, 0, 10857, 1487, 1, 0, 0, 0, 10858, 10863, 3, 1492, 746, 0, 10859, 10863, 3, 1496, 748, 0, 10860, 10863, 3, 1498, 749, 0, 10861, 10863, 3, 1500, 750, 0, 10862, 10858, 1, 0, 0, 0, 10862, 10859, 1, 0, 0, 0, 10862, 10860, 1, 0, 0, 0, 10862, 10861, 1, 0, 0, 0, 10863, 1489, 1, 0, 0, 0, 10864, 10871, 3, 1492, 746, 0, 10865, 10871, 3, 1734, 867, 0, 10866, 10871, 3, 1496, 748, 0, 10867, 10871, 3, 1498, 749, 0, 10868, 10871, 3, 1500, 750, 0, 10869, 10871, 3, 1502, 751, 0, 10870, 10864, 1, 0, 0, 0, 10870, 10865, 1, 0, 0, 0, 10870, 10866, 1, 0, 0, 0, 10870, 10867, 1, 0, 0, 0, 10870, 10868, 1, 0, 0, 0, 10870, 10869, 1, 0, 0, 0, 10871, 1491, 1, 0, 0, 0, 10872, 10874, 5, 549, 0, 0, 10873, 10875, 3, 1462, 731, 0, 10874, 10873, 1, 0, 0, 0, 10874, 10875, 1, 0, 0, 0, 10875, 10883, 1, 0, 0, 0, 10876, 10883, 3, 1458, 729, 0, 10877, 10883, 5, 550, 0, 0, 10878, 10883, 5, 554, 0, 0, 10879, 10883, 3, 1256, 628, 0, 10880, 10883, 3, 1494, 747, 0, 10881, 10883, 3, 1734, 867, 0, 10882, 10872, 1, 0, 0, 0, 10882, 10876, 1, 0, 0, 0, 10882, 10877, 1, 0, 0, 0, 10882, 10878, 1, 0, 0, 0, 10882, 10879, 1, 0, 0, 0, 10882, 10880, 1, 0, 0, 0, 10882, 10881, 1, 0, 0, 0, 10883, 1493, 1, 0, 0, 0, 10884, 10885, 5, 575, 0, 0, 10885, 1495, 1, 0, 0, 0, 10886, 10887, 7, 78, 0, 0, 10887, 1497, 1, 0, 0, 0, 10888, 10940, 5, 387, 0, 0, 10889, 10940, 5, 388, 0, 0, 10890, 10940, 3, 1184, 592, 0, 10891, 10940, 5, 390, 0, 0, 10892, 10940, 5, 391, 0, 0, 10893, 10940, 3, 1192, 596, 0, 10894, 10940, 5, 393, 0, 0, 10895, 10940, 5, 394, 0, 0, 10896, 10940, 5, 395, 0, 0, 10897, 10940, 5, 396, 0, 0, 10898, 10940, 5, 397, 0, 0, 10899, 10940, 5, 398, 0, 0, 10900, 10940, 5, 399, 0, 0, 10901, 10940, 5, 470, 0, 0, 10902, 10940, 5, 400, 0, 0, 10903, 10940, 5, 401, 0, 0, 10904, 10940, 5, 402, 0, 0, 10905, 10940, 5, 403, 0, 0, 10906, 10940, 5, 404, 0, 0, 10907, 10940, 5, 405, 0, 0, 10908, 10940, 5, 406, 0, 0, 10909, 10940, 5, 407, 0, 0, 10910, 10940, 5, 489, 0, 0, 10911, 10940, 5, 408, 0, 0, 10912, 10940, 3, 1180, 590, 0, 10913, 10940, 5, 453, 0, 0, 10914, 10940, 5, 410, 0, 0, 10915, 10940, 5, 411, 0, 0, 10916, 10940, 5, 412, 0, 0, 10917, 10940, 5, 413, 0, 0, 10918, 10940, 5, 414, 0, 0, 10919, 10940, 5, 415, 0, 0, 10920, 10940, 5, 416, 0, 0, 10921, 10940, 5, 417, 0, 0, 10922, 10940, 5, 418, 0, 0, 10923, 10940, 5, 419, 0, 0, 10924, 10940, 5, 420, 0, 0, 10925, 10940, 5, 421, 0, 0, 10926, 10940, 5, 422, 0, 0, 10927, 10940, 5, 423, 0, 0, 10928, 10940, 5, 424, 0, 0, 10929, 10940, 5, 425, 0, 0, 10930, 10940, 5, 426, 0, 0, 10931, 10940, 5, 427, 0, 0, 10932, 10940, 5, 428, 0, 0, 10933, 10940, 5, 476, 0, 0, 10934, 10940, 5, 429, 0, 0, 10935, 10940, 5, 430, 0, 0, 10936, 10940, 5, 431, 0, 0, 10937, 10940, 5, 432, 0, 0, 10938, 10940, 5, 474, 0, 0, 10939, 10888, 1, 0, 0, 0, 10939, 10889, 1, 0, 0, 0, 10939, 10890, 1, 0, 0, 0, 10939, 10891, 1, 0, 0, 0, 10939, 10892, 1, 0, 0, 0, 10939, 10893, 1, 0, 0, 0, 10939, 10894, 1, 0, 0, 0, 10939, 10895, 1, 0, 0, 0, 10939, 10896, 1, 0, 0, 0, 10939, 10897, 1, 0, 0, 0, 10939, 10898, 1, 0, 0, 0, 10939, 10899, 1, 0, 0, 0, 10939, 10900, 1, 0, 0, 0, 10939, 10901, 1, 0, 0, 0, 10939, 10902, 1, 0, 0, 0, 10939, 10903, 1, 0, 0, 0, 10939, 10904, 1, 0, 0, 0, 10939, 10905, 1, 0, 0, 0, 10939, 10906, 1, 0, 0, 0, 10939, 10907, 1, 0, 0, 0, 10939, 10908, 1, 0, 0, 0, 10939, 10909, 1, 0, 0, 0, 10939, 10910, 1, 0, 0, 0, 10939, 10911, 1, 0, 0, 0, 10939, 10912, 1, 0, 0, 0, 10939, 10913, 1, 0, 0, 0, 10939, 10914, 1, 0, 0, 0, 10939, 10915, 1, 0, 0, 0, 10939, 10916, 1, 0, 0, 0, 10939, 10917, 1, 0, 0, 0, 10939, 10918, 1, 0, 0, 0, 10939, 10919, 1, 0, 0, 0, 10939, 10920, 1, 0, 0, 0, 10939, 10921, 1, 0, 0, 0, 10939, 10922, 1, 0, 0, 0, 10939, 10923, 1, 0, 0, 0, 10939, 10924, 1, 0, 0, 0, 10939, 10925, 1, 0, 0, 0, 10939, 10926, 1, 0, 0, 0, 10939, 10927, 1, 0, 0, 0, 10939, 10928, 1, 0, 0, 0, 10939, 10929, 1, 0, 0, 0, 10939, 10930, 1, 0, 0, 0, 10939, 10931, 1, 0, 0, 0, 10939, 10932, 1, 0, 0, 0, 10939, 10933, 1, 0, 0, 0, 10939, 10934, 1, 0, 0, 0, 10939, 10935, 1, 0, 0, 0, 10939, 10936, 1, 0, 0, 0, 10939, 10937, 1, 0, 0, 0, 10939, 10938, 1, 0, 0, 0, 10940, 1499, 1, 0, 0, 0, 10941, 10942, 7, 79, 0, 0, 10942, 1501, 1, 0, 0, 0, 10943, 10944, 7, 80, 0, 0, 10944, 1503, 1, 0, 0, 0, 10945, 10946, 3, 1506, 753, 0, 10946, 10947, 3, 1516, 758, 0, 10947, 10948, 3, 1514, 757, 0, 10948, 1505, 1, 0, 0, 0, 10949, 10951, 3, 1508, 754, 0, 10950, 10949, 1, 0, 0, 0, 10951, 10954, 1, 0, 0, 0, 10952, 10950, 1, 0, 0, 0, 10952, 10953, 1, 0, 0, 0, 10953, 1507, 1, 0, 0, 0, 10954, 10952, 1, 0, 0, 0, 10955, 10956, 3, 1510, 755, 0, 10956, 10957, 5, 279, 0, 0, 10957, 10958, 5, 490, 0, 0, 10958, 10976, 1, 0, 0, 0, 10959, 10960, 3, 1510, 755, 0, 10960, 10961, 5, 491, 0, 0, 10961, 10962, 3, 1512, 756, 0, 10962, 10976, 1, 0, 0, 0, 10963, 10964, 3, 1510, 755, 0, 10964, 10965, 5, 492, 0, 0, 10965, 10966, 5, 493, 0, 0, 10966, 10976, 1, 0, 0, 0, 10967, 10968, 3, 1510, 755, 0, 10968, 10969, 5, 492, 0, 0, 10969, 10970, 5, 494, 0, 0, 10970, 10976, 1, 0, 0, 0, 10971, 10972, 3, 1510, 755, 0, 10972, 10973, 5, 492, 0, 0, 10973, 10974, 5, 495, 0, 0, 10974, 10976, 1, 0, 0, 0, 10975, 10955, 1, 0, 0, 0, 10975, 10959, 1, 0, 0, 0, 10975, 10963, 1, 0, 0, 0, 10975, 10967, 1, 0, 0, 0, 10975, 10971, 1, 0, 0, 0, 10976, 1509, 1, 0, 0, 0, 10977, 10978, 5, 29, 0, 0, 10978, 1511, 1, 0, 0, 0, 10979, 10984, 3, 1458, 729, 0, 10980, 10984, 3, 1502, 751, 0, 10981, 10984, 3, 1734, 867, 0, 10982, 10984, 3, 1496, 748, 0, 10983, 10979, 1, 0, 0, 0, 10983, 10980, 1, 0, 0, 0, 10983, 10981, 1, 0, 0, 0, 10983, 10982, 1, 0, 0, 0, 10984, 1513, 1, 0, 0, 0, 10985, 10988, 1, 0, 0, 0, 10986, 10988, 5, 7, 0, 0, 10987, 10985, 1, 0, 0, 0, 10987, 10986, 1, 0, 0, 0, 10988, 1515, 1, 0, 0, 0, 10989, 10990, 3, 1518, 759, 0, 10990, 10991, 5, 146, 0, 0, 10991, 10992, 3, 1560, 780, 0, 10992, 10993, 3, 1714, 857, 0, 10993, 10994, 5, 454, 0, 0, 10994, 10995, 3, 1728, 864, 0, 10995, 1517, 1, 0, 0, 0, 10996, 11001, 3, 1724, 862, 0, 10997, 10999, 3, 1520, 760, 0, 10998, 11000, 3, 1522, 761, 0, 10999, 10998, 1, 0, 0, 0, 10999, 11000, 1, 0, 0, 0, 11000, 11002, 1, 0, 0, 0, 11001, 10997, 1, 0, 0, 0, 11001, 11002, 1, 0, 0, 0, 11002, 1519, 1, 0, 0, 0, 11003, 11004, 5, 178, 0, 0, 11004, 1521, 1, 0, 0, 0, 11005, 11007, 3, 1526, 763, 0, 11006, 11005, 1, 0, 0, 0, 11007, 11008, 1, 0, 0, 0, 11008, 11006, 1, 0, 0, 0, 11008, 11009, 1, 0, 0, 0, 11009, 1523, 1, 0, 0, 0, 11010, 11011, 5, 18, 0, 0, 11011, 11012, 3, 1732, 866, 0, 11012, 11013, 5, 19, 0, 0, 11013, 1525, 1, 0, 0, 0, 11014, 11018, 3, 1528, 764, 0, 11015, 11018, 5, 178, 0, 0, 11016, 11018, 3, 1524, 762, 0, 11017, 11014, 1, 0, 0, 0, 11017, 11015, 1, 0, 0, 0, 11017, 11016, 1, 0, 0, 0, 11018, 1527, 1, 0, 0, 0, 11019, 11035, 3, 1544, 772, 0, 11020, 11021, 5, 496, 0, 0, 11021, 11022, 5, 62, 0, 0, 11022, 11036, 3, 1542, 771, 0, 11023, 11024, 3, 1546, 773, 0, 11024, 11025, 3, 1548, 774, 0, 11025, 11026, 3, 1550, 775, 0, 11026, 11027, 3, 1552, 776, 0, 11027, 11028, 3, 1554, 777, 0, 11028, 11036, 1, 0, 0, 0, 11029, 11030, 3, 1530, 765, 0, 11030, 11031, 5, 172, 0, 0, 11031, 11032, 3, 1534, 767, 0, 11032, 11033, 3, 1540, 770, 0, 11033, 11034, 3, 1532, 766, 0, 11034, 11036, 1, 0, 0, 0, 11035, 11020, 1, 0, 0, 0, 11035, 11023, 1, 0, 0, 0, 11035, 11029, 1, 0, 0, 0, 11036, 11037, 1, 0, 0, 0, 11037, 11038, 5, 7, 0, 0, 11038, 1529, 1, 0, 0, 0, 11039, 11044, 1, 0, 0, 0, 11040, 11041, 5, 269, 0, 0, 11041, 11044, 5, 324, 0, 0, 11042, 11044, 5, 324, 0, 0, 11043, 11039, 1, 0, 0, 0, 11043, 11040, 1, 0, 0, 0, 11043, 11042, 1, 0, 0, 0, 11044, 1531, 1, 0, 0, 0, 11045, 11046, 3, 1000, 500, 0, 11046, 1533, 1, 0, 0, 0, 11047, 11053, 1, 0, 0, 0, 11048, 11049, 5, 2, 0, 0, 11049, 11050, 3, 1536, 768, 0, 11050, 11051, 5, 3, 0, 0, 11051, 11053, 1, 0, 0, 0, 11052, 11047, 1, 0, 0, 0, 11052, 11048, 1, 0, 0, 0, 11053, 1535, 1, 0, 0, 0, 11054, 11059, 3, 1538, 769, 0, 11055, 11056, 5, 6, 0, 0, 11056, 11058, 3, 1538, 769, 0, 11057, 11055, 1, 0, 0, 0, 11058, 11061, 1, 0, 0, 0, 11059, 11057, 1, 0, 0, 0, 11059, 11060, 1, 0, 0, 0, 11060, 1537, 1, 0, 0, 0, 11061, 11059, 1, 0, 0, 0, 11062, 11063, 3, 1544, 772, 0, 11063, 11064, 3, 1548, 774, 0, 11064, 1539, 1, 0, 0, 0, 11065, 11066, 7, 81, 0, 0, 11066, 1541, 1, 0, 0, 0, 11067, 11070, 5, 28, 0, 0, 11068, 11070, 3, 1474, 737, 0, 11069, 11067, 1, 0, 0, 0, 11069, 11068, 1, 0, 0, 0, 11070, 1543, 1, 0, 0, 0, 11071, 11072, 3, 1732, 866, 0, 11072, 1545, 1, 0, 0, 0, 11073, 11076, 1, 0, 0, 0, 11074, 11076, 5, 497, 0, 0, 11075, 11073, 1, 0, 0, 0, 11075, 11074, 1, 0, 0, 0, 11076, 1547, 1, 0, 0, 0, 11077, 11078, 3, 1168, 584, 0, 11078, 1549, 1, 0, 0, 0, 11079, 11083, 1, 0, 0, 0, 11080, 11081, 5, 43, 0, 0, 11081, 11083, 3, 558, 279, 0, 11082, 11079, 1, 0, 0, 0, 11082, 11080, 1, 0, 0, 0, 11083, 1551, 1, 0, 0, 0, 11084, 11088, 1, 0, 0, 0, 11085, 11086, 5, 77, 0, 0, 11086, 11088, 5, 78, 0, 0, 11087, 11084, 1, 0, 0, 0, 11087, 11085, 1, 0, 0, 0, 11088, 1553, 1, 0, 0, 0, 11089, 11094, 1, 0, 0, 0, 11090, 11091, 3, 1556, 778, 0, 11091, 11092, 3, 1736, 868, 0, 11092, 11094, 1, 0, 0, 0, 11093, 11089, 1, 0, 0, 0, 11093, 11090, 1, 0, 0, 0, 11094, 1555, 1, 0, 0, 0, 11095, 11098, 3, 1558, 779, 0, 11096, 11098, 5, 53, 0, 0, 11097, 11095, 1, 0, 0, 0, 11097, 11096, 1, 0, 0, 0, 11098, 1557, 1, 0, 0, 0, 11099, 11100, 7, 82, 0, 0, 11100, 1559, 1, 0, 0, 0, 11101, 11103, 3, 1562, 781, 0, 11102, 11101, 1, 0, 0, 0, 11103, 11106, 1, 0, 0, 0, 11104, 11102, 1, 0, 0, 0, 11104, 11105, 1, 0, 0, 0, 11105, 1561, 1, 0, 0, 0, 11106, 11104, 1, 0, 0, 0, 11107, 11108, 3, 1516, 758, 0, 11108, 11109, 5, 7, 0, 0, 11109, 11135, 1, 0, 0, 0, 11110, 11135, 3, 1628, 814, 0, 11111, 11135, 3, 1632, 816, 0, 11112, 11135, 3, 1570, 785, 0, 11113, 11135, 3, 1586, 793, 0, 11114, 11135, 3, 1592, 796, 0, 11115, 11135, 3, 1602, 801, 0, 11116, 11135, 3, 1604, 802, 0, 11117, 11135, 3, 1606, 803, 0, 11118, 11135, 3, 1620, 810, 0, 11119, 11135, 3, 1624, 812, 0, 11120, 11135, 3, 1644, 822, 0, 11121, 11135, 3, 1650, 825, 0, 11122, 11135, 3, 1652, 826, 0, 11123, 11135, 3, 1564, 782, 0, 11124, 11135, 3, 1566, 783, 0, 11125, 11135, 3, 1572, 786, 0, 11126, 11135, 3, 1660, 830, 0, 11127, 11135, 3, 1672, 836, 0, 11128, 11135, 3, 1680, 840, 0, 11129, 11135, 3, 1700, 850, 0, 11130, 11135, 3, 1702, 851, 0, 11131, 11135, 3, 1704, 852, 0, 11132, 11135, 3, 1706, 853, 0, 11133, 11135, 3, 1710, 855, 0, 11134, 11107, 1, 0, 0, 0, 11134, 11110, 1, 0, 0, 0, 11134, 11111, 1, 0, 0, 0, 11134, 11112, 1, 0, 0, 0, 11134, 11113, 1, 0, 0, 0, 11134, 11114, 1, 0, 0, 0, 11134, 11115, 1, 0, 0, 0, 11134, 11116, 1, 0, 0, 0, 11134, 11117, 1, 0, 0, 0, 11134, 11118, 1, 0, 0, 0, 11134, 11119, 1, 0, 0, 0, 11134, 11120, 1, 0, 0, 0, 11134, 11121, 1, 0, 0, 0, 11134, 11122, 1, 0, 0, 0, 11134, 11123, 1, 0, 0, 0, 11134, 11124, 1, 0, 0, 0, 11134, 11125, 1, 0, 0, 0, 11134, 11126, 1, 0, 0, 0, 11134, 11127, 1, 0, 0, 0, 11134, 11128, 1, 0, 0, 0, 11134, 11129, 1, 0, 0, 0, 11134, 11130, 1, 0, 0, 0, 11134, 11131, 1, 0, 0, 0, 11134, 11132, 1, 0, 0, 0, 11134, 11133, 1, 0, 0, 0, 11135, 1563, 1, 0, 0, 0, 11136, 11137, 5, 498, 0, 0, 11137, 11138, 3, 1740, 870, 0, 11138, 11139, 5, 7, 0, 0, 11139, 1565, 1, 0, 0, 0, 11140, 11141, 5, 433, 0, 0, 11141, 11147, 3, 1732, 866, 0, 11142, 11143, 5, 2, 0, 0, 11143, 11144, 3, 1568, 784, 0, 11144, 11145, 5, 3, 0, 0, 11145, 11146, 5, 7, 0, 0, 11146, 11148, 1, 0, 0, 0, 11147, 11142, 1, 0, 0, 0, 11147, 11148, 1, 0, 0, 0, 11148, 11157, 1, 0, 0, 0, 11149, 11150, 5, 57, 0, 0, 11150, 11151, 3, 1732, 866, 0, 11151, 11152, 5, 2, 0, 0, 11152, 11153, 3, 1568, 784, 0, 11153, 11154, 5, 3, 0, 0, 11154, 11155, 5, 7, 0, 0, 11155, 11157, 1, 0, 0, 0, 11156, 11140, 1, 0, 0, 0, 11156, 11149, 1, 0, 0, 0, 11157, 1567, 1, 0, 0, 0, 11158, 11161, 1, 0, 0, 0, 11159, 11161, 3, 1328, 664, 0, 11160, 11158, 1, 0, 0, 0, 11160, 11159, 1, 0, 0, 0, 11161, 1569, 1, 0, 0, 0, 11162, 11163, 3, 1584, 792, 0, 11163, 11164, 3, 1558, 779, 0, 11164, 11165, 3, 1736, 868, 0, 11165, 11166, 5, 7, 0, 0, 11166, 1571, 1, 0, 0, 0, 11167, 11168, 5, 499, 0, 0, 11168, 11169, 3, 1574, 787, 0, 11169, 11170, 5, 500, 0, 0, 11170, 11171, 3, 1576, 788, 0, 11171, 11172, 5, 7, 0, 0, 11172, 1573, 1, 0, 0, 0, 11173, 11177, 1, 0, 0, 0, 11174, 11177, 5, 434, 0, 0, 11175, 11177, 5, 501, 0, 0, 11176, 11173, 1, 0, 0, 0, 11176, 11174, 1, 0, 0, 0, 11176, 11175, 1, 0, 0, 0, 11177, 1575, 1, 0, 0, 0, 11178, 11183, 3, 1578, 789, 0, 11179, 11180, 5, 6, 0, 0, 11180, 11182, 3, 1578, 789, 0, 11181, 11179, 1, 0, 0, 0, 11182, 11185, 1, 0, 0, 0, 11183, 11181, 1, 0, 0, 0, 11183, 11184, 1, 0, 0, 0, 11184, 1577, 1, 0, 0, 0, 11185, 11183, 1, 0, 0, 0, 11186, 11187, 3, 1582, 791, 0, 11187, 11188, 3, 1558, 779, 0, 11188, 11189, 3, 1580, 790, 0, 11189, 1579, 1, 0, 0, 0, 11190, 11191, 3, 1474, 737, 0, 11191, 1581, 1, 0, 0, 0, 11192, 11193, 3, 1584, 792, 0, 11193, 1583, 1, 0, 0, 0, 11194, 11197, 3, 558, 279, 0, 11195, 11197, 5, 28, 0, 0, 11196, 11194, 1, 0, 0, 0, 11196, 11195, 1, 0, 0, 0, 11197, 11204, 1, 0, 0, 0, 11198, 11199, 5, 4, 0, 0, 11199, 11200, 3, 1742, 871, 0, 11200, 11201, 5, 5, 0, 0, 11201, 11203, 1, 0, 0, 0, 11202, 11198, 1, 0, 0, 0, 11203, 11206, 1, 0, 0, 0, 11204, 11202, 1, 0, 0, 0, 11204, 11205, 1, 0, 0, 0, 11205, 1585, 1, 0, 0, 0, 11206, 11204, 1, 0, 0, 0, 11207, 11208, 5, 220, 0, 0, 11208, 11209, 3, 1738, 869, 0, 11209, 11210, 5, 93, 0, 0, 11210, 11211, 3, 1560, 780, 0, 11211, 11212, 3, 1588, 794, 0, 11212, 11213, 3, 1590, 795, 0, 11213, 11214, 5, 454, 0, 0, 11214, 11215, 5, 220, 0, 0, 11215, 11216, 5, 7, 0, 0, 11216, 1587, 1, 0, 0, 0, 11217, 11218, 5, 502, 0, 0, 11218, 11219, 3, 1212, 606, 0, 11219, 11220, 5, 93, 0, 0, 11220, 11221, 3, 1560, 780, 0, 11221, 11223, 1, 0, 0, 0, 11222, 11217, 1, 0, 0, 0, 11223, 11226, 1, 0, 0, 0, 11224, 11222, 1, 0, 0, 0, 11224, 11225, 1, 0, 0, 0, 11225, 1589, 1, 0, 0, 0, 11226, 11224, 1, 0, 0, 0, 11227, 11231, 1, 0, 0, 0, 11228, 11229, 5, 58, 0, 0, 11229, 11231, 3, 1560, 780, 0, 11230, 11227, 1, 0, 0, 0, 11230, 11228, 1, 0, 0, 0, 11231, 1591, 1, 0, 0, 0, 11232, 11233, 5, 40, 0, 0, 11233, 11234, 3, 1594, 797, 0, 11234, 11235, 3, 1596, 798, 0, 11235, 11236, 3, 1600, 800, 0, 11236, 11237, 5, 454, 0, 0, 11237, 11238, 5, 40, 0, 0, 11238, 11239, 5, 7, 0, 0, 11239, 1593, 1, 0, 0, 0, 11240, 11243, 1, 0, 0, 0, 11241, 11243, 3, 1736, 868, 0, 11242, 11240, 1, 0, 0, 0, 11242, 11241, 1, 0, 0, 0, 11243, 1595, 1, 0, 0, 0, 11244, 11246, 3, 1598, 799, 0, 11245, 11244, 1, 0, 0, 0, 11246, 11247, 1, 0, 0, 0, 11247, 11245, 1, 0, 0, 0, 11247, 11248, 1, 0, 0, 0, 11248, 1597, 1, 0, 0, 0, 11249, 11250, 5, 102, 0, 0, 11250, 11251, 3, 1328, 664, 0, 11251, 11252, 5, 93, 0, 0, 11252, 11253, 3, 1560, 780, 0, 11253, 1599, 1, 0, 0, 0, 11254, 11258, 1, 0, 0, 0, 11255, 11256, 5, 58, 0, 0, 11256, 11258, 3, 1560, 780, 0, 11257, 11254, 1, 0, 0, 0, 11257, 11255, 1, 0, 0, 0, 11258, 1601, 1, 0, 0, 0, 11259, 11260, 3, 1726, 863, 0, 11260, 11261, 3, 1648, 824, 0, 11261, 1603, 1, 0, 0, 0, 11262, 11263, 3, 1726, 863, 0, 11263, 11264, 5, 503, 0, 0, 11264, 11265, 3, 1744, 872, 0, 11265, 11266, 3, 1648, 824, 0, 11266, 1605, 1, 0, 0, 0, 11267, 11268, 3, 1726, 863, 0, 11268, 11269, 5, 62, 0, 0, 11269, 11270, 3, 1608, 804, 0, 11270, 11271, 3, 1648, 824, 0, 11271, 1607, 1, 0, 0, 0, 11272, 11273, 3, 1618, 809, 0, 11273, 11289, 5, 68, 0, 0, 11274, 11275, 3, 994, 497, 0, 11275, 11276, 3, 1612, 806, 0, 11276, 11290, 1, 0, 0, 0, 11277, 11290, 3, 1000, 500, 0, 11278, 11290, 3, 926, 463, 0, 11279, 11280, 5, 202, 0, 0, 11280, 11281, 3, 1212, 606, 0, 11281, 11282, 3, 1610, 805, 0, 11282, 11290, 1, 0, 0, 0, 11283, 11284, 3, 1614, 807, 0, 11284, 11285, 3, 1212, 606, 0, 11285, 11286, 5, 24, 0, 0, 11286, 11287, 3, 1212, 606, 0, 11287, 11288, 3, 1616, 808, 0, 11288, 11290, 1, 0, 0, 0, 11289, 11274, 1, 0, 0, 0, 11289, 11277, 1, 0, 0, 0, 11289, 11278, 1, 0, 0, 0, 11289, 11279, 1, 0, 0, 0, 11289, 11283, 1, 0, 0, 0, 11290, 1609, 1, 0, 0, 0, 11291, 11295, 1, 0, 0, 0, 11292, 11293, 5, 100, 0, 0, 11293, 11295, 3, 1328, 664, 0, 11294, 11291, 1, 0, 0, 0, 11294, 11292, 1, 0, 0, 0, 11295, 1611, 1, 0, 0, 0, 11296, 11309, 1, 0, 0, 0, 11297, 11298, 5, 2, 0, 0, 11298, 11303, 3, 1212, 606, 0, 11299, 11300, 5, 6, 0, 0, 11300, 11302, 3, 1212, 606, 0, 11301, 11299, 1, 0, 0, 0, 11302, 11305, 1, 0, 0, 0, 11303, 11301, 1, 0, 0, 0, 11303, 11304, 1, 0, 0, 0, 11304, 11306, 1, 0, 0, 0, 11305, 11303, 1, 0, 0, 0, 11306, 11307, 5, 3, 0, 0, 11307, 11309, 1, 0, 0, 0, 11308, 11296, 1, 0, 0, 0, 11308, 11297, 1, 0, 0, 0, 11309, 1613, 1, 0, 0, 0, 11310, 11313, 1, 0, 0, 0, 11311, 11313, 5, 504, 0, 0, 11312, 11310, 1, 0, 0, 0, 11312, 11311, 1, 0, 0, 0, 11313, 1615, 1, 0, 0, 0, 11314, 11318, 1, 0, 0, 0, 11315, 11316, 5, 147, 0, 0, 11316, 11318, 3, 1212, 606, 0, 11317, 11314, 1, 0, 0, 0, 11317, 11315, 1, 0, 0, 0, 11318, 1617, 1, 0, 0, 0, 11319, 11320, 3, 552, 276, 0, 11320, 1619, 1, 0, 0, 0, 11321, 11322, 3, 1726, 863, 0, 11322, 11323, 5, 505, 0, 0, 11323, 11324, 3, 1618, 809, 0, 11324, 11325, 3, 1622, 811, 0, 11325, 11326, 5, 68, 0, 0, 11326, 11327, 5, 35, 0, 0, 11327, 11328, 3, 1212, 606, 0, 11328, 11329, 3, 1648, 824, 0, 11329, 1621, 1, 0, 0, 0, 11330, 11334, 1, 0, 0, 0, 11331, 11332, 5, 506, 0, 0, 11332, 11334, 3, 1456, 728, 0, 11333, 11330, 1, 0, 0, 0, 11333, 11331, 1, 0, 0, 0, 11334, 1623, 1, 0, 0, 0, 11335, 11336, 3, 1626, 813, 0, 11336, 11338, 3, 1728, 864, 0, 11337, 11339, 3, 1730, 865, 0, 11338, 11337, 1, 0, 0, 0, 11338, 11339, 1, 0, 0, 0, 11339, 11340, 1, 0, 0, 0, 11340, 11341, 5, 7, 0, 0, 11341, 1625, 1, 0, 0, 0, 11342, 11343, 7, 83, 0, 0, 11343, 1627, 1, 0, 0, 0, 11344, 11356, 5, 508, 0, 0, 11345, 11346, 5, 268, 0, 0, 11346, 11357, 3, 1736, 868, 0, 11347, 11353, 5, 509, 0, 0, 11348, 11349, 5, 202, 0, 0, 11349, 11350, 3, 1212, 606, 0, 11350, 11351, 3, 1610, 805, 0, 11351, 11354, 1, 0, 0, 0, 11352, 11354, 3, 1000, 500, 0, 11353, 11348, 1, 0, 0, 0, 11353, 11352, 1, 0, 0, 0, 11354, 11357, 1, 0, 0, 0, 11355, 11357, 3, 1630, 815, 0, 11356, 11345, 1, 0, 0, 0, 11356, 11347, 1, 0, 0, 0, 11356, 11355, 1, 0, 0, 0, 11357, 11358, 1, 0, 0, 0, 11358, 11359, 5, 7, 0, 0, 11359, 1629, 1, 0, 0, 0, 11360, 11363, 1, 0, 0, 0, 11361, 11363, 3, 1736, 868, 0, 11362, 11360, 1, 0, 0, 0, 11362, 11361, 1, 0, 0, 0, 11363, 1631, 1, 0, 0, 0, 11364, 11366, 5, 510, 0, 0, 11365, 11367, 3, 1634, 817, 0, 11366, 11365, 1, 0, 0, 0, 11366, 11367, 1, 0, 0, 0, 11367, 11368, 1, 0, 0, 0, 11368, 11369, 3, 1458, 729, 0, 11369, 11370, 3, 1636, 818, 0, 11370, 11371, 3, 1638, 819, 0, 11371, 11372, 5, 7, 0, 0, 11372, 11399, 1, 0, 0, 0, 11373, 11375, 5, 510, 0, 0, 11374, 11376, 3, 1634, 817, 0, 11375, 11374, 1, 0, 0, 0, 11375, 11376, 1, 0, 0, 0, 11376, 11377, 1, 0, 0, 0, 11377, 11378, 3, 1492, 746, 0, 11378, 11379, 3, 1638, 819, 0, 11379, 11380, 5, 7, 0, 0, 11380, 11399, 1, 0, 0, 0, 11381, 11383, 5, 510, 0, 0, 11382, 11384, 3, 1634, 817, 0, 11383, 11382, 1, 0, 0, 0, 11383, 11384, 1, 0, 0, 0, 11384, 11385, 1, 0, 0, 0, 11385, 11386, 5, 511, 0, 0, 11386, 11387, 3, 1458, 729, 0, 11387, 11388, 3, 1638, 819, 0, 11388, 11389, 5, 7, 0, 0, 11389, 11399, 1, 0, 0, 0, 11390, 11392, 5, 510, 0, 0, 11391, 11393, 3, 1634, 817, 0, 11392, 11391, 1, 0, 0, 0, 11392, 11393, 1, 0, 0, 0, 11393, 11394, 1, 0, 0, 0, 11394, 11395, 3, 1638, 819, 0, 11395, 11396, 5, 7, 0, 0, 11396, 11399, 1, 0, 0, 0, 11397, 11399, 5, 510, 0, 0, 11398, 11364, 1, 0, 0, 0, 11398, 11373, 1, 0, 0, 0, 11398, 11381, 1, 0, 0, 0, 11398, 11390, 1, 0, 0, 0, 11398, 11397, 1, 0, 0, 0, 11399, 1633, 1, 0, 0, 0, 11400, 11401, 7, 84, 0, 0, 11401, 1635, 1, 0, 0, 0, 11402, 11410, 1, 0, 0, 0, 11403, 11404, 5, 6, 0, 0, 11404, 11406, 3, 1212, 606, 0, 11405, 11403, 1, 0, 0, 0, 11406, 11407, 1, 0, 0, 0, 11407, 11405, 1, 0, 0, 0, 11407, 11408, 1, 0, 0, 0, 11408, 11410, 1, 0, 0, 0, 11409, 11402, 1, 0, 0, 0, 11409, 11405, 1, 0, 0, 0, 11410, 1637, 1, 0, 0, 0, 11411, 11415, 1, 0, 0, 0, 11412, 11413, 5, 100, 0, 0, 11413, 11415, 3, 1642, 821, 0, 11414, 11411, 1, 0, 0, 0, 11414, 11412, 1, 0, 0, 0, 11415, 1639, 1, 0, 0, 0, 11416, 11417, 3, 1492, 746, 0, 11417, 11418, 5, 10, 0, 0, 11418, 11419, 3, 1212, 606, 0, 11419, 1641, 1, 0, 0, 0, 11420, 11425, 3, 1640, 820, 0, 11421, 11422, 5, 6, 0, 0, 11422, 11424, 3, 1640, 820, 0, 11423, 11421, 1, 0, 0, 0, 11424, 11427, 1, 0, 0, 0, 11425, 11423, 1, 0, 0, 0, 11425, 11426, 1, 0, 0, 0, 11426, 1643, 1, 0, 0, 0, 11427, 11425, 1, 0, 0, 0, 11428, 11429, 5, 518, 0, 0, 11429, 11430, 3, 1736, 868, 0, 11430, 11431, 3, 1646, 823, 0, 11431, 11432, 5, 7, 0, 0, 11432, 1645, 1, 0, 0, 0, 11433, 11437, 1, 0, 0, 0, 11434, 11435, 5, 6, 0, 0, 11435, 11437, 3, 1736, 868, 0, 11436, 11433, 1, 0, 0, 0, 11436, 11434, 1, 0, 0, 0, 11437, 1647, 1, 0, 0, 0, 11438, 11439, 5, 519, 0, 0, 11439, 11440, 3, 1560, 780, 0, 11440, 11441, 5, 454, 0, 0, 11441, 11442, 5, 519, 0, 0, 11442, 11443, 3, 1728, 864, 0, 11443, 11444, 5, 7, 0, 0, 11444, 1649, 1, 0, 0, 0, 11445, 11446, 3, 1746, 873, 0, 11446, 11447, 5, 7, 0, 0, 11447, 1651, 1, 0, 0, 0, 11448, 11449, 5, 202, 0, 0, 11449, 11457, 3, 1212, 606, 0, 11450, 11451, 3, 1658, 829, 0, 11451, 11452, 3, 1654, 827, 0, 11452, 11458, 1, 0, 0, 0, 11453, 11454, 3, 1654, 827, 0, 11454, 11455, 3, 1658, 829, 0, 11455, 11458, 1, 0, 0, 0, 11456, 11458, 1, 0, 0, 0, 11457, 11450, 1, 0, 0, 0, 11457, 11453, 1, 0, 0, 0, 11457, 11456, 1, 0, 0, 0, 11458, 11459, 1, 0, 0, 0, 11459, 11460, 5, 7, 0, 0, 11460, 1653, 1, 0, 0, 0, 11461, 11465, 1, 0, 0, 0, 11462, 11463, 5, 100, 0, 0, 11463, 11465, 3, 1656, 828, 0, 11464, 11461, 1, 0, 0, 0, 11464, 11462, 1, 0, 0, 0, 11465, 1655, 1, 0, 0, 0, 11466, 11471, 3, 1212, 606, 0, 11467, 11468, 5, 6, 0, 0, 11468, 11470, 3, 1212, 606, 0, 11469, 11467, 1, 0, 0, 0, 11470, 11473, 1, 0, 0, 0, 11471, 11469, 1, 0, 0, 0, 11471, 11472, 1, 0, 0, 0, 11472, 1657, 1, 0, 0, 0, 11473, 11471, 1, 0, 0, 0, 11474, 11481, 1, 0, 0, 0, 11475, 11477, 5, 71, 0, 0, 11476, 11478, 5, 346, 0, 0, 11477, 11476, 1, 0, 0, 0, 11477, 11478, 1, 0, 0, 0, 11478, 11479, 1, 0, 0, 0, 11479, 11481, 3, 1674, 837, 0, 11480, 11474, 1, 0, 0, 0, 11480, 11475, 1, 0, 0, 0, 11481, 1659, 1, 0, 0, 0, 11482, 11500, 5, 520, 0, 0, 11483, 11484, 3, 1712, 856, 0, 11484, 11485, 3, 1668, 834, 0, 11485, 11491, 5, 62, 0, 0, 11486, 11492, 3, 1000, 500, 0, 11487, 11488, 5, 202, 0, 0, 11488, 11489, 3, 1736, 868, 0, 11489, 11490, 3, 1666, 833, 0, 11490, 11492, 1, 0, 0, 0, 11491, 11486, 1, 0, 0, 0, 11491, 11487, 1, 0, 0, 0, 11492, 11501, 1, 0, 0, 0, 11493, 11498, 3, 1474, 737, 0, 11494, 11495, 5, 2, 0, 0, 11495, 11496, 3, 1664, 832, 0, 11496, 11497, 5, 3, 0, 0, 11497, 11499, 1, 0, 0, 0, 11498, 11494, 1, 0, 0, 0, 11498, 11499, 1, 0, 0, 0, 11499, 11501, 1, 0, 0, 0, 11500, 11483, 1, 0, 0, 0, 11500, 11493, 1, 0, 0, 0, 11501, 11502, 1, 0, 0, 0, 11502, 11503, 5, 7, 0, 0, 11503, 1661, 1, 0, 0, 0, 11504, 11505, 3, 1474, 737, 0, 11505, 11506, 5, 20, 0, 0, 11506, 11507, 3, 1212, 606, 0, 11507, 11510, 1, 0, 0, 0, 11508, 11510, 3, 1212, 606, 0, 11509, 11504, 1, 0, 0, 0, 11509, 11508, 1, 0, 0, 0, 11510, 1663, 1, 0, 0, 0, 11511, 11516, 3, 1662, 831, 0, 11512, 11513, 5, 6, 0, 0, 11513, 11515, 3, 1662, 831, 0, 11514, 11512, 1, 0, 0, 0, 11515, 11518, 1, 0, 0, 0, 11516, 11514, 1, 0, 0, 0, 11516, 11517, 1, 0, 0, 0, 11517, 1665, 1, 0, 0, 0, 11518, 11516, 1, 0, 0, 0, 11519, 11523, 1, 0, 0, 0, 11520, 11521, 5, 100, 0, 0, 11521, 11523, 3, 1328, 664, 0, 11522, 11519, 1, 0, 0, 0, 11522, 11520, 1, 0, 0, 0, 11523, 1667, 1, 0, 0, 0, 11524, 11529, 1, 0, 0, 0, 11525, 11526, 3, 1670, 835, 0, 11526, 11527, 5, 324, 0, 0, 11527, 11529, 1, 0, 0, 0, 11528, 11524, 1, 0, 0, 0, 11528, 11525, 1, 0, 0, 0, 11529, 1669, 1, 0, 0, 0, 11530, 11533, 1, 0, 0, 0, 11531, 11533, 5, 269, 0, 0, 11532, 11530, 1, 0, 0, 0, 11532, 11531, 1, 0, 0, 0, 11533, 1671, 1, 0, 0, 0, 11534, 11536, 5, 61, 0, 0, 11535, 11537, 3, 1678, 839, 0, 11536, 11535, 1, 0, 0, 0, 11536, 11537, 1, 0, 0, 0, 11537, 11538, 1, 0, 0, 0, 11538, 11539, 3, 1676, 838, 0, 11539, 11540, 3, 1712, 856, 0, 11540, 11541, 5, 71, 0, 0, 11541, 11542, 3, 1674, 837, 0, 11542, 11543, 5, 7, 0, 0, 11543, 1673, 1, 0, 0, 0, 11544, 11545, 3, 1328, 664, 0, 11545, 1675, 1, 0, 0, 0, 11546, 11550, 1, 0, 0, 0, 11547, 11550, 5, 64, 0, 0, 11548, 11550, 5, 68, 0, 0, 11549, 11546, 1, 0, 0, 0, 11549, 11547, 1, 0, 0, 0, 11549, 11548, 1, 0, 0, 0, 11550, 1677, 1, 0, 0, 0, 11551, 11567, 5, 268, 0, 0, 11552, 11567, 5, 293, 0, 0, 11553, 11567, 5, 207, 0, 0, 11554, 11567, 5, 249, 0, 0, 11555, 11556, 5, 130, 0, 0, 11556, 11567, 3, 1212, 606, 0, 11557, 11558, 5, 307, 0, 0, 11558, 11567, 3, 1212, 606, 0, 11559, 11567, 3, 1212, 606, 0, 11560, 11567, 5, 30, 0, 0, 11561, 11564, 7, 85, 0, 0, 11562, 11565, 3, 1212, 606, 0, 11563, 11565, 5, 30, 0, 0, 11564, 11562, 1, 0, 0, 0, 11564, 11563, 1, 0, 0, 0, 11564, 11565, 1, 0, 0, 0, 11565, 11567, 1, 0, 0, 0, 11566, 11551, 1, 0, 0, 0, 11566, 11552, 1, 0, 0, 0, 11566, 11553, 1, 0, 0, 0, 11566, 11554, 1, 0, 0, 0, 11566, 11555, 1, 0, 0, 0, 11566, 11557, 1, 0, 0, 0, 11566, 11559, 1, 0, 0, 0, 11566, 11560, 1, 0, 0, 0, 11566, 11561, 1, 0, 0, 0, 11567, 1679, 1, 0, 0, 0, 11568, 11570, 5, 265, 0, 0, 11569, 11571, 3, 1678, 839, 0, 11570, 11569, 1, 0, 0, 0, 11570, 11571, 1, 0, 0, 0, 11571, 11572, 1, 0, 0, 0, 11572, 11573, 3, 1712, 856, 0, 11573, 11574, 5, 7, 0, 0, 11574, 1681, 1, 0, 0, 0, 11575, 11577, 3, 1014, 507, 0, 11576, 11575, 1, 0, 0, 0, 11576, 11577, 1, 0, 0, 0, 11577, 11578, 1, 0, 0, 0, 11578, 11579, 5, 525, 0, 0, 11579, 11581, 5, 71, 0, 0, 11580, 11582, 5, 81, 0, 0, 11581, 11580, 1, 0, 0, 0, 11581, 11582, 1, 0, 0, 0, 11582, 11583, 1, 0, 0, 0, 11583, 11585, 3, 1406, 703, 0, 11584, 11586, 5, 9, 0, 0, 11585, 11584, 1, 0, 0, 0, 11585, 11586, 1, 0, 0, 0, 11586, 11591, 1, 0, 0, 0, 11587, 11589, 5, 36, 0, 0, 11588, 11587, 1, 0, 0, 0, 11588, 11589, 1, 0, 0, 0, 11589, 11590, 1, 0, 0, 0, 11590, 11592, 3, 1474, 737, 0, 11591, 11588, 1, 0, 0, 0, 11591, 11592, 1, 0, 0, 0, 11592, 11593, 1, 0, 0, 0, 11593, 11594, 5, 100, 0, 0, 11594, 11595, 3, 1684, 842, 0, 11595, 11596, 5, 80, 0, 0, 11596, 11598, 3, 1686, 843, 0, 11597, 11599, 3, 1688, 844, 0, 11598, 11597, 1, 0, 0, 0, 11599, 11600, 1, 0, 0, 0, 11600, 11598, 1, 0, 0, 0, 11600, 11601, 1, 0, 0, 0, 11601, 1683, 1, 0, 0, 0, 11602, 11604, 5, 81, 0, 0, 11603, 11602, 1, 0, 0, 0, 11603, 11604, 1, 0, 0, 0, 11604, 11605, 1, 0, 0, 0, 11605, 11607, 3, 1406, 703, 0, 11606, 11608, 5, 9, 0, 0, 11607, 11606, 1, 0, 0, 0, 11607, 11608, 1, 0, 0, 0, 11608, 11614, 1, 0, 0, 0, 11609, 11612, 3, 1004, 502, 0, 11610, 11612, 3, 1100, 550, 0, 11611, 11609, 1, 0, 0, 0, 11611, 11610, 1, 0, 0, 0, 11612, 11614, 1, 0, 0, 0, 11613, 11603, 1, 0, 0, 0, 11613, 11611, 1, 0, 0, 0, 11614, 11619, 1, 0, 0, 0, 11615, 11617, 5, 36, 0, 0, 11616, 11615, 1, 0, 0, 0, 11616, 11617, 1, 0, 0, 0, 11617, 11618, 1, 0, 0, 0, 11618, 11620, 3, 1474, 737, 0, 11619, 11616, 1, 0, 0, 0, 11619, 11620, 1, 0, 0, 0, 11620, 1685, 1, 0, 0, 0, 11621, 11622, 3, 1212, 606, 0, 11622, 1687, 1, 0, 0, 0, 11623, 11624, 5, 102, 0, 0, 11624, 11627, 5, 526, 0, 0, 11625, 11626, 5, 33, 0, 0, 11626, 11628, 3, 1212, 606, 0, 11627, 11625, 1, 0, 0, 0, 11627, 11628, 1, 0, 0, 0, 11628, 11629, 1, 0, 0, 0, 11629, 11634, 5, 93, 0, 0, 11630, 11635, 3, 1692, 846, 0, 11631, 11635, 5, 182, 0, 0, 11632, 11633, 5, 57, 0, 0, 11633, 11635, 5, 270, 0, 0, 11634, 11630, 1, 0, 0, 0, 11634, 11631, 1, 0, 0, 0, 11634, 11632, 1, 0, 0, 0, 11635, 11650, 1, 0, 0, 0, 11636, 11637, 5, 102, 0, 0, 11637, 11638, 5, 77, 0, 0, 11638, 11641, 5, 526, 0, 0, 11639, 11640, 5, 33, 0, 0, 11640, 11642, 3, 1212, 606, 0, 11641, 11639, 1, 0, 0, 0, 11641, 11642, 1, 0, 0, 0, 11642, 11643, 1, 0, 0, 0, 11643, 11647, 5, 93, 0, 0, 11644, 11648, 3, 1690, 845, 0, 11645, 11646, 5, 57, 0, 0, 11646, 11648, 5, 270, 0, 0, 11647, 11644, 1, 0, 0, 0, 11647, 11645, 1, 0, 0, 0, 11648, 11650, 1, 0, 0, 0, 11649, 11623, 1, 0, 0, 0, 11649, 11636, 1, 0, 0, 0, 11650, 1689, 1, 0, 0, 0, 11651, 11656, 5, 241, 0, 0, 11652, 11653, 5, 2, 0, 0, 11653, 11654, 3, 244, 122, 0, 11654, 11655, 5, 3, 0, 0, 11655, 11657, 1, 0, 0, 0, 11656, 11652, 1, 0, 0, 0, 11656, 11657, 1, 0, 0, 0, 11657, 11661, 1, 0, 0, 0, 11658, 11659, 5, 463, 0, 0, 11659, 11660, 7, 53, 0, 0, 11660, 11662, 5, 450, 0, 0, 11661, 11658, 1, 0, 0, 0, 11661, 11662, 1, 0, 0, 0, 11662, 11663, 1, 0, 0, 0, 11663, 11664, 3, 1694, 847, 0, 11664, 1691, 1, 0, 0, 0, 11665, 11666, 5, 369, 0, 0, 11666, 11679, 5, 333, 0, 0, 11667, 11668, 3, 1432, 716, 0, 11668, 11669, 5, 10, 0, 0, 11669, 11670, 3, 1698, 849, 0, 11670, 11680, 1, 0, 0, 0, 11671, 11672, 5, 2, 0, 0, 11672, 11673, 3, 244, 122, 0, 11673, 11674, 5, 3, 0, 0, 11674, 11675, 5, 10, 0, 0, 11675, 11676, 5, 2, 0, 0, 11676, 11677, 3, 1696, 848, 0, 11677, 11678, 5, 3, 0, 0, 11678, 11680, 1, 0, 0, 0, 11679, 11667, 1, 0, 0, 0, 11679, 11671, 1, 0, 0, 0, 11680, 11681, 1, 0, 0, 0, 11681, 11679, 1, 0, 0, 0, 11681, 11682, 1, 0, 0, 0, 11682, 1693, 1, 0, 0, 0, 11683, 11684, 5, 422, 0, 0, 11684, 11688, 3, 1696, 848, 0, 11685, 11686, 5, 53, 0, 0, 11686, 11688, 5, 422, 0, 0, 11687, 11683, 1, 0, 0, 0, 11687, 11685, 1, 0, 0, 0, 11688, 1695, 1, 0, 0, 0, 11689, 11690, 5, 2, 0, 0, 11690, 11695, 3, 1698, 849, 0, 11691, 11692, 5, 6, 0, 0, 11692, 11694, 3, 1698, 849, 0, 11693, 11691, 1, 0, 0, 0, 11694, 11697, 1, 0, 0, 0, 11695, 11693, 1, 0, 0, 0, 11695, 11696, 1, 0, 0, 0, 11696, 11698, 1, 0, 0, 0, 11697, 11695, 1, 0, 0, 0, 11698, 11699, 5, 3, 0, 0, 11699, 1697, 1, 0, 0, 0, 11700, 11703, 3, 1048, 524, 0, 11701, 11703, 5, 53, 0, 0, 11702, 11700, 1, 0, 0, 0, 11702, 11701, 1, 0, 0, 0, 11703, 1699, 1, 0, 0, 0, 11704, 11705, 5, 157, 0, 0, 11705, 11706, 3, 1712, 856, 0, 11706, 11707, 5, 7, 0, 0, 11707, 1701, 1, 0, 0, 0, 11708, 11709, 5, 78, 0, 0, 11709, 11710, 5, 7, 0, 0, 11710, 1703, 1, 0, 0, 0, 11711, 11713, 5, 161, 0, 0, 11712, 11714, 3, 1708, 854, 0, 11713, 11712, 1, 0, 0, 0, 11713, 11714, 1, 0, 0, 0, 11714, 11715, 1, 0, 0, 0, 11715, 11716, 5, 7, 0, 0, 11716, 1705, 1, 0, 0, 0, 11717, 11719, 5, 319, 0, 0, 11718, 11720, 3, 1708, 854, 0, 11719, 11718, 1, 0, 0, 0, 11719, 11720, 1, 0, 0, 0, 11720, 11721, 1, 0, 0, 0, 11721, 11722, 5, 7, 0, 0, 11722, 1707, 1, 0, 0, 0, 11723, 11725, 5, 33, 0, 0, 11724, 11726, 5, 269, 0, 0, 11725, 11724, 1, 0, 0, 0, 11725, 11726, 1, 0, 0, 0, 11726, 11727, 1, 0, 0, 0, 11727, 11728, 5, 153, 0, 0, 11728, 1709, 1, 0, 0, 0, 11729, 11730, 5, 333, 0, 0, 11730, 11731, 3, 558, 279, 0, 11731, 11732, 5, 94, 0, 0, 11732, 11733, 5, 53, 0, 0, 11733, 11734, 5, 7, 0, 0, 11734, 11742, 1, 0, 0, 0, 11735, 11738, 5, 313, 0, 0, 11736, 11739, 3, 558, 279, 0, 11737, 11739, 5, 30, 0, 0, 11738, 11736, 1, 0, 0, 0, 11738, 11737, 1, 0, 0, 0, 11739, 11740, 1, 0, 0, 0, 11740, 11742, 5, 7, 0, 0, 11741, 11729, 1, 0, 0, 0, 11741, 11735, 1, 0, 0, 0, 11742, 1711, 1, 0, 0, 0, 11743, 11746, 3, 1474, 737, 0, 11744, 11746, 5, 28, 0, 0, 11745, 11743, 1, 0, 0, 0, 11745, 11744, 1, 0, 0, 0, 11746, 1713, 1, 0, 0, 0, 11747, 11751, 1, 0, 0, 0, 11748, 11749, 5, 517, 0, 0, 11749, 11751, 3, 1716, 858, 0, 11750, 11747, 1, 0, 0, 0, 11750, 11748, 1, 0, 0, 0, 11751, 1715, 1, 0, 0, 0, 11752, 11754, 3, 1718, 859, 0, 11753, 11752, 1, 0, 0, 0, 11754, 11755, 1, 0, 0, 0, 11755, 11753, 1, 0, 0, 0, 11755, 11756, 1, 0, 0, 0, 11756, 1717, 1, 0, 0, 0, 11757, 11758, 5, 102, 0, 0, 11758, 11759, 3, 1720, 860, 0, 11759, 11760, 5, 93, 0, 0, 11760, 11761, 3, 1560, 780, 0, 11761, 1719, 1, 0, 0, 0, 11762, 11767, 3, 1722, 861, 0, 11763, 11764, 5, 82, 0, 0, 11764, 11766, 3, 1722, 861, 0, 11765, 11763, 1, 0, 0, 0, 11766, 11769, 1, 0, 0, 0, 11767, 11765, 1, 0, 0, 0, 11767, 11768, 1, 0, 0, 0, 11768, 1721, 1, 0, 0, 0, 11769, 11767, 1, 0, 0, 0, 11770, 11774, 3, 1732, 866, 0, 11771, 11772, 5, 511, 0, 0, 11772, 11774, 3, 1458, 729, 0, 11773, 11770, 1, 0, 0, 0, 11773, 11771, 1, 0, 0, 0, 11774, 1723, 1, 0, 0, 0, 11775, 11778, 1, 0, 0, 0, 11776, 11778, 3, 1524, 762, 0, 11777, 11775, 1, 0, 0, 0, 11777, 11776, 1, 0, 0, 0, 11778, 1725, 1, 0, 0, 0, 11779, 11782, 1, 0, 0, 0, 11780, 11782, 3, 1524, 762, 0, 11781, 11779, 1, 0, 0, 0, 11781, 11780, 1, 0, 0, 0, 11782, 1727, 1, 0, 0, 0, 11783, 11786, 1, 0, 0, 0, 11784, 11786, 3, 1732, 866, 0, 11785, 11783, 1, 0, 0, 0, 11785, 11784, 1, 0, 0, 0, 11786, 1729, 1, 0, 0, 0, 11787, 11788, 5, 102, 0, 0, 11788, 11789, 3, 1740, 870, 0, 11789, 1731, 1, 0, 0, 0, 11790, 11793, 3, 1474, 737, 0, 11791, 11793, 3, 1734, 867, 0, 11792, 11790, 1, 0, 0, 0, 11792, 11791, 1, 0, 0, 0, 11793, 1733, 1, 0, 0, 0, 11794, 11795, 7, 86, 0, 0, 11795, 1735, 1, 0, 0, 0, 11796, 11798, 3, 1384, 692, 0, 11797, 11796, 1, 0, 0, 0, 11797, 11798, 1, 0, 0, 0, 11798, 11800, 1, 0, 0, 0, 11799, 11801, 3, 1028, 514, 0, 11800, 11799, 1, 0, 0, 0, 11800, 11801, 1, 0, 0, 0, 11801, 11803, 1, 0, 0, 0, 11802, 11804, 3, 1102, 551, 0, 11803, 11802, 1, 0, 0, 0, 11803, 11804, 1, 0, 0, 0, 11804, 11806, 1, 0, 0, 0, 11805, 11807, 3, 1144, 572, 0, 11806, 11805, 1, 0, 0, 0, 11806, 11807, 1, 0, 0, 0, 11807, 11809, 1, 0, 0, 0, 11808, 11810, 3, 1072, 536, 0, 11809, 11808, 1, 0, 0, 0, 11809, 11810, 1, 0, 0, 0, 11810, 11812, 1, 0, 0, 0, 11811, 11813, 3, 1086, 543, 0, 11812, 11811, 1, 0, 0, 0, 11812, 11813, 1, 0, 0, 0, 11813, 11815, 1, 0, 0, 0, 11814, 11816, 3, 1288, 644, 0, 11815, 11814, 1, 0, 0, 0, 11815, 11816, 1, 0, 0, 0, 11816, 1737, 1, 0, 0, 0, 11817, 11818, 3, 1736, 868, 0, 11818, 1739, 1, 0, 0, 0, 11819, 11820, 3, 1736, 868, 0, 11820, 1741, 1, 0, 0, 0, 11821, 11822, 3, 1212, 606, 0, 11822, 1743, 1, 0, 0, 0, 11823, 11824, 3, 1212, 606, 0, 11824, 1745, 1, 0, 0, 0, 11825, 11827, 3, 6, 3, 0, 11826, 11828, 3, 1748, 874, 0, 11827, 11826, 1, 0, 0, 0, 11827, 11828, 1, 0, 0, 0, 11828, 1747, 1, 0, 0, 0, 11829, 11830, 5, 71, 0, 0, 11830, 11831, 3, 1030, 515, 0, 11831, 11832, 3, 1674, 837, 0, 11832, 1749, 1, 0, 0, 0, 1282, 1753, 1762, 1881, 1885, 1894, 1903, 1909, 1915, 1947, 1959, 1965, 1973, 1981, 1987, 1996, 2002, 2014, 2020, 2026, 2033, 2037, 2042, 2046, 2059, 2070, 2076, 2092, 2095, 2100, 2106, 2111, 2120, 2124, 2136, 2140, 2143, 2147, 2158, 2176, 2183, 2191, 2196, 2203, 2209, 2215, 2222, 2233, 2237, 2241, 2245, 2258, 2262, 2267, 2272, 2284, 2293, 2305, 2310, 2321, 2327, 2332, 2342, 2347, 2354, 2359, 2364, 2375, 2381, 2386, 2394, 2403, 2418, 2424, 2430, 2435, 2442, 2454, 2462, 2470, 2488, 2497, 2511, 2515, 2530, 2538, 2548, 2588, 2591, 2595, 2599, 2602, 2607, 2614, 2623, 2629, 2633, 2642, 2650, 2659, 2668, 2672, 2679, 2685, 2689, 2693, 2698, 2701, 2705, 2711, 2718, 2734, 2748, 2758, 2760, 2765, 2769, 2772, 2778, 2780, 2808, 2818, 2831, 2838, 2843, 2847, 2853, 2858, 2861, 2863, 2868, 2872, 2876, 2880, 2884, 2887, 2891, 2899, 2903, 2907, 2916, 2923, 2928, 2935, 2940, 2947, 2952, 2970, 2975, 2987, 2992, 3001, 3008, 3015, 3019, 3024, 3028, 3031, 3034, 3037, 3040, 3043, 3048, 3051, 3054, 3057, 3060, 3063, 3069, 3073, 3076, 3079, 3082, 3085, 3087, 3096, 3111, 3119, 3125, 3129, 3134, 3137, 3140, 3144, 3148, 3162, 3167, 3174, 3179, 3183, 3186, 3190, 3193, 3195, 3202, 3205, 3209, 3215, 3218, 3225, 3234, 3241, 3246, 3249, 3252, 3255, 3259, 3266, 3271, 3284, 3294, 3307, 3310, 3313, 3320, 3328, 3331, 3334, 3341, 3345, 3351, 3354, 3357, 3360, 3372, 3375, 3378, 3382, 3400, 3408, 3424, 3435, 3450, 3467, 3469, 3490, 3495, 3498, 3502, 3505, 3511, 3514, 3516, 3527, 3536, 3542, 3545, 3548, 3562, 3565, 3568, 3573, 3581, 3590, 3594, 3600, 3604, 3607, 3610, 3613, 3616, 3622, 3626, 3631, 3637, 3641, 3644, 3647, 3650, 3658, 3662, 3666, 3670, 3674, 3679, 3693, 3702, 3719, 3724, 3727, 3729, 3739, 3746, 3751, 3754, 3757, 3764, 3767, 3769, 3775, 3784, 3794, 3799, 3807, 3811, 3818, 3828, 3839, 3947, 3955, 3958, 3968, 3973, 3983, 3994, 4006, 4019, 4029, 4041, 4045, 4048, 4055, 4063, 4073, 4075, 4081, 4086, 4090, 4095, 4101, 4108, 4114, 4116, 4123, 4131, 4136, 4147, 4154, 4158, 4175, 4178, 4181, 4184, 4187, 4195, 4198, 4201, 4207, 4215, 4219, 4231, 4237, 4240, 4245, 4249, 4256, 4267, 4290, 4310, 4319, 4322, 4325, 4335, 4338, 4347, 4351, 4354, 4362, 4368, 4372, 4383, 4393, 4401, 4406, 4418, 4435, 4439, 4445, 4452, 4460, 4474, 4500, 4507, 4521, 4532, 4535, 4548, 4557, 4582, 4593, 4635, 4643, 4649, 4660, 4666, 4674, 4685, 4699, 4708, 4713, 4724, 4735, 4743, 4753, 4760, 4763, 4769, 4772, 4787, 4800, 4829, 4836, 4851, 4863, 4867, 4872, 4876, 4881, 4885, 4891, 4895, 4900, 4904, 4910, 4914, 4919, 4923, 4928, 4932, 4937, 4941, 4948, 4952, 4959, 4963, 4970, 4974, 4981, 4985, 4991, 4995, 5001, 5005, 5010, 5014, 5021, 5025, 5029, 5033, 5037, 5042, 5046, 5051, 5055, 5060, 5064, 5069, 5075, 5080, 5086, 5091, 5097, 5102, 5106, 5111, 5115, 5121, 5125, 5130, 5138, 5144, 5150, 5156, 5162, 5169, 5174, 5178, 5183, 5187, 5192, 5198, 5205, 5210, 5217, 5227, 5231, 5237, 5239, 5246, 5250, 5255, 5273, 5288, 5306, 5315, 5324, 5328, 5334, 5341, 5346, 5353, 5358, 5361, 5364, 5368, 5439, 5535, 5539, 5544, 5555, 5566, 5577, 5588, 5599, 5611, 5622, 5633, 5643, 5650, 5657, 5663, 5671, 5676, 5681, 5686, 5692, 5699, 5705, 5711, 5716, 5722, 5729, 5734, 5740, 5747, 5750, 5763, 5772, 5784, 5786, 5804, 5811, 5821, 5826, 5830, 5834, 5838, 5840, 5900, 5907, 5913, 5924, 5927, 5934, 5937, 5947, 5950, 5952, 5971, 5983, 5992, 6001, 6013, 6015, 6021, 6025, 6028, 6031, 6036, 6042, 6045, 6048, 6051, 6054, 6070, 6074, 6077, 6080, 6083, 6086, 6091, 6094, 6096, 6109, 6121, 6135, 6139, 6145, 6155, 6157, 6162, 6170, 6180, 6189, 6197, 6206, 6208, 6215, 6224, 6226, 6233, 6242, 6244, 6248, 6257, 6262, 6268, 6273, 6277, 6282, 6300, 6305, 6320, 6329, 6340, 6346, 6383, 6403, 6410, 6421, 6435, 6442, 6450, 6455, 6462, 6466, 6471, 6475, 6480, 6484, 6486, 6491, 6495, 6500, 6504, 6528, 6535, 6545, 6557, 6562, 6575, 6587, 6599, 6601, 6607, 6614, 6659, 6677, 6681, 6686, 6689, 6693, 6698, 6703, 6706, 6713, 6730, 6801, 6832, 6886, 6896, 6906, 6917, 6927, 6938, 6948, 6953, 6962, 6967, 6977, 6982, 6991, 7004, 7009, 7121, 7123, 7132, 7143, 7154, 7167, 7179, 7190, 7197, 7287, 7340, 7350, 7361, 7372, 7386, 7401, 7412, 7419, 7473, 7614, 7620, 7623, 7633, 7673, 7683, 7690, 7713, 7722, 7731, 7740, 7773, 7777, 7787, 7791, 7801, 7804, 7808, 7812, 7820, 7831, 7843, 7847, 7850, 7854, 7857, 7862, 7866, 7869, 7875, 7886, 7889, 7896, 7900, 7905, 7908, 7910, 7924, 7928, 7933, 7940, 7947, 7950, 7955, 7958, 7967, 7969, 7974, 7978, 7990, 7993, 8000, 8004, 8009, 8019, 8029, 8032, 8035, 8037, 8043, 8050, 8070, 8090, 8094, 8099, 8168, 8173, 8179, 8192, 8196, 8200, 8206, 8208, 8216, 8226, 8229, 8232, 8235, 8238, 8245, 8248, 8250, 8254, 8257, 8264, 8266, 8273, 8280, 8284, 8288, 8297, 8303, 8307, 8311, 8316, 8328, 8335, 8345, 8358, 8369, 8376, 8381, 8385, 8389, 8394, 8407, 8412, 8416, 8420, 8427, 8430, 8432, 8440, 8444, 8447, 8454, 8457, 8462, 8468, 8474, 8478, 8487, 8496, 8503, 8506, 8512, 8517, 8523, 8529, 8532, 8535, 8542, 8546, 8549, 8564, 8567, 8574, 8577, 8584, 8587, 8590, 8597, 8609, 8616, 8618, 8628, 8646, 8648, 8656, 8660, 8670, 8674, 8678, 8682, 8684, 8689, 8693, 8697, 8699, 8701, 8705, 8709, 8712, 8715, 8718, 8721, 8723, 8726, 8729, 8732, 8735, 8738, 8741, 8750, 8752, 8757, 8761, 8767, 8771, 8775, 8784, 8789, 8793, 8799, 8802, 8821, 8829, 8838, 8842, 8845, 8849, 8854, 8860, 8872, 8887, 8894, 8897, 8901, 8905, 8909, 8911, 8919, 8928, 8934, 8936, 8943, 8947, 8956, 8960, 8969, 8978, 8990, 9018, 9025, 9029, 9032, 9037, 9041, 9044, 9060, 9071, 9076, 9079, 9082, 9086, 9090, 9094, 9099, 9103, 9107, 9109, 9118, 9123, 9129, 9133, 9135, 9142, 9147, 9153, 9155, 9159, 9166, 9173, 9176, 9182, 9186, 9195, 9198, 9202, 9210, 9216, 9218, 9221, 9225, 9228, 9231, 9235, 9239, 9245, 9248, 9257, 9264, 9266, 9273, 9281, 9286, 9289, 9297, 9306, 9314, 9316, 9320, 9327, 9346, 9355, 9361, 9380, 9389, 9395, 9399, 9404, 9414, 9421, 9430, 9433, 9442, 9444, 9450, 9454, 9459, 9469, 9475, 9477, 9483, 9487, 9490, 9503, 9509, 9513, 9517, 9520, 9528, 9532, 9536, 9544, 9551, 9558, 9562, 9568, 9570, 9579, 9582, 9592, 9608, 9614, 9619, 9626, 9635, 9642, 9650, 9658, 9663, 9667, 9670, 9676, 9681, 9697, 9700, 9702, 9714, 9716, 9720, 9728, 9730, 9734, 9736, 9744, 9748, 9757, 9765, 9771, 9774, 9783, 9788, 9795, 9805, 9831, 9842, 9844, 9846, 9854, 9876, 9885, 9895, 9898, 9903, 9908, 9912, 9915, 9919, 9922, 9925, 9928, 9932, 9946, 9953, 9960, 9967, 9985, 9993, 10005, 10011, 10024, 10063, 10065, 10085, 10095, 10106, 10118, 10125, 10137, 10149, 10155, 10163, 10180, 10205, 10215, 10219, 10222, 10225, 10228, 10241, 10246, 10251, 10253, 10261, 10270, 10279, 10284, 10293, 10298, 10312, 10322, 10330, 10344, 10351, 10359, 10367, 10375, 10379, 10386, 10394, 10401, 10407, 10416, 10431, 10442, 10475, 10484, 10491, 10495, 10499, 10506, 10520, 10525, 10530, 10534, 10536, 10539, 10546, 10551, 10561, 10569, 10572, 10579, 10587, 10595, 10603, 10611, 10616, 10620, 10624, 10628, 10632, 10636, 10640, 10647, 10655, 10660, 10664, 10668, 10678, 10684, 10690, 10694, 10708, 10714, 10720, 10732, 10737, 10745, 10752, 10757, 10769, 10777, 10782, 10792, 10803, 10810, 10817, 10828, 10831, 10833, 10837, 10840, 10846, 10852, 10856, 10862, 10870, 10874, 10882, 10939, 10952, 10975, 10983, 10987, 10999, 11001, 11008, 11017, 11035, 11043, 11052, 11059, 11069, 11075, 11082, 11087, 11093, 11097, 11104, 11134, 11147, 11156, 11160, 11176, 11183, 11196, 11204, 11224, 11230, 11242, 11247, 11257, 11289, 11294, 11303, 11308, 11312, 11317, 11333, 11338, 11353, 11356, 11362, 11366, 11375, 11383, 11392, 11398, 11407, 11409, 11414, 11425, 11436, 11457, 11464, 11471, 11477, 11480, 11491, 11498, 11500, 11509, 11516, 11522, 11528, 11532, 11536, 11549, 11564, 11566, 11570, 11576, 11581, 11585, 11588, 11591, 11600, 11603, 11607, 11611, 11613, 11616, 11619, 11627, 11634, 11641, 11647, 11649, 11656, 11661, 11679, 11681, 11687, 11695, 11702, 11713, 11719, 11725, 11738, 11741, 11745, 11750, 11755, 11767, 11773, 11777, 11781, 11785, 11792, 11797, 11800, 11803, 11806, 11809, 11812, 11815, 11827] \ No newline at end of file +[4, 1, 590, 8504, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, 2, 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 1, 0, 5, 0, 936, 8, 0, 10, 0, 12, 0, 939, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 945, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1065, 8, 2, 3, 2, 1067, 8, 2, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1076, 8, 4, 1, 4, 5, 4, 1079, 8, 4, 10, 4, 12, 4, 1082, 9, 4, 1, 5, 1, 5, 1, 5, 3, 5, 1087, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1122, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 1132, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 1138, 8, 7, 1, 7, 5, 7, 1141, 8, 7, 10, 7, 12, 7, 1144, 9, 7, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 1150, 8, 8, 1, 8, 5, 8, 1153, 8, 8, 10, 8, 12, 8, 1156, 9, 8, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 1162, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 1173, 8, 10, 1, 10, 1, 10, 1, 11, 1, 11, 5, 11, 1179, 8, 11, 10, 11, 12, 11, 1182, 9, 11, 1, 11, 3, 11, 1185, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1197, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1203, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1209, 8, 12, 1, 12, 1, 12, 3, 12, 1213, 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1218, 8, 12, 1, 12, 1, 12, 3, 12, 1222, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1235, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 1245, 8, 12, 3, 12, 1247, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 1253, 8, 13, 1, 13, 5, 13, 1256, 8, 13, 10, 13, 12, 13, 1259, 9, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 3, 15, 1271, 8, 15, 1, 15, 3, 15, 1274, 8, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1279, 8, 15, 1, 15, 5, 15, 1282, 8, 15, 10, 15, 12, 15, 1285, 9, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 1295, 8, 17, 1, 18, 1, 18, 3, 18, 1299, 8, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 1311, 8, 19, 1, 20, 1, 20, 3, 20, 1315, 8, 20, 1, 20, 3, 20, 1318, 8, 20, 1, 20, 1, 20, 3, 20, 1322, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 1334, 8, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 1352, 8, 21, 1, 22, 1, 22, 1, 22, 5, 22, 1357, 8, 22, 10, 22, 12, 22, 1360, 9, 22, 1, 23, 1, 23, 1, 23, 5, 23, 1365, 8, 23, 10, 23, 12, 23, 1368, 9, 23, 1, 24, 1, 24, 3, 24, 1372, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 1379, 8, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 1387, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 1393, 8, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1401, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1409, 8, 28, 1, 29, 1, 29, 3, 29, 1413, 8, 29, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 1427, 8, 31, 1, 32, 1, 32, 1, 32, 3, 32, 1432, 8, 32, 1, 33, 1, 33, 1, 33, 3, 33, 1437, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1449, 8, 34, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 1455, 8, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 3, 38, 1467, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1472, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1482, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1488, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1493, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1501, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1506, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1513, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1518, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1523, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1533, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1538, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1543, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1550, 8, 38, 1, 38, 1, 38, 3, 38, 1554, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1568, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1574, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1580, 8, 38, 1, 38, 1, 38, 1, 38, 3, 38, 1585, 8, 38, 1, 39, 1, 39, 1, 39, 5, 39, 1590, 8, 39, 10, 39, 12, 39, 1593, 9, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1604, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41, 5, 41, 1610, 8, 41, 10, 41, 12, 41, 1613, 9, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 3, 42, 1620, 8, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 1636, 8, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 3, 46, 1645, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 5, 46, 1652, 8, 46, 10, 46, 12, 46, 1655, 9, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1663, 8, 46, 1, 46, 1, 46, 3, 46, 1667, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1679, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1687, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1697, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1717, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1722, 8, 46, 1, 46, 3, 46, 1725, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1732, 8, 46, 1, 46, 3, 46, 1735, 8, 46, 1, 46, 1, 46, 3, 46, 1739, 8, 46, 1, 46, 1, 46, 3, 46, 1743, 8, 46, 1, 46, 3, 46, 1746, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1751, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1756, 8, 46, 1, 46, 1, 46, 3, 46, 1760, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1769, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1775, 8, 46, 1, 46, 1, 46, 3, 46, 1779, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1788, 8, 46, 1, 46, 3, 46, 1791, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1797, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1806, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 4, 46, 1816, 8, 46, 11, 46, 12, 46, 1817, 1, 46, 1, 46, 3, 46, 1822, 8, 46, 1, 46, 1, 46, 3, 46, 1826, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1831, 8, 46, 1, 46, 3, 46, 1834, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1840, 8, 46, 4, 46, 1842, 8, 46, 11, 46, 12, 46, 1843, 1, 46, 1, 46, 3, 46, 1848, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1854, 8, 46, 1, 46, 1, 46, 3, 46, 1858, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1863, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1868, 8, 46, 1, 46, 1, 46, 3, 46, 1872, 8, 46, 1, 46, 3, 46, 1875, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1882, 8, 47, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 5, 50, 1893, 8, 50, 10, 50, 12, 50, 1896, 9, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1908, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 5, 53, 1920, 8, 53, 10, 53, 12, 53, 1923, 9, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 1939, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 1947, 8, 54, 10, 54, 12, 54, 1950, 9, 54, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1956, 8, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1961, 8, 55, 1, 55, 1, 55, 3, 55, 1965, 8, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1972, 8, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1977, 8, 55, 1, 55, 3, 55, 1980, 8, 55, 3, 55, 1982, 8, 55, 1, 56, 1, 56, 1, 56, 3, 56, 1987, 8, 56, 1, 57, 1, 57, 3, 57, 1991, 8, 57, 1, 57, 1, 57, 3, 57, 1995, 8, 57, 1, 57, 1, 57, 3, 57, 1999, 8, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2004, 8, 57, 1, 57, 3, 57, 2007, 8, 57, 1, 57, 1, 57, 3, 57, 2011, 8, 57, 1, 57, 3, 57, 2014, 8, 57, 1, 57, 1, 57, 3, 57, 2018, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2026, 8, 57, 1, 57, 1, 57, 1, 57, 3, 57, 2031, 8, 57, 1, 57, 3, 57, 2034, 8, 57, 1, 57, 1, 57, 3, 57, 2038, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 2044, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 2053, 8, 58, 1, 58, 1, 58, 3, 58, 2057, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 5, 58, 2063, 8, 58, 10, 58, 12, 58, 2066, 9, 58, 1, 58, 1, 58, 1, 58, 1, 58, 5, 58, 2072, 8, 58, 10, 58, 12, 58, 2075, 9, 58, 1, 58, 1, 58, 3, 58, 2079, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 2089, 8, 59, 10, 59, 12, 59, 2092, 9, 59, 1, 59, 1, 59, 3, 59, 2096, 8, 59, 1, 60, 1, 60, 3, 60, 2100, 8, 60, 1, 60, 1, 60, 3, 60, 2104, 8, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2109, 8, 60, 1, 60, 1, 60, 3, 60, 2113, 8, 60, 1, 60, 3, 60, 2116, 8, 60, 1, 60, 3, 60, 2119, 8, 60, 1, 60, 3, 60, 2122, 8, 60, 1, 60, 3, 60, 2125, 8, 60, 1, 60, 3, 60, 2128, 8, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2133, 8, 60, 1, 60, 3, 60, 2136, 8, 60, 1, 60, 3, 60, 2139, 8, 60, 1, 60, 3, 60, 2142, 8, 60, 1, 60, 3, 60, 2145, 8, 60, 1, 60, 3, 60, 2148, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 2154, 8, 60, 1, 60, 1, 60, 3, 60, 2158, 8, 60, 1, 60, 3, 60, 2161, 8, 60, 1, 60, 3, 60, 2164, 8, 60, 1, 60, 3, 60, 2167, 8, 60, 1, 60, 3, 60, 2170, 8, 60, 3, 60, 2172, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 2179, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 5, 62, 2185, 8, 62, 10, 62, 12, 62, 2188, 9, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 5, 63, 2195, 8, 63, 10, 63, 12, 63, 2198, 9, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 5, 64, 2205, 8, 64, 10, 64, 12, 64, 2208, 9, 64, 1, 64, 1, 64, 3, 64, 2212, 8, 64, 1, 64, 3, 64, 2215, 8, 64, 1, 65, 1, 65, 1, 65, 3, 65, 2220, 8, 65, 1, 65, 5, 65, 2223, 8, 65, 10, 65, 12, 65, 2226, 9, 65, 1, 65, 1, 65, 3, 65, 2230, 8, 65, 1, 65, 3, 65, 2233, 8, 65, 1, 66, 1, 66, 1, 66, 3, 66, 2238, 8, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 2247, 8, 66, 3, 66, 2249, 8, 66, 1, 66, 1, 66, 3, 66, 2253, 8, 66, 1, 66, 3, 66, 2256, 8, 66, 1, 66, 1, 66, 3, 66, 2260, 8, 66, 1, 66, 5, 66, 2263, 8, 66, 10, 66, 12, 66, 2266, 9, 66, 1, 67, 1, 67, 3, 67, 2270, 8, 67, 1, 67, 1, 67, 3, 67, 2274, 8, 67, 1, 67, 3, 67, 2277, 8, 67, 1, 67, 1, 67, 3, 67, 2281, 8, 67, 1, 68, 3, 68, 2284, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2289, 8, 68, 1, 68, 3, 68, 2292, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2297, 8, 68, 1, 68, 3, 68, 2300, 8, 68, 1, 68, 1, 68, 3, 68, 2304, 8, 68, 1, 68, 3, 68, 2307, 8, 68, 1, 68, 3, 68, 2310, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2315, 8, 68, 1, 68, 3, 68, 2318, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2326, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 4, 68, 2336, 8, 68, 11, 68, 12, 68, 2337, 1, 68, 1, 68, 3, 68, 2342, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2349, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 2354, 8, 68, 1, 68, 3, 68, 2357, 8, 68, 1, 68, 3, 68, 2360, 8, 68, 1, 68, 3, 68, 2363, 8, 68, 1, 69, 1, 69, 1, 69, 3, 69, 2368, 8, 69, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 5, 71, 2377, 8, 71, 10, 71, 12, 71, 2380, 9, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2385, 8, 71, 1, 71, 1, 71, 3, 71, 2389, 8, 71, 1, 71, 3, 71, 2392, 8, 71, 1, 71, 3, 71, 2395, 8, 71, 1, 71, 5, 71, 2398, 8, 71, 10, 71, 12, 71, 2401, 9, 71, 1, 71, 1, 71, 5, 71, 2405, 8, 71, 10, 71, 12, 71, 2408, 9, 71, 3, 71, 2410, 8, 71, 1, 71, 1, 71, 3, 71, 2414, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 5, 71, 2420, 8, 71, 10, 71, 12, 71, 2423, 9, 71, 1, 71, 1, 71, 3, 71, 2427, 8, 71, 1, 71, 3, 71, 2430, 8, 71, 1, 71, 3, 71, 2433, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2440, 8, 71, 1, 71, 5, 71, 2443, 8, 71, 10, 71, 12, 71, 2446, 9, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 2454, 8, 71, 1, 71, 3, 71, 2457, 8, 71, 1, 71, 3, 71, 2460, 8, 71, 1, 71, 5, 71, 2463, 8, 71, 10, 71, 12, 71, 2466, 9, 71, 3, 71, 2468, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 5, 73, 2478, 8, 73, 10, 73, 12, 73, 2481, 9, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 5, 74, 2488, 8, 74, 10, 74, 12, 74, 2491, 9, 74, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2507, 8, 77, 1, 78, 1, 78, 3, 78, 2511, 8, 78, 1, 78, 1, 78, 3, 78, 2515, 8, 78, 3, 78, 2517, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2534, 8, 81, 3, 81, 2536, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 5, 83, 2550, 8, 83, 10, 83, 12, 83, 2553, 9, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 3, 84, 2563, 8, 84, 1, 84, 3, 84, 2566, 8, 84, 1, 84, 3, 84, 2569, 8, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 2578, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2587, 8, 87, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 3, 91, 2603, 8, 91, 1, 91, 3, 91, 2606, 8, 91, 1, 91, 3, 91, 2609, 8, 91, 1, 91, 1, 91, 1, 91, 1, 91, 5, 91, 2615, 8, 91, 10, 91, 12, 91, 2618, 9, 91, 1, 91, 3, 91, 2621, 8, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 3, 92, 2628, 8, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 3, 93, 2637, 8, 93, 1, 93, 1, 93, 3, 93, 2641, 8, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 2647, 8, 93, 1, 94, 1, 94, 3, 94, 2651, 8, 94, 1, 94, 3, 94, 2654, 8, 94, 1, 94, 3, 94, 2657, 8, 94, 1, 94, 3, 94, 2660, 8, 94, 1, 94, 3, 94, 2663, 8, 94, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 2669, 8, 95, 1, 96, 1, 96, 3, 96, 2673, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2678, 8, 96, 1, 96, 1, 96, 3, 96, 2682, 8, 96, 1, 96, 3, 96, 2685, 8, 96, 1, 96, 3, 96, 2688, 8, 96, 1, 96, 3, 96, 2691, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 2696, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 2702, 8, 97, 1, 97, 1, 97, 3, 97, 2706, 8, 97, 1, 98, 1, 98, 3, 98, 2710, 8, 98, 1, 98, 1, 98, 3, 98, 2714, 8, 98, 1, 98, 1, 98, 4, 98, 2718, 8, 98, 11, 98, 12, 98, 2719, 3, 98, 2722, 8, 98, 1, 99, 1, 99, 1, 99, 3, 99, 2727, 8, 99, 1, 99, 1, 99, 4, 99, 2731, 8, 99, 11, 99, 12, 99, 2732, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2739, 8, 100, 1, 100, 1, 100, 3, 100, 2743, 8, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2758, 8, 100, 1, 100, 1, 100, 1, 100, 3, 100, 2763, 8, 100, 1, 100, 3, 100, 2766, 8, 100, 3, 100, 2768, 8, 100, 1, 101, 3, 101, 2771, 8, 101, 1, 101, 1, 101, 3, 101, 2775, 8, 101, 1, 102, 1, 102, 3, 102, 2779, 8, 102, 1, 102, 3, 102, 2782, 8, 102, 1, 102, 3, 102, 2785, 8, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2793, 8, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 2799, 8, 102, 3, 102, 2801, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2807, 8, 103, 1, 103, 1, 103, 1, 103, 3, 103, 2812, 8, 103, 1, 104, 1, 104, 1, 104, 3, 104, 2817, 8, 104, 1, 104, 1, 104, 3, 104, 2821, 8, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 5, 104, 2828, 8, 104, 10, 104, 12, 104, 2831, 9, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 2839, 8, 105, 10, 105, 12, 105, 2842, 9, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 2880, 8, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 4, 107, 2888, 8, 107, 11, 107, 12, 107, 2889, 3, 107, 2892, 8, 107, 1, 107, 3, 107, 2895, 8, 107, 1, 108, 1, 108, 3, 108, 2899, 8, 108, 1, 108, 1, 108, 3, 108, 2903, 8, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 4, 109, 2911, 8, 109, 11, 109, 12, 109, 2912, 3, 109, 2915, 8, 109, 1, 109, 1, 109, 4, 109, 2919, 8, 109, 11, 109, 12, 109, 2920, 3, 109, 2923, 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 2930, 8, 110, 10, 110, 12, 110, 2933, 9, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 2942, 8, 111, 10, 111, 12, 111, 2945, 9, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 3, 114, 2958, 8, 114, 1, 114, 1, 114, 1, 114, 3, 114, 2963, 8, 114, 1, 114, 3, 114, 2966, 8, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 2973, 8, 114, 1, 115, 1, 115, 1, 115, 3, 115, 2978, 8, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 2986, 8, 116, 3, 116, 2988, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 2994, 8, 117, 1, 117, 1, 117, 1, 117, 3, 117, 2999, 8, 117, 1, 117, 1, 117, 3, 117, 3003, 8, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3008, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3014, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3021, 8, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 3027, 8, 117, 3, 117, 3029, 8, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3038, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3044, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 3052, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3058, 8, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3063, 8, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3068, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 3076, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 3091, 8, 121, 3, 121, 3093, 8, 121, 1, 121, 1, 121, 3, 121, 3097, 8, 121, 1, 121, 1, 121, 3, 121, 3101, 8, 121, 1, 121, 3, 121, 3104, 8, 121, 1, 121, 3, 121, 3107, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 3116, 8, 122, 1, 122, 3, 122, 3119, 8, 122, 1, 122, 3, 122, 3122, 8, 122, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 3128, 8, 123, 1, 123, 1, 123, 5, 123, 3132, 8, 123, 10, 123, 12, 123, 3135, 9, 123, 1, 123, 3, 123, 3138, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 3150, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 3156, 8, 123, 1, 124, 3, 124, 3159, 8, 124, 1, 124, 1, 124, 1, 124, 3, 124, 3164, 8, 124, 1, 124, 1, 124, 3, 124, 3168, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 3175, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 3185, 8, 124, 3, 124, 3187, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 3, 128, 3211, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3223, 8, 128, 1, 128, 4, 128, 3226, 8, 128, 11, 128, 12, 128, 3227, 3, 128, 3230, 8, 128, 1, 128, 1, 128, 3, 128, 3234, 8, 128, 1, 128, 3, 128, 3237, 8, 128, 1, 128, 3, 128, 3240, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3250, 8, 128, 1, 128, 3, 128, 3253, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3263, 8, 128, 1, 128, 5, 128, 3266, 8, 128, 10, 128, 12, 128, 3269, 9, 128, 1, 128, 1, 128, 3, 128, 3273, 8, 128, 1, 128, 3, 128, 3276, 8, 128, 1, 128, 3, 128, 3279, 8, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 3287, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 3293, 8, 129, 1, 130, 1, 130, 1, 130, 5, 130, 3298, 8, 130, 10, 130, 12, 130, 3301, 9, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 3308, 8, 131, 1, 131, 3, 131, 3311, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 3322, 8, 133, 1, 134, 1, 134, 3, 134, 3326, 8, 134, 1, 134, 1, 134, 5, 134, 3330, 8, 134, 10, 134, 12, 134, 3333, 9, 134, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 3339, 8, 135, 1, 136, 3, 136, 3342, 8, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 3351, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 5, 137, 3363, 8, 137, 10, 137, 12, 137, 3366, 9, 137, 3, 137, 3368, 8, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 5, 138, 3380, 8, 138, 10, 138, 12, 138, 3383, 9, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 3393, 8, 139, 1, 139, 3, 139, 3396, 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 5, 140, 3406, 8, 140, 10, 140, 12, 140, 3409, 9, 140, 1, 141, 1, 141, 3, 141, 3413, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 5, 141, 3424, 8, 141, 10, 141, 12, 141, 3427, 9, 141, 1, 141, 1, 141, 3, 141, 3431, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3444, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 5, 141, 3451, 8, 141, 10, 141, 12, 141, 3454, 9, 141, 3, 141, 3456, 8, 141, 1, 141, 3, 141, 3459, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3466, 8, 141, 1, 141, 3, 141, 3469, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3481, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 3487, 8, 141, 3, 141, 3489, 8, 141, 1, 142, 1, 142, 1, 142, 1, 142, 5, 142, 3495, 8, 142, 10, 142, 12, 142, 3498, 9, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 3, 143, 3505, 8, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 3513, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3525, 8, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3530, 8, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 3541, 8, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3552, 8, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 3560, 8, 148, 1, 148, 1, 148, 1, 148, 1, 148, 5, 148, 3566, 8, 148, 10, 148, 12, 148, 3569, 9, 148, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3575, 8, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3582, 8, 149, 3, 149, 3584, 8, 149, 1, 149, 3, 149, 3587, 8, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3592, 8, 149, 1, 149, 1, 149, 1, 149, 3, 149, 3597, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 3614, 8, 151, 10, 151, 12, 151, 3617, 9, 151, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 3623, 8, 151, 10, 151, 12, 151, 3626, 9, 151, 3, 151, 3628, 8, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3655, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3664, 8, 154, 1, 154, 3, 154, 3667, 8, 154, 1, 154, 1, 154, 3, 154, 3671, 8, 154, 1, 154, 1, 154, 3, 154, 3675, 8, 154, 1, 154, 1, 154, 3, 154, 3679, 8, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3684, 8, 154, 10, 154, 12, 154, 3687, 9, 154, 1, 154, 3, 154, 3690, 8, 154, 1, 154, 1, 154, 3, 154, 3694, 8, 154, 1, 154, 1, 154, 3, 154, 3698, 8, 154, 1, 154, 1, 154, 3, 154, 3702, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3707, 8, 154, 1, 154, 1, 154, 3, 154, 3711, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3716, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3722, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3727, 8, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3732, 8, 154, 10, 154, 12, 154, 3735, 9, 154, 1, 154, 3, 154, 3738, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3744, 8, 154, 1, 154, 1, 154, 3, 154, 3748, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3753, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3761, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3767, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3772, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3779, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3784, 8, 154, 1, 154, 1, 154, 3, 154, 3788, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3793, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3799, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3806, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3811, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3818, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3823, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 3830, 8, 154, 1, 154, 1, 154, 3, 154, 3834, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 3840, 8, 154, 10, 154, 12, 154, 3843, 9, 154, 1, 154, 3, 154, 3846, 8, 154, 3, 154, 3848, 8, 154, 1, 155, 3, 155, 3851, 8, 155, 1, 155, 1, 155, 1, 155, 3, 155, 3856, 8, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 3, 155, 3866, 8, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 3881, 8, 156, 1, 156, 3, 156, 3884, 8, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 3892, 8, 156, 1, 157, 1, 157, 1, 157, 5, 157, 3897, 8, 157, 10, 157, 12, 157, 3900, 9, 157, 1, 158, 1, 158, 3, 158, 3904, 8, 158, 1, 159, 1, 159, 4, 159, 3908, 8, 159, 11, 159, 12, 159, 3909, 1, 160, 1, 160, 3, 160, 3914, 8, 160, 1, 160, 1, 160, 1, 160, 5, 160, 3919, 8, 160, 10, 160, 12, 160, 3922, 9, 160, 1, 160, 1, 160, 3, 160, 3926, 8, 160, 1, 160, 3, 160, 3929, 8, 160, 1, 161, 3, 161, 3932, 8, 161, 1, 161, 1, 161, 3, 161, 3936, 8, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 3945, 8, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 3963, 8, 162, 1, 162, 3, 162, 3966, 8, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 3998, 8, 162, 1, 162, 1, 162, 1, 162, 3, 162, 4003, 8, 162, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 4009, 8, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, 163, 4029, 8, 163, 1, 163, 1, 163, 1, 163, 3, 163, 4034, 8, 163, 1, 164, 1, 164, 1, 164, 1, 165, 3, 165, 4040, 8, 165, 1, 165, 3, 165, 4043, 8, 165, 1, 165, 1, 165, 3, 165, 4047, 8, 165, 1, 165, 1, 165, 3, 165, 4051, 8, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4057, 8, 165, 1, 165, 3, 165, 4060, 8, 165, 1, 165, 1, 165, 3, 165, 4064, 8, 165, 1, 165, 1, 165, 3, 165, 4068, 8, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4073, 8, 165, 1, 165, 3, 165, 4076, 8, 165, 1, 165, 3, 165, 4079, 8, 165, 1, 165, 3, 165, 4082, 8, 165, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 4095, 8, 167, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 4101, 8, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 4109, 8, 168, 1, 169, 1, 169, 1, 169, 5, 169, 4114, 8, 169, 10, 169, 12, 169, 4117, 9, 169, 1, 169, 1, 169, 3, 169, 4121, 8, 169, 1, 169, 3, 169, 4124, 8, 169, 1, 169, 1, 169, 1, 169, 5, 169, 4129, 8, 169, 10, 169, 12, 169, 4132, 9, 169, 3, 169, 4134, 8, 169, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 4142, 8, 171, 1, 171, 3, 171, 4145, 8, 171, 1, 172, 1, 172, 1, 172, 3, 172, 4150, 8, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 4157, 8, 172, 1, 172, 3, 172, 4160, 8, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 5, 172, 4178, 8, 172, 10, 172, 12, 172, 4181, 9, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 4192, 8, 172, 1, 173, 3, 173, 4195, 8, 173, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 4201, 8, 173, 1, 173, 5, 173, 4204, 8, 173, 10, 173, 12, 173, 4207, 9, 173, 1, 174, 1, 174, 1, 174, 1, 174, 5, 174, 4213, 8, 174, 10, 174, 12, 174, 4216, 9, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 4223, 8, 174, 1, 174, 1, 174, 1, 174, 3, 174, 4228, 8, 174, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 4234, 8, 175, 1, 175, 1, 175, 1, 175, 5, 175, 4239, 8, 175, 10, 175, 12, 175, 4242, 9, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 4249, 8, 175, 1, 175, 3, 175, 4252, 8, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 5, 176, 4263, 8, 176, 10, 176, 12, 176, 4266, 9, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 4279, 8, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 4285, 8, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 4293, 8, 177, 3, 177, 4295, 8, 177, 1, 178, 1, 178, 1, 179, 1, 179, 3, 179, 4301, 8, 179, 1, 179, 1, 179, 3, 179, 4305, 8, 179, 1, 179, 3, 179, 4308, 8, 179, 1, 179, 3, 179, 4311, 8, 179, 1, 179, 1, 179, 1, 179, 3, 179, 4316, 8, 179, 1, 179, 1, 179, 1, 179, 3, 179, 4321, 8, 179, 1, 179, 1, 179, 3, 179, 4325, 8, 179, 1, 179, 3, 179, 4328, 8, 179, 1, 179, 3, 179, 4331, 8, 179, 1, 179, 3, 179, 4334, 8, 179, 1, 179, 3, 179, 4337, 8, 179, 1, 180, 1, 180, 1, 180, 1, 180, 5, 180, 4343, 8, 180, 10, 180, 12, 180, 4346, 9, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 4356, 8, 181, 1, 181, 3, 181, 4359, 8, 181, 1, 181, 3, 181, 4362, 8, 181, 1, 181, 1, 181, 1, 181, 3, 181, 4367, 8, 181, 1, 181, 3, 181, 4370, 8, 181, 1, 181, 1, 181, 3, 181, 4374, 8, 181, 1, 182, 1, 182, 3, 182, 4378, 8, 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 4384, 8, 182, 1, 182, 1, 182, 1, 182, 1, 182, 5, 182, 4390, 8, 182, 10, 182, 12, 182, 4393, 9, 182, 3, 182, 4395, 8, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 5, 182, 4406, 8, 182, 10, 182, 12, 182, 4409, 9, 182, 1, 182, 1, 182, 3, 182, 4413, 8, 182, 3, 182, 4415, 8, 182, 1, 182, 4, 182, 4418, 8, 182, 11, 182, 12, 182, 4419, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 4427, 8, 182, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 3, 184, 4434, 8, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 5, 185, 4441, 8, 185, 10, 185, 12, 185, 4444, 9, 185, 1, 186, 1, 186, 1, 186, 5, 186, 4449, 8, 186, 10, 186, 12, 186, 4452, 9, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 4459, 8, 187, 1, 188, 1, 188, 1, 188, 5, 188, 4464, 8, 188, 10, 188, 12, 188, 4467, 9, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 4474, 8, 189, 1, 190, 1, 190, 1, 190, 5, 190, 4479, 8, 190, 10, 190, 12, 190, 4482, 9, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 3, 191, 4489, 8, 191, 1, 192, 1, 192, 3, 192, 4493, 8, 192, 1, 192, 1, 192, 3, 192, 4497, 8, 192, 3, 192, 4499, 8, 192, 1, 192, 1, 192, 1, 193, 1, 193, 3, 193, 4505, 8, 193, 1, 193, 1, 193, 1, 193, 3, 193, 4510, 8, 193, 1, 194, 1, 194, 3, 194, 4514, 8, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 3, 194, 4521, 8, 194, 1, 195, 1, 195, 1, 195, 3, 195, 4526, 8, 195, 1, 196, 1, 196, 1, 196, 3, 196, 4531, 8, 196, 1, 196, 1, 196, 1, 196, 3, 196, 4536, 8, 196, 3, 196, 4538, 8, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 3, 198, 4548, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 4558, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 4574, 8, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 5, 199, 4590, 8, 199, 10, 199, 12, 199, 4593, 9, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 4604, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 4611, 8, 199, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 4626, 8, 202, 1, 202, 4, 202, 4629, 8, 202, 11, 202, 12, 202, 4630, 1, 202, 3, 202, 4634, 8, 202, 1, 203, 1, 203, 1, 203, 3, 203, 4639, 8, 203, 1, 203, 1, 203, 1, 203, 3, 203, 4644, 8, 203, 1, 203, 1, 203, 1, 203, 3, 203, 4649, 8, 203, 1, 203, 3, 203, 4652, 8, 203, 1, 203, 3, 203, 4655, 8, 203, 1, 204, 1, 204, 1, 204, 3, 204, 4660, 8, 204, 1, 204, 1, 204, 1, 204, 5, 204, 4665, 8, 204, 10, 204, 12, 204, 4668, 9, 204, 1, 204, 3, 204, 4671, 8, 204, 1, 205, 1, 205, 1, 205, 3, 205, 4676, 8, 205, 1, 205, 1, 205, 1, 205, 5, 205, 4681, 8, 205, 10, 205, 12, 205, 4684, 9, 205, 1, 205, 3, 205, 4687, 8, 205, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 4693, 8, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 4702, 8, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 5, 207, 4709, 8, 207, 10, 207, 12, 207, 4712, 9, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 4, 209, 4723, 8, 209, 11, 209, 12, 209, 4724, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 3, 210, 4738, 8, 210, 1, 210, 1, 210, 1, 210, 1, 210, 3, 210, 4744, 8, 210, 1, 210, 1, 210, 3, 210, 4748, 8, 210, 3, 210, 4750, 8, 210, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 3, 212, 4757, 8, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 4770, 8, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 4777, 8, 212, 3, 212, 4779, 8, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 5, 214, 4793, 8, 214, 10, 214, 12, 214, 4796, 9, 214, 1, 214, 3, 214, 4799, 8, 214, 1, 214, 1, 214, 3, 214, 4803, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4808, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4813, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4818, 8, 214, 1, 214, 1, 214, 1, 214, 3, 214, 4823, 8, 214, 1, 214, 3, 214, 4826, 8, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4838, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4891, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4900, 8, 216, 1, 216, 1, 216, 3, 216, 4904, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4913, 8, 216, 1, 216, 1, 216, 3, 216, 4917, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4926, 8, 216, 1, 216, 1, 216, 3, 216, 4930, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4935, 8, 216, 1, 216, 3, 216, 4938, 8, 216, 1, 216, 1, 216, 3, 216, 4942, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4947, 8, 216, 3, 216, 4949, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4958, 8, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4963, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4974, 8, 216, 1, 216, 1, 216, 3, 216, 4978, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 4992, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5000, 8, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 5038, 8, 216, 3, 216, 5040, 8, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 3, 217, 5059, 8, 217, 1, 217, 3, 217, 5062, 8, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 5089, 8, 218, 1, 218, 1, 218, 3, 218, 5093, 8, 218, 1, 218, 1, 218, 3, 218, 5097, 8, 218, 1, 218, 1, 218, 3, 218, 5101, 8, 218, 1, 218, 1, 218, 3, 218, 5105, 8, 218, 1, 218, 3, 218, 5108, 8, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 5123, 8, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 3, 218, 5130, 8, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 5, 220, 5142, 8, 220, 10, 220, 12, 220, 5145, 9, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 3, 221, 5157, 8, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5182, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5201, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5216, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5232, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5239, 8, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 5250, 8, 224, 1, 224, 3, 224, 5253, 8, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 5, 225, 5270, 8, 225, 10, 225, 12, 225, 5273, 9, 225, 3, 225, 5275, 8, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 5, 226, 5286, 8, 226, 10, 226, 12, 226, 5289, 9, 226, 1, 226, 3, 226, 5292, 8, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 3, 227, 5312, 8, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 5, 227, 5322, 8, 227, 10, 227, 12, 227, 5325, 9, 227, 1, 227, 3, 227, 5328, 8, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 3, 227, 5350, 8, 227, 1, 228, 1, 228, 3, 228, 5354, 8, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 3, 228, 5364, 8, 228, 1, 228, 1, 228, 3, 228, 5368, 8, 228, 1, 228, 1, 228, 1, 228, 1, 228, 3, 228, 5374, 8, 228, 1, 228, 1, 228, 3, 228, 5378, 8, 228, 5, 228, 5380, 8, 228, 10, 228, 12, 228, 5383, 9, 228, 1, 228, 3, 228, 5386, 8, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 5393, 8, 229, 1, 230, 1, 230, 1, 230, 3, 230, 5398, 8, 230, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 3, 233, 5409, 8, 233, 1, 234, 1, 234, 3, 234, 5413, 8, 234, 1, 234, 3, 234, 5416, 8, 234, 1, 234, 1, 234, 1, 234, 3, 234, 5421, 8, 234, 1, 234, 1, 234, 1, 234, 1, 234, 3, 234, 5427, 8, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 3, 234, 5438, 8, 234, 1, 234, 1, 234, 3, 234, 5442, 8, 234, 1, 234, 3, 234, 5445, 8, 234, 1, 234, 1, 234, 3, 234, 5449, 8, 234, 1, 234, 1, 234, 3, 234, 5453, 8, 234, 1, 234, 3, 234, 5456, 8, 234, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 3, 236, 5466, 8, 236, 1, 236, 3, 236, 5469, 8, 236, 1, 237, 1, 237, 3, 237, 5473, 8, 237, 1, 237, 5, 237, 5476, 8, 237, 10, 237, 12, 237, 5479, 9, 237, 1, 238, 1, 238, 1, 238, 3, 238, 5484, 8, 238, 1, 238, 3, 238, 5487, 8, 238, 1, 238, 1, 238, 1, 238, 3, 238, 5492, 8, 238, 1, 238, 3, 238, 5495, 8, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 3, 238, 5502, 8, 238, 3, 238, 5504, 8, 238, 1, 238, 1, 238, 1, 238, 1, 238, 3, 238, 5510, 8, 238, 1, 238, 1, 238, 3, 238, 5514, 8, 238, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 3, 240, 5523, 8, 240, 1, 240, 4, 240, 5526, 8, 240, 11, 240, 12, 240, 5527, 3, 240, 5530, 8, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 3, 241, 5540, 8, 241, 1, 241, 3, 241, 5543, 8, 241, 1, 241, 1, 241, 1, 241, 3, 241, 5548, 8, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 3, 242, 5556, 8, 242, 1, 242, 3, 242, 5559, 8, 242, 1, 242, 4, 242, 5562, 8, 242, 11, 242, 12, 242, 5563, 3, 242, 5566, 8, 242, 3, 242, 5568, 8, 242, 1, 243, 1, 243, 1, 243, 1, 243, 3, 243, 5574, 8, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 3, 246, 5591, 8, 246, 1, 246, 1, 246, 5, 246, 5595, 8, 246, 10, 246, 12, 246, 5598, 9, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 5610, 8, 247, 1, 247, 1, 247, 1, 247, 1, 247, 3, 247, 5616, 8, 247, 1, 247, 1, 247, 3, 247, 5620, 8, 247, 1, 247, 1, 247, 1, 247, 3, 247, 5625, 8, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 3, 249, 5655, 8, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 3, 249, 5670, 8, 249, 1, 249, 1, 249, 1, 249, 3, 249, 5675, 8, 249, 1, 250, 1, 250, 3, 250, 5679, 8, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 3, 251, 5692, 8, 251, 1, 251, 1, 251, 3, 251, 5696, 8, 251, 3, 251, 5698, 8, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 5, 251, 5705, 8, 251, 10, 251, 12, 251, 5708, 9, 251, 1, 251, 1, 251, 1, 251, 3, 251, 5713, 8, 251, 3, 251, 5715, 8, 251, 1, 252, 1, 252, 3, 252, 5719, 8, 252, 1, 252, 3, 252, 5722, 8, 252, 1, 252, 3, 252, 5725, 8, 252, 1, 252, 3, 252, 5728, 8, 252, 1, 252, 3, 252, 5731, 8, 252, 3, 252, 5733, 8, 252, 1, 252, 3, 252, 5736, 8, 252, 1, 253, 1, 253, 3, 253, 5740, 8, 253, 1, 253, 1, 253, 1, 253, 1, 253, 5, 253, 5746, 8, 253, 10, 253, 12, 253, 5749, 9, 253, 1, 253, 1, 253, 3, 253, 5753, 8, 253, 1, 253, 3, 253, 5756, 8, 253, 1, 254, 1, 254, 1, 255, 1, 255, 3, 255, 5762, 8, 255, 1, 255, 1, 255, 3, 255, 5766, 8, 255, 1, 256, 1, 256, 3, 256, 5770, 8, 256, 1, 256, 1, 256, 1, 256, 3, 256, 5775, 8, 256, 3, 256, 5777, 8, 256, 1, 257, 1, 257, 3, 257, 5781, 8, 257, 1, 258, 1, 258, 3, 258, 5785, 8, 258, 1, 259, 1, 259, 1, 259, 5, 259, 5790, 8, 259, 10, 259, 12, 259, 5793, 9, 259, 1, 260, 1, 260, 1, 260, 3, 260, 5798, 8, 260, 1, 260, 1, 260, 3, 260, 5802, 8, 260, 3, 260, 5804, 8, 260, 3, 260, 5806, 8, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 3, 261, 5819, 8, 261, 1, 262, 1, 262, 1, 262, 1, 262, 5, 262, 5825, 8, 262, 10, 262, 12, 262, 5828, 9, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 3, 263, 5835, 8, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 5, 264, 5844, 8, 264, 10, 264, 12, 264, 5847, 9, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 3, 265, 5855, 8, 265, 1, 266, 1, 266, 1, 266, 3, 266, 5860, 8, 266, 1, 266, 1, 266, 3, 266, 5864, 8, 266, 1, 266, 1, 266, 3, 266, 5868, 8, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 3, 266, 5875, 8, 266, 1, 266, 3, 266, 5878, 8, 266, 3, 266, 5880, 8, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 3, 268, 5888, 8, 268, 1, 268, 1, 268, 3, 268, 5892, 8, 268, 1, 269, 3, 269, 5895, 8, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5902, 8, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5909, 8, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5914, 8, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 5921, 8, 269, 1, 269, 3, 269, 5924, 8, 269, 3, 269, 5926, 8, 269, 1, 269, 3, 269, 5929, 8, 269, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 5935, 8, 270, 1, 270, 1, 270, 1, 270, 3, 270, 5940, 8, 270, 1, 270, 1, 270, 3, 270, 5944, 8, 270, 1, 271, 1, 271, 1, 271, 5, 271, 5949, 8, 271, 10, 271, 12, 271, 5952, 9, 271, 1, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 274, 3, 274, 5961, 8, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 5968, 8, 274, 1, 274, 3, 274, 5971, 8, 274, 1, 274, 3, 274, 5974, 8, 274, 1, 275, 1, 275, 3, 275, 5978, 8, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 3, 275, 5989, 8, 275, 1, 275, 3, 275, 5992, 8, 275, 1, 275, 3, 275, 5995, 8, 275, 1, 275, 3, 275, 5998, 8, 275, 1, 276, 3, 276, 6001, 8, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 3, 276, 6008, 8, 276, 1, 276, 3, 276, 6011, 8, 276, 1, 276, 3, 276, 6014, 8, 276, 1, 277, 1, 277, 1, 277, 5, 277, 6019, 8, 277, 10, 277, 12, 277, 6022, 9, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 3, 278, 6033, 8, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 3, 278, 6040, 8, 278, 3, 278, 6042, 8, 278, 1, 279, 1, 279, 1, 279, 3, 279, 6047, 8, 279, 1, 279, 1, 279, 1, 279, 5, 279, 6052, 8, 279, 10, 279, 12, 279, 6055, 9, 279, 1, 279, 1, 279, 1, 279, 3, 279, 6060, 8, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 3, 280, 6067, 8, 280, 1, 281, 1, 281, 1, 281, 3, 281, 6072, 8, 281, 1, 281, 1, 281, 1, 282, 3, 282, 6077, 8, 282, 1, 282, 1, 282, 3, 282, 6081, 8, 282, 1, 282, 1, 282, 3, 282, 6085, 8, 282, 1, 282, 1, 282, 3, 282, 6089, 8, 282, 3, 282, 6091, 8, 282, 1, 283, 1, 283, 3, 283, 6095, 8, 283, 1, 284, 1, 284, 3, 284, 6099, 8, 284, 1, 284, 3, 284, 6102, 8, 284, 1, 284, 3, 284, 6105, 8, 284, 3, 284, 6107, 8, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 3, 284, 6117, 8, 284, 3, 284, 6119, 8, 284, 1, 284, 1, 284, 1, 284, 3, 284, 6124, 8, 284, 5, 284, 6126, 8, 284, 10, 284, 12, 284, 6129, 9, 284, 1, 285, 1, 285, 3, 285, 6133, 8, 285, 1, 286, 1, 286, 3, 286, 6137, 8, 286, 1, 286, 1, 286, 1, 286, 5, 286, 6142, 8, 286, 10, 286, 12, 286, 6145, 9, 286, 1, 287, 1, 287, 3, 287, 6149, 8, 287, 1, 287, 1, 287, 3, 287, 6153, 8, 287, 1, 287, 3, 287, 6156, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 6162, 8, 287, 1, 287, 3, 287, 6165, 8, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 3, 289, 6184, 8, 289, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 3, 290, 6191, 8, 290, 1, 290, 1, 290, 3, 290, 6195, 8, 290, 1, 291, 3, 291, 6198, 8, 291, 1, 291, 1, 291, 3, 291, 6202, 8, 291, 1, 291, 1, 291, 3, 291, 6206, 8, 291, 1, 291, 3, 291, 6209, 8, 291, 1, 291, 3, 291, 6212, 8, 291, 1, 292, 1, 292, 1, 292, 3, 292, 6217, 8, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 5, 293, 6224, 8, 293, 10, 293, 12, 293, 6227, 9, 293, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 6233, 8, 294, 1, 294, 1, 294, 3, 294, 6237, 8, 294, 1, 295, 1, 295, 3, 295, 6241, 8, 295, 1, 295, 1, 295, 3, 295, 6245, 8, 295, 1, 295, 3, 295, 6248, 8, 295, 3, 295, 6250, 8, 295, 1, 296, 1, 296, 1, 296, 3, 296, 6255, 8, 296, 1, 296, 1, 296, 3, 296, 6259, 8, 296, 1, 297, 1, 297, 1, 297, 3, 297, 6264, 8, 297, 1, 297, 1, 297, 1, 297, 1, 297, 3, 297, 6270, 8, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 6277, 8, 298, 1, 299, 1, 299, 1, 299, 3, 299, 6282, 8, 299, 1, 300, 1, 300, 1, 300, 3, 300, 6287, 8, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 5, 301, 6294, 8, 301, 10, 301, 12, 301, 6297, 9, 301, 1, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6303, 8, 302, 1, 302, 1, 302, 1, 302, 1, 302, 5, 302, 6309, 8, 302, 10, 302, 12, 302, 6312, 9, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 3, 302, 6322, 8, 302, 1, 303, 1, 303, 1, 303, 3, 303, 6327, 8, 303, 1, 303, 1, 303, 3, 303, 6331, 8, 303, 1, 303, 3, 303, 6334, 8, 303, 1, 303, 1, 303, 3, 303, 6338, 8, 303, 1, 303, 1, 303, 1, 303, 3, 303, 6343, 8, 303, 4, 303, 6345, 8, 303, 11, 303, 12, 303, 6346, 1, 303, 1, 303, 1, 303, 3, 303, 6352, 8, 303, 1, 304, 1, 304, 1, 304, 1, 304, 5, 304, 6358, 8, 304, 10, 304, 12, 304, 6361, 9, 304, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 5, 306, 6369, 8, 306, 10, 306, 12, 306, 6372, 9, 306, 1, 307, 1, 307, 3, 307, 6376, 8, 307, 1, 307, 1, 307, 3, 307, 6380, 8, 307, 1, 307, 3, 307, 6383, 8, 307, 1, 307, 3, 307, 6386, 8, 307, 3, 307, 6388, 8, 307, 1, 307, 3, 307, 6391, 8, 307, 1, 307, 3, 307, 6394, 8, 307, 1, 307, 3, 307, 6397, 8, 307, 1, 307, 1, 307, 3, 307, 6401, 8, 307, 1, 307, 1, 307, 3, 307, 6405, 8, 307, 1, 307, 1, 307, 3, 307, 6409, 8, 307, 3, 307, 6411, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6420, 8, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6425, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6431, 8, 307, 1, 307, 1, 307, 3, 307, 6435, 8, 307, 3, 307, 6437, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6444, 8, 307, 1, 307, 1, 307, 1, 307, 3, 307, 6449, 8, 307, 1, 307, 1, 307, 1, 307, 1, 307, 5, 307, 6455, 8, 307, 10, 307, 12, 307, 6458, 9, 307, 1, 308, 3, 308, 6461, 8, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 6468, 8, 308, 1, 309, 1, 309, 1, 309, 3, 309, 6473, 8, 309, 1, 309, 3, 309, 6476, 8, 309, 1, 309, 1, 309, 1, 309, 1, 309, 3, 309, 6482, 8, 309, 1, 310, 1, 310, 3, 310, 6486, 8, 310, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 6492, 8, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 3, 312, 6501, 8, 312, 1, 312, 1, 312, 1, 312, 1, 312, 3, 312, 6507, 8, 312, 3, 312, 6509, 8, 312, 1, 313, 1, 313, 1, 313, 3, 313, 6514, 8, 313, 1, 313, 3, 313, 6517, 8, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 3, 313, 6526, 8, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 3, 313, 6533, 8, 313, 3, 313, 6535, 8, 313, 1, 314, 1, 314, 1, 314, 5, 314, 6540, 8, 314, 10, 314, 12, 314, 6543, 9, 314, 1, 315, 1, 315, 3, 315, 6547, 8, 315, 1, 315, 3, 315, 6550, 8, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 3, 316, 6560, 8, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 5, 317, 6569, 8, 317, 10, 317, 12, 317, 6572, 9, 317, 1, 317, 1, 317, 3, 317, 6576, 8, 317, 1, 317, 1, 317, 3, 317, 6580, 8, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 3, 318, 6588, 8, 318, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 6598, 8, 320, 1, 321, 1, 321, 1, 321, 5, 321, 6603, 8, 321, 10, 321, 12, 321, 6606, 9, 321, 1, 322, 1, 322, 1, 322, 3, 322, 6611, 8, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 5, 323, 6620, 8, 323, 10, 323, 12, 323, 6623, 9, 323, 1, 323, 1, 323, 1, 323, 3, 323, 6628, 8, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 5, 323, 6636, 8, 323, 10, 323, 12, 323, 6639, 9, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 3, 324, 6647, 8, 324, 1, 324, 1, 324, 3, 324, 6651, 8, 324, 1, 324, 4, 324, 6654, 8, 324, 11, 324, 12, 324, 6655, 3, 324, 6658, 8, 324, 1, 324, 1, 324, 3, 324, 6662, 8, 324, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 6670, 8, 325, 1, 326, 3, 326, 6673, 8, 326, 1, 326, 1, 326, 1, 326, 3, 326, 6678, 8, 326, 1, 326, 5, 326, 6681, 8, 326, 10, 326, 12, 326, 6684, 9, 326, 1, 326, 1, 326, 1, 326, 1, 326, 3, 326, 6690, 8, 326, 3, 326, 6692, 8, 326, 1, 326, 1, 326, 1, 326, 1, 326, 3, 326, 6698, 8, 326, 1, 327, 1, 327, 3, 327, 6702, 8, 327, 1, 327, 3, 327, 6705, 8, 327, 1, 327, 1, 327, 1, 327, 3, 327, 6710, 8, 327, 1, 327, 3, 327, 6713, 8, 327, 3, 327, 6715, 8, 327, 1, 328, 1, 328, 1, 328, 1, 328, 3, 328, 6721, 8, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 6730, 8, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 6736, 8, 329, 1, 329, 3, 329, 6739, 8, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 3, 331, 6747, 8, 331, 1, 331, 3, 331, 6750, 8, 331, 1, 332, 1, 332, 3, 332, 6754, 8, 332, 1, 332, 1, 332, 1, 332, 1, 332, 3, 332, 6760, 8, 332, 3, 332, 6762, 8, 332, 1, 332, 3, 332, 6765, 8, 332, 1, 333, 1, 333, 3, 333, 6769, 8, 333, 1, 333, 1, 333, 1, 333, 3, 333, 6774, 8, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6781, 8, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6788, 8, 334, 3, 334, 6790, 8, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6796, 8, 334, 3, 334, 6798, 8, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6803, 8, 334, 3, 334, 6805, 8, 334, 1, 335, 1, 335, 3, 335, 6809, 8, 335, 1, 336, 1, 336, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 3, 338, 6818, 8, 338, 1, 338, 1, 338, 3, 338, 6822, 8, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 5, 338, 6830, 8, 338, 10, 338, 12, 338, 6833, 9, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6846, 8, 339, 1, 339, 3, 339, 6849, 8, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6857, 8, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 5, 339, 6864, 8, 339, 10, 339, 12, 339, 6867, 9, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6872, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6877, 8, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6885, 8, 339, 3, 339, 6887, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6892, 8, 339, 1, 339, 1, 339, 3, 339, 6896, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6901, 8, 339, 1, 339, 1, 339, 1, 339, 3, 339, 6906, 8, 339, 1, 340, 1, 340, 1, 340, 1, 340, 3, 340, 6912, 8, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 5, 340, 6928, 8, 340, 10, 340, 12, 340, 6931, 9, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6939, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6954, 8, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6959, 8, 341, 1, 341, 3, 341, 6962, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6968, 8, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6973, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6986, 8, 341, 1, 341, 4, 341, 6989, 8, 341, 11, 341, 12, 341, 6990, 1, 341, 1, 341, 3, 341, 6995, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7002, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7021, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7033, 8, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7038, 8, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 7046, 8, 341, 5, 341, 7048, 8, 341, 10, 341, 12, 341, 7051, 9, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 3, 342, 7059, 8, 342, 1, 342, 3, 342, 7062, 8, 342, 1, 342, 1, 342, 1, 342, 3, 342, 7067, 8, 342, 1, 342, 1, 342, 1, 342, 3, 342, 7072, 8, 342, 1, 342, 1, 342, 3, 342, 7076, 8, 342, 1, 342, 3, 342, 7079, 8, 342, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 3, 343, 7088, 8, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 3, 343, 7096, 8, 343, 1, 343, 1, 343, 1, 343, 3, 343, 7101, 8, 343, 3, 343, 7103, 8, 343, 1, 343, 3, 343, 7106, 8, 343, 1, 344, 1, 344, 3, 344, 7110, 8, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7121, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7142, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7150, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7163, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7173, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7179, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7185, 8, 345, 1, 345, 3, 345, 7188, 8, 345, 1, 345, 3, 345, 7191, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7217, 8, 345, 3, 345, 7219, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7240, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7250, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7263, 8, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7268, 8, 345, 1, 345, 1, 345, 3, 345, 7272, 8, 345, 3, 345, 7274, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7286, 8, 345, 1, 346, 1, 346, 1, 346, 5, 346, 7291, 8, 346, 10, 346, 12, 346, 7294, 9, 346, 1, 347, 1, 347, 1, 347, 3, 347, 7299, 8, 347, 1, 348, 1, 348, 1, 349, 1, 349, 3, 349, 7305, 8, 349, 1, 349, 1, 349, 3, 349, 7309, 8, 349, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 5, 351, 7318, 8, 351, 10, 351, 12, 351, 7321, 9, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 3, 353, 7330, 8, 353, 1, 354, 1, 354, 3, 354, 7334, 8, 354, 1, 354, 1, 354, 1, 354, 3, 354, 7339, 8, 354, 1, 354, 3, 354, 7342, 8, 354, 1, 354, 3, 354, 7345, 8, 354, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 3, 355, 7354, 8, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 3, 355, 7365, 8, 355, 3, 355, 7367, 8, 355, 1, 356, 1, 356, 3, 356, 7371, 8, 356, 1, 356, 1, 356, 1, 356, 3, 356, 7376, 8, 356, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 3, 357, 7385, 8, 357, 1, 358, 1, 358, 1, 358, 3, 358, 7390, 8, 358, 1, 358, 1, 358, 1, 359, 1, 359, 1, 360, 1, 360, 3, 360, 7398, 8, 360, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 3, 362, 7408, 8, 362, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 3, 363, 7416, 8, 363, 1, 364, 1, 364, 3, 364, 7420, 8, 364, 1, 364, 3, 364, 7423, 8, 364, 1, 365, 1, 365, 1, 365, 5, 365, 7428, 8, 365, 10, 365, 12, 365, 7431, 9, 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 3, 366, 7438, 8, 366, 1, 367, 1, 367, 3, 367, 7442, 8, 367, 1, 368, 1, 368, 1, 368, 5, 368, 7447, 8, 368, 10, 368, 12, 368, 7450, 9, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 3, 369, 7457, 8, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 5, 370, 7464, 8, 370, 10, 370, 12, 370, 7467, 9, 370, 3, 370, 7469, 8, 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 7481, 8, 371, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 7490, 8, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 7497, 8, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 7506, 8, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 3, 375, 7516, 8, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7521, 8, 375, 1, 375, 1, 375, 3, 375, 7525, 8, 375, 3, 375, 7527, 8, 375, 1, 375, 3, 375, 7530, 8, 375, 1, 376, 4, 376, 7533, 8, 376, 11, 376, 12, 376, 7534, 1, 377, 5, 377, 7538, 8, 377, 10, 377, 12, 377, 7541, 9, 377, 1, 378, 1, 378, 1, 378, 5, 378, 7546, 8, 378, 10, 378, 12, 378, 7549, 9, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 3, 379, 7556, 8, 379, 1, 379, 3, 379, 7559, 8, 379, 1, 380, 1, 380, 1, 380, 5, 380, 7564, 8, 380, 10, 380, 12, 380, 7567, 9, 380, 1, 381, 1, 381, 1, 381, 5, 381, 7572, 8, 381, 10, 381, 12, 381, 7575, 9, 381, 1, 382, 1, 382, 1, 382, 5, 382, 7580, 8, 382, 10, 382, 12, 382, 7583, 9, 382, 1, 383, 1, 383, 1, 383, 5, 383, 7588, 8, 383, 10, 383, 12, 383, 7591, 9, 383, 1, 384, 1, 384, 1, 385, 1, 385, 1, 386, 1, 386, 1, 387, 1, 387, 1, 388, 1, 388, 1, 389, 1, 389, 1, 390, 1, 390, 3, 390, 7607, 8, 390, 1, 391, 1, 391, 1, 391, 5, 391, 7612, 8, 391, 10, 391, 12, 391, 7615, 9, 391, 1, 392, 1, 392, 1, 392, 5, 392, 7620, 8, 392, 10, 392, 12, 392, 7623, 9, 392, 1, 393, 1, 393, 1, 394, 1, 394, 1, 395, 1, 395, 1, 396, 1, 396, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 3, 398, 7639, 8, 398, 1, 399, 1, 399, 1, 399, 1, 399, 3, 399, 7645, 8, 399, 1, 400, 1, 400, 1, 400, 1, 400, 3, 400, 7651, 8, 400, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 3, 402, 7659, 8, 402, 1, 403, 1, 403, 1, 403, 1, 403, 3, 403, 7665, 8, 403, 1, 404, 1, 404, 1, 404, 3, 404, 7670, 8, 404, 1, 405, 1, 405, 1, 405, 1, 405, 5, 405, 7676, 8, 405, 10, 405, 12, 405, 7679, 9, 405, 1, 405, 1, 405, 3, 405, 7683, 8, 405, 1, 406, 3, 406, 7686, 8, 406, 1, 406, 1, 406, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 3, 407, 7695, 8, 407, 1, 408, 1, 408, 1, 408, 5, 408, 7700, 8, 408, 10, 408, 12, 408, 7703, 9, 408, 1, 409, 1, 409, 1, 409, 1, 409, 3, 409, 7709, 8, 409, 1, 410, 1, 410, 1, 410, 1, 410, 3, 410, 7715, 8, 410, 1, 411, 1, 411, 1, 411, 1, 411, 3, 411, 7721, 8, 411, 1, 412, 1, 412, 1, 412, 3, 412, 7726, 8, 412, 1, 413, 1, 413, 1, 413, 3, 413, 7731, 8, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 3, 413, 7739, 8, 413, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 3, 415, 7794, 8, 415, 1, 416, 1, 416, 1, 417, 1, 417, 1, 418, 3, 418, 7801, 8, 418, 1, 418, 1, 418, 1, 418, 1, 418, 4, 418, 7807, 8, 418, 11, 418, 12, 418, 7808, 3, 418, 7811, 8, 418, 3, 418, 7813, 8, 418, 1, 418, 1, 418, 5, 418, 7817, 8, 418, 10, 418, 12, 418, 7820, 9, 418, 1, 418, 3, 418, 7823, 8, 418, 1, 418, 1, 418, 3, 418, 7827, 8, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 3, 420, 7838, 8, 420, 1, 420, 3, 420, 7841, 8, 420, 1, 420, 1, 420, 3, 420, 7845, 8, 420, 1, 420, 1, 420, 3, 420, 7849, 8, 420, 1, 420, 1, 420, 3, 420, 7853, 8, 420, 1, 420, 3, 420, 7856, 8, 420, 1, 420, 3, 420, 7859, 8, 420, 1, 420, 3, 420, 7862, 8, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 5, 420, 7869, 8, 420, 10, 420, 12, 420, 7872, 9, 420, 1, 420, 1, 420, 3, 420, 7876, 8, 420, 1, 420, 1, 420, 3, 420, 7880, 8, 420, 1, 420, 1, 420, 1, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 3, 423, 7913, 8, 423, 1, 424, 1, 424, 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7923, 8, 425, 1, 425, 1, 425, 3, 425, 7927, 8, 425, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7933, 8, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7938, 8, 425, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 3, 427, 7947, 8, 427, 1, 427, 1, 427, 1, 427, 1, 427, 5, 427, 7953, 8, 427, 10, 427, 12, 427, 7956, 9, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 429, 1, 429, 3, 429, 7966, 8, 429, 1, 429, 1, 429, 1, 429, 1, 429, 5, 429, 7972, 8, 429, 10, 429, 12, 429, 7975, 9, 429, 1, 430, 1, 430, 1, 430, 1, 430, 5, 430, 7981, 8, 430, 10, 430, 12, 430, 7984, 9, 430, 1, 430, 1, 430, 1, 430, 1, 430, 5, 430, 7990, 8, 430, 10, 430, 12, 430, 7993, 9, 430, 5, 430, 7995, 8, 430, 10, 430, 12, 430, 7998, 9, 430, 1, 430, 3, 430, 8001, 8, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 431, 1, 431, 5, 431, 8009, 8, 431, 10, 431, 12, 431, 8012, 9, 431, 1, 432, 1, 432, 3, 432, 8016, 8, 432, 1, 432, 1, 432, 1, 432, 1, 432, 5, 432, 8022, 8, 432, 10, 432, 12, 432, 8025, 9, 432, 4, 432, 8027, 8, 432, 11, 432, 12, 432, 8028, 1, 432, 3, 432, 8032, 8, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, 3, 433, 8039, 8, 433, 1, 433, 1, 433, 1, 433, 1, 433, 3, 433, 8045, 8, 433, 1, 433, 1, 433, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 8053, 8, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 8061, 8, 434, 1, 434, 3, 434, 8064, 8, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 8071, 8, 434, 3, 434, 8073, 8, 434, 1, 435, 3, 435, 8076, 8, 435, 1, 435, 1, 435, 1, 435, 1, 435, 3, 435, 8082, 8, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 436, 1, 436, 3, 436, 8091, 8, 436, 1, 436, 1, 436, 3, 436, 8095, 8, 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 3, 437, 8109, 8, 437, 1, 437, 3, 437, 8112, 8, 437, 3, 437, 8114, 8, 437, 1, 437, 1, 437, 1, 438, 1, 438, 3, 438, 8120, 8, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 4, 438, 8128, 8, 438, 11, 438, 12, 438, 8129, 3, 438, 8132, 8, 438, 3, 438, 8134, 8, 438, 1, 438, 1, 438, 1, 438, 1, 438, 5, 438, 8140, 8, 438, 10, 438, 12, 438, 8143, 9, 438, 3, 438, 8145, 8, 438, 1, 438, 3, 438, 8148, 8, 438, 1, 439, 1, 439, 1, 439, 1, 439, 1, 440, 1, 440, 1, 440, 1, 440, 3, 440, 8158, 8, 440, 1, 440, 1, 440, 1, 441, 1, 441, 5, 441, 8164, 8, 441, 10, 441, 12, 441, 8167, 9, 441, 1, 441, 1, 441, 1, 441, 3, 441, 8172, 8, 441, 1, 441, 1, 441, 1, 442, 1, 442, 3, 442, 8178, 8, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 3, 443, 8185, 8, 443, 1, 443, 1, 443, 3, 443, 8189, 8, 443, 1, 443, 1, 443, 3, 443, 8193, 8, 443, 1, 443, 3, 443, 8196, 8, 443, 1, 443, 3, 443, 8199, 8, 443, 1, 443, 1, 443, 1, 444, 1, 444, 3, 444, 8205, 8, 444, 1, 444, 1, 444, 1, 445, 1, 445, 1, 445, 3, 445, 8212, 8, 445, 1, 445, 3, 445, 8215, 8, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 3, 445, 8223, 8, 445, 3, 445, 8225, 8, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 5, 445, 8232, 8, 445, 10, 445, 12, 445, 8235, 9, 445, 1, 445, 1, 445, 3, 445, 8239, 8, 445, 3, 445, 8241, 8, 445, 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 3, 446, 8248, 8, 446, 1, 446, 1, 446, 1, 447, 1, 447, 3, 447, 8254, 8, 447, 1, 447, 3, 447, 8257, 8, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8269, 8, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8276, 8, 448, 3, 448, 8278, 8, 448, 1, 449, 1, 449, 3, 449, 8282, 8, 449, 1, 449, 1, 449, 1, 449, 1, 450, 3, 450, 8288, 8, 450, 1, 450, 1, 450, 1, 450, 3, 450, 8293, 8, 450, 1, 450, 1, 450, 3, 450, 8297, 8, 450, 1, 450, 3, 450, 8300, 8, 450, 1, 450, 3, 450, 8303, 8, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 4, 450, 8310, 8, 450, 11, 450, 12, 450, 8311, 1, 451, 3, 451, 8315, 8, 451, 1, 451, 1, 451, 3, 451, 8319, 8, 451, 1, 451, 1, 451, 3, 451, 8323, 8, 451, 3, 451, 8325, 8, 451, 1, 451, 3, 451, 8328, 8, 451, 1, 451, 3, 451, 8331, 8, 451, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8337, 8, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8344, 8, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8351, 8, 452, 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 8357, 8, 452, 3, 452, 8359, 8, 452, 1, 453, 1, 453, 3, 453, 8363, 8, 453, 1, 453, 1, 453, 1, 453, 3, 453, 8368, 8, 453, 1, 453, 1, 453, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 5, 454, 8384, 8, 454, 10, 454, 12, 454, 8387, 9, 454, 1, 454, 1, 454, 4, 454, 8391, 8, 454, 11, 454, 12, 454, 8392, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 5, 455, 8400, 8, 455, 10, 455, 12, 455, 8403, 9, 455, 1, 455, 1, 455, 1, 455, 1, 455, 3, 455, 8409, 8, 455, 1, 456, 1, 456, 3, 456, 8413, 8, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 3, 459, 8425, 8, 459, 1, 459, 3, 459, 8428, 8, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 3, 460, 8441, 8, 460, 1, 460, 3, 460, 8444, 8, 460, 1, 461, 1, 461, 3, 461, 8448, 8, 461, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 5, 462, 8455, 8, 462, 10, 462, 12, 462, 8458, 9, 462, 1, 462, 1, 462, 5, 462, 8462, 8, 462, 10, 462, 12, 462, 8465, 9, 462, 4, 462, 8467, 8, 462, 11, 462, 12, 462, 8468, 1, 463, 1, 463, 1, 463, 3, 463, 8474, 8, 463, 1, 464, 1, 464, 3, 464, 8478, 8, 464, 1, 465, 1, 465, 1, 466, 3, 466, 8483, 8, 466, 1, 466, 3, 466, 8486, 8, 466, 1, 466, 3, 466, 8489, 8, 466, 1, 466, 3, 466, 8492, 8, 466, 1, 466, 3, 466, 8495, 8, 466, 1, 466, 1, 466, 3, 466, 8499, 8, 466, 1, 466, 3, 466, 8502, 8, 466, 1, 466, 0, 3, 676, 680, 682, 467, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, 748, 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, 780, 782, 784, 786, 788, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810, 812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, 870, 872, 874, 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, 924, 926, 928, 930, 932, 0, 119, 2, 0, 195, 195, 364, 364, 2, 0, 66, 66, 318, 318, 2, 0, 99, 99, 318, 318, 2, 0, 134, 134, 318, 318, 1, 0, 529, 531, 2, 0, 10, 10, 94, 94, 2, 0, 133, 133, 191, 191, 2, 0, 254, 254, 332, 332, 2, 0, 162, 162, 363, 363, 2, 0, 180, 180, 221, 221, 5, 0, 30, 30, 288, 288, 329, 329, 352, 352, 354, 354, 2, 0, 109, 109, 532, 532, 2, 0, 158, 158, 277, 277, 2, 0, 367, 367, 439, 439, 2, 0, 139, 139, 312, 312, 2, 0, 191, 191, 333, 333, 2, 0, 313, 313, 333, 333, 2, 0, 150, 150, 315, 315, 2, 0, 64, 64, 94, 94, 4, 0, 78, 78, 183, 183, 197, 197, 298, 298, 2, 0, 213, 213, 254, 254, 2, 0, 352, 352, 354, 354, 2, 0, 200, 200, 224, 224, 9, 0, 30, 30, 160, 160, 165, 165, 179, 179, 219, 219, 227, 227, 342, 342, 345, 345, 438, 438, 3, 0, 113, 113, 284, 284, 336, 336, 2, 0, 53, 53, 78, 78, 2, 0, 105, 105, 379, 379, 2, 0, 260, 260, 262, 262, 3, 0, 173, 173, 260, 260, 262, 262, 1, 0, 12, 13, 2, 0, 64, 64, 375, 375, 2, 0, 156, 156, 206, 206, 2, 0, 189, 189, 360, 360, 2, 0, 215, 215, 373, 373, 3, 0, 133, 133, 191, 191, 333, 333, 5, 0, 30, 30, 88, 88, 182, 182, 241, 241, 369, 369, 2, 0, 9, 9, 94, 94, 2, 0, 92, 92, 226, 226, 1, 0, 448, 449, 2, 0, 92, 92, 414, 414, 2, 0, 341, 341, 414, 414, 4, 0, 163, 163, 185, 185, 283, 283, 353, 353, 2, 0, 135, 135, 145, 145, 2, 0, 211, 211, 278, 278, 3, 0, 321, 321, 357, 357, 445, 445, 3, 0, 66, 66, 99, 99, 318, 318, 5, 0, 108, 108, 168, 168, 226, 226, 328, 328, 342, 342, 2, 0, 167, 167, 314, 314, 2, 0, 61, 61, 265, 265, 4, 0, 207, 207, 249, 249, 268, 268, 293, 293, 2, 0, 130, 130, 307, 307, 2, 0, 64, 64, 68, 68, 10, 0, 46, 46, 88, 88, 182, 182, 202, 202, 241, 241, 352, 352, 354, 354, 357, 358, 369, 369, 521, 523, 5, 0, 212, 212, 329, 329, 350, 350, 455, 455, 457, 457, 5, 0, 212, 212, 329, 329, 350, 350, 361, 361, 455, 456, 2, 0, 37, 37, 55, 55, 2, 0, 207, 207, 249, 249, 2, 0, 10, 10, 53, 53, 2, 0, 181, 181, 243, 243, 2, 0, 170, 170, 320, 320, 2, 0, 141, 141, 223, 223, 5, 0, 108, 108, 168, 168, 189, 189, 342, 342, 360, 360, 2, 0, 226, 226, 328, 328, 2, 0, 163, 163, 185, 185, 2, 0, 186, 186, 193, 193, 4, 0, 88, 88, 182, 182, 241, 241, 369, 369, 2, 0, 137, 137, 242, 242, 2, 0, 161, 161, 319, 319, 4, 0, 129, 129, 161, 161, 319, 319, 454, 454, 2, 0, 356, 356, 380, 380, 2, 0, 81, 81, 382, 382, 2, 0, 151, 151, 254, 254, 2, 0, 133, 133, 138, 138, 1, 0, 31, 32, 2, 0, 128, 128, 547, 547, 2, 0, 60, 60, 96, 96, 2, 0, 99, 99, 349, 349, 2, 0, 131, 131, 414, 414, 2, 0, 201, 201, 334, 334, 3, 0, 59, 59, 70, 70, 97, 97, 2, 0, 30, 30, 56, 56, 1, 0, 527, 528, 2, 0, 207, 207, 268, 268, 2, 0, 320, 320, 414, 414, 2, 0, 571, 571, 573, 573, 1, 0, 468, 469, 4, 0, 113, 113, 115, 115, 119, 119, 126, 126, 2, 0, 360, 360, 477, 477, 2, 0, 394, 395, 409, 409, 2, 0, 391, 392, 406, 406, 1, 0, 391, 392, 1, 0, 418, 419, 5, 0, 10, 10, 16, 17, 21, 21, 23, 23, 25, 25, 3, 0, 9, 9, 14, 14, 27, 27, 2, 0, 98, 98, 396, 396, 2, 0, 50, 51, 75, 76, 2, 0, 41, 41, 420, 420, 3, 0, 39, 39, 73, 73, 95, 95, 4, 0, 393, 393, 399, 399, 404, 404, 425, 425, 2, 0, 292, 292, 347, 347, 2, 0, 166, 166, 188, 188, 2, 0, 304, 304, 450, 450, 3, 0, 299, 299, 320, 320, 481, 481, 2, 0, 208, 208, 289, 289, 3, 0, 30, 30, 34, 34, 90, 90, 6, 0, 9, 10, 12, 17, 21, 21, 23, 23, 25, 25, 27, 27, 2, 0, 114, 114, 120, 120, 2, 0, 20, 20, 22, 22, 1, 0, 483, 486, 10, 0, 124, 124, 129, 228, 238, 386, 433, 452, 455, 469, 471, 471, 473, 473, 475, 475, 478, 488, 547, 548, 3, 0, 106, 123, 125, 128, 472, 472, 4, 0, 30, 52, 54, 70, 72, 105, 454, 454, 2, 0, 62, 62, 116, 116, 2, 0, 10, 10, 20, 20, 2, 0, 434, 434, 501, 501, 2, 0, 167, 167, 507, 507, 1, 0, 512, 517, 2, 0, 144, 144, 210, 210, 36, 0, 33, 33, 35, 35, 43, 43, 45, 45, 53, 53, 57, 57, 61, 61, 116, 116, 123, 123, 130, 130, 144, 144, 153, 153, 157, 157, 161, 161, 167, 167, 172, 172, 207, 207, 210, 210, 241, 241, 249, 249, 265, 265, 268, 269, 279, 279, 293, 293, 307, 307, 313, 313, 319, 319, 323, 324, 333, 333, 360, 360, 433, 434, 477, 477, 490, 502, 504, 504, 506, 518, 520, 520, 9941, 0, 937, 1, 0, 0, 0, 2, 942, 1, 0, 0, 0, 4, 1066, 1, 0, 0, 0, 6, 1068, 1, 0, 0, 0, 8, 1071, 1, 0, 0, 0, 10, 1121, 1, 0, 0, 0, 12, 1131, 1, 0, 0, 0, 14, 1133, 1, 0, 0, 0, 16, 1145, 1, 0, 0, 0, 18, 1157, 1, 0, 0, 0, 20, 1168, 1, 0, 0, 0, 22, 1202, 1, 0, 0, 0, 24, 1246, 1, 0, 0, 0, 26, 1248, 1, 0, 0, 0, 28, 1260, 1, 0, 0, 0, 30, 1267, 1, 0, 0, 0, 32, 1286, 1, 0, 0, 0, 34, 1294, 1, 0, 0, 0, 36, 1296, 1, 0, 0, 0, 38, 1310, 1, 0, 0, 0, 40, 1314, 1, 0, 0, 0, 42, 1351, 1, 0, 0, 0, 44, 1353, 1, 0, 0, 0, 46, 1361, 1, 0, 0, 0, 48, 1371, 1, 0, 0, 0, 50, 1378, 1, 0, 0, 0, 52, 1386, 1, 0, 0, 0, 54, 1392, 1, 0, 0, 0, 56, 1408, 1, 0, 0, 0, 58, 1412, 1, 0, 0, 0, 60, 1414, 1, 0, 0, 0, 62, 1426, 1, 0, 0, 0, 64, 1431, 1, 0, 0, 0, 66, 1436, 1, 0, 0, 0, 68, 1438, 1, 0, 0, 0, 70, 1450, 1, 0, 0, 0, 72, 1458, 1, 0, 0, 0, 74, 1460, 1, 0, 0, 0, 76, 1584, 1, 0, 0, 0, 78, 1586, 1, 0, 0, 0, 80, 1603, 1, 0, 0, 0, 82, 1605, 1, 0, 0, 0, 84, 1619, 1, 0, 0, 0, 86, 1621, 1, 0, 0, 0, 88, 1635, 1, 0, 0, 0, 90, 1637, 1, 0, 0, 0, 92, 1874, 1, 0, 0, 0, 94, 1881, 1, 0, 0, 0, 96, 1883, 1, 0, 0, 0, 98, 1885, 1, 0, 0, 0, 100, 1888, 1, 0, 0, 0, 102, 1899, 1, 0, 0, 0, 104, 1902, 1, 0, 0, 0, 106, 1938, 1, 0, 0, 0, 108, 1940, 1, 0, 0, 0, 110, 1981, 1, 0, 0, 0, 112, 1983, 1, 0, 0, 0, 114, 2037, 1, 0, 0, 0, 116, 2078, 1, 0, 0, 0, 118, 2080, 1, 0, 0, 0, 120, 2097, 1, 0, 0, 0, 122, 2178, 1, 0, 0, 0, 124, 2180, 1, 0, 0, 0, 126, 2191, 1, 0, 0, 0, 128, 2214, 1, 0, 0, 0, 130, 2232, 1, 0, 0, 0, 132, 2234, 1, 0, 0, 0, 134, 2269, 1, 0, 0, 0, 136, 2362, 1, 0, 0, 0, 138, 2367, 1, 0, 0, 0, 140, 2369, 1, 0, 0, 0, 142, 2467, 1, 0, 0, 0, 144, 2469, 1, 0, 0, 0, 146, 2473, 1, 0, 0, 0, 148, 2484, 1, 0, 0, 0, 150, 2492, 1, 0, 0, 0, 152, 2495, 1, 0, 0, 0, 154, 2498, 1, 0, 0, 0, 156, 2516, 1, 0, 0, 0, 158, 2518, 1, 0, 0, 0, 160, 2522, 1, 0, 0, 0, 162, 2535, 1, 0, 0, 0, 164, 2537, 1, 0, 0, 0, 166, 2542, 1, 0, 0, 0, 168, 2562, 1, 0, 0, 0, 170, 2570, 1, 0, 0, 0, 172, 2577, 1, 0, 0, 0, 174, 2579, 1, 0, 0, 0, 176, 2588, 1, 0, 0, 0, 178, 2591, 1, 0, 0, 0, 180, 2595, 1, 0, 0, 0, 182, 2599, 1, 0, 0, 0, 184, 2624, 1, 0, 0, 0, 186, 2634, 1, 0, 0, 0, 188, 2648, 1, 0, 0, 0, 190, 2664, 1, 0, 0, 0, 192, 2670, 1, 0, 0, 0, 194, 2697, 1, 0, 0, 0, 196, 2707, 1, 0, 0, 0, 198, 2723, 1, 0, 0, 0, 200, 2767, 1, 0, 0, 0, 202, 2774, 1, 0, 0, 0, 204, 2776, 1, 0, 0, 0, 206, 2802, 1, 0, 0, 0, 208, 2813, 1, 0, 0, 0, 210, 2832, 1, 0, 0, 0, 212, 2843, 1, 0, 0, 0, 214, 2881, 1, 0, 0, 0, 216, 2902, 1, 0, 0, 0, 218, 2904, 1, 0, 0, 0, 220, 2924, 1, 0, 0, 0, 222, 2936, 1, 0, 0, 0, 224, 2948, 1, 0, 0, 0, 226, 2951, 1, 0, 0, 0, 228, 2954, 1, 0, 0, 0, 230, 2974, 1, 0, 0, 0, 232, 2979, 1, 0, 0, 0, 234, 3028, 1, 0, 0, 0, 236, 3030, 1, 0, 0, 0, 238, 3053, 1, 0, 0, 0, 240, 3069, 1, 0, 0, 0, 242, 3081, 1, 0, 0, 0, 244, 3108, 1, 0, 0, 0, 246, 3123, 1, 0, 0, 0, 248, 3186, 1, 0, 0, 0, 250, 3188, 1, 0, 0, 0, 252, 3193, 1, 0, 0, 0, 254, 3199, 1, 0, 0, 0, 256, 3286, 1, 0, 0, 0, 258, 3292, 1, 0, 0, 0, 260, 3294, 1, 0, 0, 0, 262, 3310, 1, 0, 0, 0, 264, 3312, 1, 0, 0, 0, 266, 3321, 1, 0, 0, 0, 268, 3325, 1, 0, 0, 0, 270, 3338, 1, 0, 0, 0, 272, 3350, 1, 0, 0, 0, 274, 3352, 1, 0, 0, 0, 276, 3374, 1, 0, 0, 0, 278, 3386, 1, 0, 0, 0, 280, 3397, 1, 0, 0, 0, 282, 3488, 1, 0, 0, 0, 284, 3490, 1, 0, 0, 0, 286, 3501, 1, 0, 0, 0, 288, 3512, 1, 0, 0, 0, 290, 3514, 1, 0, 0, 0, 292, 3540, 1, 0, 0, 0, 294, 3542, 1, 0, 0, 0, 296, 3546, 1, 0, 0, 0, 298, 3596, 1, 0, 0, 0, 300, 3598, 1, 0, 0, 0, 302, 3604, 1, 0, 0, 0, 304, 3629, 1, 0, 0, 0, 306, 3633, 1, 0, 0, 0, 308, 3847, 1, 0, 0, 0, 310, 3865, 1, 0, 0, 0, 312, 3891, 1, 0, 0, 0, 314, 3893, 1, 0, 0, 0, 316, 3901, 1, 0, 0, 0, 318, 3907, 1, 0, 0, 0, 320, 3911, 1, 0, 0, 0, 322, 3931, 1, 0, 0, 0, 324, 3937, 1, 0, 0, 0, 326, 4004, 1, 0, 0, 0, 328, 4035, 1, 0, 0, 0, 330, 4081, 1, 0, 0, 0, 332, 4083, 1, 0, 0, 0, 334, 4085, 1, 0, 0, 0, 336, 4096, 1, 0, 0, 0, 338, 4133, 1, 0, 0, 0, 340, 4135, 1, 0, 0, 0, 342, 4141, 1, 0, 0, 0, 344, 4191, 1, 0, 0, 0, 346, 4194, 1, 0, 0, 0, 348, 4208, 1, 0, 0, 0, 350, 4229, 1, 0, 0, 0, 352, 4253, 1, 0, 0, 0, 354, 4294, 1, 0, 0, 0, 356, 4296, 1, 0, 0, 0, 358, 4298, 1, 0, 0, 0, 360, 4338, 1, 0, 0, 0, 362, 4355, 1, 0, 0, 0, 364, 4375, 1, 0, 0, 0, 366, 4428, 1, 0, 0, 0, 368, 4431, 1, 0, 0, 0, 370, 4437, 1, 0, 0, 0, 372, 4445, 1, 0, 0, 0, 374, 4458, 1, 0, 0, 0, 376, 4460, 1, 0, 0, 0, 378, 4473, 1, 0, 0, 0, 380, 4475, 1, 0, 0, 0, 382, 4488, 1, 0, 0, 0, 384, 4498, 1, 0, 0, 0, 386, 4509, 1, 0, 0, 0, 388, 4520, 1, 0, 0, 0, 390, 4522, 1, 0, 0, 0, 392, 4527, 1, 0, 0, 0, 394, 4541, 1, 0, 0, 0, 396, 4573, 1, 0, 0, 0, 398, 4610, 1, 0, 0, 0, 400, 4612, 1, 0, 0, 0, 402, 4615, 1, 0, 0, 0, 404, 4618, 1, 0, 0, 0, 406, 4635, 1, 0, 0, 0, 408, 4656, 1, 0, 0, 0, 410, 4672, 1, 0, 0, 0, 412, 4688, 1, 0, 0, 0, 414, 4710, 1, 0, 0, 0, 416, 4715, 1, 0, 0, 0, 418, 4718, 1, 0, 0, 0, 420, 4726, 1, 0, 0, 0, 422, 4751, 1, 0, 0, 0, 424, 4754, 1, 0, 0, 0, 426, 4782, 1, 0, 0, 0, 428, 4787, 1, 0, 0, 0, 430, 4827, 1, 0, 0, 0, 432, 5039, 1, 0, 0, 0, 434, 5041, 1, 0, 0, 0, 436, 5129, 1, 0, 0, 0, 438, 5131, 1, 0, 0, 0, 440, 5137, 1, 0, 0, 0, 442, 5148, 1, 0, 0, 0, 444, 5158, 1, 0, 0, 0, 446, 5238, 1, 0, 0, 0, 448, 5240, 1, 0, 0, 0, 450, 5254, 1, 0, 0, 0, 452, 5276, 1, 0, 0, 0, 454, 5349, 1, 0, 0, 0, 456, 5351, 1, 0, 0, 0, 458, 5392, 1, 0, 0, 0, 460, 5394, 1, 0, 0, 0, 462, 5399, 1, 0, 0, 0, 464, 5402, 1, 0, 0, 0, 466, 5405, 1, 0, 0, 0, 468, 5455, 1, 0, 0, 0, 470, 5457, 1, 0, 0, 0, 472, 5468, 1, 0, 0, 0, 474, 5470, 1, 0, 0, 0, 476, 5480, 1, 0, 0, 0, 478, 5515, 1, 0, 0, 0, 480, 5518, 1, 0, 0, 0, 482, 5539, 1, 0, 0, 0, 484, 5549, 1, 0, 0, 0, 486, 5569, 1, 0, 0, 0, 488, 5575, 1, 0, 0, 0, 490, 5581, 1, 0, 0, 0, 492, 5586, 1, 0, 0, 0, 494, 5599, 1, 0, 0, 0, 496, 5626, 1, 0, 0, 0, 498, 5674, 1, 0, 0, 0, 500, 5676, 1, 0, 0, 0, 502, 5714, 1, 0, 0, 0, 504, 5716, 1, 0, 0, 0, 506, 5737, 1, 0, 0, 0, 508, 5757, 1, 0, 0, 0, 510, 5761, 1, 0, 0, 0, 512, 5776, 1, 0, 0, 0, 514, 5778, 1, 0, 0, 0, 516, 5782, 1, 0, 0, 0, 518, 5786, 1, 0, 0, 0, 520, 5794, 1, 0, 0, 0, 522, 5818, 1, 0, 0, 0, 524, 5820, 1, 0, 0, 0, 526, 5831, 1, 0, 0, 0, 528, 5839, 1, 0, 0, 0, 530, 5854, 1, 0, 0, 0, 532, 5879, 1, 0, 0, 0, 534, 5881, 1, 0, 0, 0, 536, 5885, 1, 0, 0, 0, 538, 5894, 1, 0, 0, 0, 540, 5934, 1, 0, 0, 0, 542, 5945, 1, 0, 0, 0, 544, 5953, 1, 0, 0, 0, 546, 5956, 1, 0, 0, 0, 548, 5960, 1, 0, 0, 0, 550, 5975, 1, 0, 0, 0, 552, 6000, 1, 0, 0, 0, 554, 6015, 1, 0, 0, 0, 556, 6041, 1, 0, 0, 0, 558, 6043, 1, 0, 0, 0, 560, 6066, 1, 0, 0, 0, 562, 6068, 1, 0, 0, 0, 564, 6076, 1, 0, 0, 0, 566, 6094, 1, 0, 0, 0, 568, 6118, 1, 0, 0, 0, 570, 6130, 1, 0, 0, 0, 572, 6134, 1, 0, 0, 0, 574, 6146, 1, 0, 0, 0, 576, 6166, 1, 0, 0, 0, 578, 6174, 1, 0, 0, 0, 580, 6188, 1, 0, 0, 0, 582, 6211, 1, 0, 0, 0, 584, 6213, 1, 0, 0, 0, 586, 6218, 1, 0, 0, 0, 588, 6228, 1, 0, 0, 0, 590, 6249, 1, 0, 0, 0, 592, 6251, 1, 0, 0, 0, 594, 6260, 1, 0, 0, 0, 596, 6271, 1, 0, 0, 0, 598, 6281, 1, 0, 0, 0, 600, 6283, 1, 0, 0, 0, 602, 6290, 1, 0, 0, 0, 604, 6321, 1, 0, 0, 0, 606, 6351, 1, 0, 0, 0, 608, 6353, 1, 0, 0, 0, 610, 6362, 1, 0, 0, 0, 612, 6365, 1, 0, 0, 0, 614, 6436, 1, 0, 0, 0, 616, 6460, 1, 0, 0, 0, 618, 6481, 1, 0, 0, 0, 620, 6483, 1, 0, 0, 0, 622, 6491, 1, 0, 0, 0, 624, 6508, 1, 0, 0, 0, 626, 6534, 1, 0, 0, 0, 628, 6536, 1, 0, 0, 0, 630, 6544, 1, 0, 0, 0, 632, 6551, 1, 0, 0, 0, 634, 6575, 1, 0, 0, 0, 636, 6581, 1, 0, 0, 0, 638, 6589, 1, 0, 0, 0, 640, 6592, 1, 0, 0, 0, 642, 6599, 1, 0, 0, 0, 644, 6607, 1, 0, 0, 0, 646, 6612, 1, 0, 0, 0, 648, 6642, 1, 0, 0, 0, 650, 6669, 1, 0, 0, 0, 652, 6697, 1, 0, 0, 0, 654, 6714, 1, 0, 0, 0, 656, 6720, 1, 0, 0, 0, 658, 6738, 1, 0, 0, 0, 660, 6740, 1, 0, 0, 0, 662, 6744, 1, 0, 0, 0, 664, 6761, 1, 0, 0, 0, 666, 6766, 1, 0, 0, 0, 668, 6804, 1, 0, 0, 0, 670, 6806, 1, 0, 0, 0, 672, 6810, 1, 0, 0, 0, 674, 6812, 1, 0, 0, 0, 676, 6821, 1, 0, 0, 0, 678, 6905, 1, 0, 0, 0, 680, 6911, 1, 0, 0, 0, 682, 7020, 1, 0, 0, 0, 684, 7052, 1, 0, 0, 0, 686, 7105, 1, 0, 0, 0, 688, 7109, 1, 0, 0, 0, 690, 7285, 1, 0, 0, 0, 692, 7287, 1, 0, 0, 0, 694, 7295, 1, 0, 0, 0, 696, 7300, 1, 0, 0, 0, 698, 7302, 1, 0, 0, 0, 700, 7310, 1, 0, 0, 0, 702, 7313, 1, 0, 0, 0, 704, 7322, 1, 0, 0, 0, 706, 7326, 1, 0, 0, 0, 708, 7331, 1, 0, 0, 0, 710, 7348, 1, 0, 0, 0, 712, 7375, 1, 0, 0, 0, 714, 7384, 1, 0, 0, 0, 716, 7386, 1, 0, 0, 0, 718, 7393, 1, 0, 0, 0, 720, 7397, 1, 0, 0, 0, 722, 7399, 1, 0, 0, 0, 724, 7407, 1, 0, 0, 0, 726, 7415, 1, 0, 0, 0, 728, 7422, 1, 0, 0, 0, 730, 7424, 1, 0, 0, 0, 732, 7437, 1, 0, 0, 0, 734, 7441, 1, 0, 0, 0, 736, 7443, 1, 0, 0, 0, 738, 7456, 1, 0, 0, 0, 740, 7458, 1, 0, 0, 0, 742, 7480, 1, 0, 0, 0, 744, 7482, 1, 0, 0, 0, 746, 7505, 1, 0, 0, 0, 748, 7507, 1, 0, 0, 0, 750, 7529, 1, 0, 0, 0, 752, 7532, 1, 0, 0, 0, 754, 7539, 1, 0, 0, 0, 756, 7542, 1, 0, 0, 0, 758, 7558, 1, 0, 0, 0, 760, 7560, 1, 0, 0, 0, 762, 7568, 1, 0, 0, 0, 764, 7576, 1, 0, 0, 0, 766, 7584, 1, 0, 0, 0, 768, 7592, 1, 0, 0, 0, 770, 7594, 1, 0, 0, 0, 772, 7596, 1, 0, 0, 0, 774, 7598, 1, 0, 0, 0, 776, 7600, 1, 0, 0, 0, 778, 7602, 1, 0, 0, 0, 780, 7604, 1, 0, 0, 0, 782, 7608, 1, 0, 0, 0, 784, 7616, 1, 0, 0, 0, 786, 7624, 1, 0, 0, 0, 788, 7626, 1, 0, 0, 0, 790, 7628, 1, 0, 0, 0, 792, 7630, 1, 0, 0, 0, 794, 7632, 1, 0, 0, 0, 796, 7638, 1, 0, 0, 0, 798, 7644, 1, 0, 0, 0, 800, 7650, 1, 0, 0, 0, 802, 7652, 1, 0, 0, 0, 804, 7658, 1, 0, 0, 0, 806, 7664, 1, 0, 0, 0, 808, 7666, 1, 0, 0, 0, 810, 7682, 1, 0, 0, 0, 812, 7685, 1, 0, 0, 0, 814, 7694, 1, 0, 0, 0, 816, 7696, 1, 0, 0, 0, 818, 7708, 1, 0, 0, 0, 820, 7714, 1, 0, 0, 0, 822, 7720, 1, 0, 0, 0, 824, 7725, 1, 0, 0, 0, 826, 7738, 1, 0, 0, 0, 828, 7740, 1, 0, 0, 0, 830, 7793, 1, 0, 0, 0, 832, 7795, 1, 0, 0, 0, 834, 7797, 1, 0, 0, 0, 836, 7800, 1, 0, 0, 0, 838, 7828, 1, 0, 0, 0, 840, 7832, 1, 0, 0, 0, 842, 7883, 1, 0, 0, 0, 844, 7886, 1, 0, 0, 0, 846, 7912, 1, 0, 0, 0, 848, 7914, 1, 0, 0, 0, 850, 7937, 1, 0, 0, 0, 852, 7939, 1, 0, 0, 0, 854, 7944, 1, 0, 0, 0, 856, 7959, 1, 0, 0, 0, 858, 7965, 1, 0, 0, 0, 860, 7976, 1, 0, 0, 0, 862, 8006, 1, 0, 0, 0, 864, 8013, 1, 0, 0, 0, 866, 8038, 1, 0, 0, 0, 868, 8048, 1, 0, 0, 0, 870, 8075, 1, 0, 0, 0, 872, 8088, 1, 0, 0, 0, 874, 8098, 1, 0, 0, 0, 876, 8117, 1, 0, 0, 0, 878, 8149, 1, 0, 0, 0, 880, 8153, 1, 0, 0, 0, 882, 8161, 1, 0, 0, 0, 884, 8175, 1, 0, 0, 0, 886, 8181, 1, 0, 0, 0, 888, 8202, 1, 0, 0, 0, 890, 8208, 1, 0, 0, 0, 892, 8247, 1, 0, 0, 0, 894, 8251, 1, 0, 0, 0, 896, 8277, 1, 0, 0, 0, 898, 8279, 1, 0, 0, 0, 900, 8287, 1, 0, 0, 0, 902, 8324, 1, 0, 0, 0, 904, 8358, 1, 0, 0, 0, 906, 8360, 1, 0, 0, 0, 908, 8371, 1, 0, 0, 0, 910, 8408, 1, 0, 0, 0, 912, 8412, 1, 0, 0, 0, 914, 8414, 1, 0, 0, 0, 916, 8418, 1, 0, 0, 0, 918, 8421, 1, 0, 0, 0, 920, 8443, 1, 0, 0, 0, 922, 8447, 1, 0, 0, 0, 924, 8449, 1, 0, 0, 0, 926, 8473, 1, 0, 0, 0, 928, 8477, 1, 0, 0, 0, 930, 8479, 1, 0, 0, 0, 932, 8482, 1, 0, 0, 0, 934, 936, 3, 2, 1, 0, 935, 934, 1, 0, 0, 0, 936, 939, 1, 0, 0, 0, 937, 935, 1, 0, 0, 0, 937, 938, 1, 0, 0, 0, 938, 940, 1, 0, 0, 0, 939, 937, 1, 0, 0, 0, 940, 941, 5, 0, 0, 1, 941, 1, 1, 0, 0, 0, 942, 944, 3, 4, 2, 0, 943, 945, 5, 7, 0, 0, 944, 943, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 3, 1, 0, 0, 0, 946, 1067, 3, 278, 139, 0, 947, 1067, 3, 488, 244, 0, 948, 1067, 3, 484, 242, 0, 949, 1067, 3, 486, 243, 0, 950, 1067, 3, 352, 176, 0, 951, 1067, 3, 494, 247, 0, 952, 1067, 3, 292, 146, 0, 953, 1067, 3, 210, 105, 0, 954, 1067, 3, 212, 106, 0, 955, 1067, 3, 218, 109, 0, 956, 1067, 3, 232, 116, 0, 957, 1067, 3, 404, 202, 0, 958, 1067, 3, 28, 14, 0, 959, 1067, 3, 434, 217, 0, 960, 1067, 3, 436, 218, 0, 961, 1067, 3, 446, 223, 0, 962, 1067, 3, 438, 219, 0, 963, 1067, 3, 444, 222, 0, 964, 1067, 3, 244, 122, 0, 965, 1067, 3, 246, 123, 0, 966, 1067, 3, 198, 99, 0, 967, 1067, 3, 490, 245, 0, 968, 1067, 3, 76, 38, 0, 969, 1067, 3, 430, 215, 0, 970, 1067, 3, 108, 54, 0, 971, 1067, 3, 450, 225, 0, 972, 1067, 3, 18, 9, 0, 973, 1067, 3, 20, 10, 0, 974, 1067, 3, 16, 8, 0, 975, 1067, 3, 454, 227, 0, 976, 1067, 3, 184, 92, 0, 977, 1067, 3, 498, 249, 0, 978, 1067, 3, 496, 248, 0, 979, 1067, 3, 240, 120, 0, 980, 1067, 3, 506, 253, 0, 981, 1067, 3, 6, 3, 0, 982, 1067, 3, 72, 36, 0, 983, 1067, 3, 112, 56, 0, 984, 1067, 3, 502, 251, 0, 985, 1067, 3, 324, 162, 0, 986, 1067, 3, 70, 35, 0, 987, 1067, 3, 114, 57, 0, 988, 1067, 3, 254, 127, 0, 989, 1067, 3, 186, 93, 0, 990, 1067, 3, 280, 140, 0, 991, 1067, 3, 420, 210, 0, 992, 1067, 3, 500, 250, 0, 993, 1067, 3, 492, 246, 0, 994, 1067, 3, 208, 104, 0, 995, 1067, 3, 214, 107, 0, 996, 1067, 3, 228, 114, 0, 997, 1067, 3, 234, 117, 0, 998, 1067, 3, 364, 182, 0, 999, 1067, 3, 26, 13, 0, 1000, 1067, 3, 192, 96, 0, 1001, 1067, 3, 296, 148, 0, 1002, 1067, 3, 300, 150, 0, 1003, 1067, 3, 448, 224, 0, 1004, 1067, 3, 302, 151, 0, 1005, 1067, 3, 242, 121, 0, 1006, 1067, 3, 204, 102, 0, 1007, 1067, 3, 30, 15, 0, 1008, 1067, 3, 196, 98, 0, 1009, 1067, 3, 120, 60, 0, 1010, 1067, 3, 452, 226, 0, 1011, 1067, 3, 182, 91, 0, 1012, 1067, 3, 206, 103, 0, 1013, 1067, 3, 424, 212, 0, 1014, 1067, 3, 256, 128, 0, 1015, 1067, 3, 274, 137, 0, 1016, 1067, 3, 8, 4, 0, 1017, 1067, 3, 14, 7, 0, 1018, 1067, 3, 238, 119, 0, 1019, 1067, 3, 480, 240, 0, 1020, 1067, 3, 536, 268, 0, 1021, 1067, 3, 558, 279, 0, 1022, 1067, 3, 282, 141, 0, 1023, 1067, 3, 548, 274, 0, 1024, 1067, 3, 74, 37, 0, 1025, 1067, 3, 418, 209, 0, 1026, 1067, 3, 308, 154, 0, 1027, 1067, 3, 532, 266, 0, 1028, 1067, 3, 520, 260, 0, 1029, 1067, 3, 328, 164, 0, 1030, 1067, 3, 334, 167, 0, 1031, 1067, 3, 348, 174, 0, 1032, 1067, 3, 900, 450, 0, 1033, 1067, 3, 236, 118, 0, 1034, 1067, 3, 358, 179, 0, 1035, 1067, 3, 538, 269, 0, 1036, 1067, 3, 464, 232, 0, 1037, 1067, 3, 194, 97, 0, 1038, 1067, 3, 478, 239, 0, 1039, 1067, 3, 550, 275, 0, 1040, 1067, 3, 460, 230, 0, 1041, 1067, 3, 526, 263, 0, 1042, 1067, 3, 306, 153, 0, 1043, 1067, 3, 428, 214, 0, 1044, 1067, 3, 408, 204, 0, 1045, 1067, 3, 406, 203, 0, 1046, 1067, 3, 410, 205, 0, 1047, 1067, 3, 432, 216, 0, 1048, 1067, 3, 336, 168, 0, 1049, 1067, 3, 350, 175, 0, 1050, 1067, 3, 456, 228, 0, 1051, 1067, 3, 326, 163, 0, 1052, 1067, 3, 560, 280, 0, 1053, 1067, 3, 468, 234, 0, 1054, 1067, 3, 320, 160, 0, 1055, 1067, 3, 466, 233, 0, 1056, 1067, 3, 552, 276, 0, 1057, 1067, 3, 504, 252, 0, 1058, 1067, 3, 60, 30, 0, 1059, 1067, 3, 36, 18, 0, 1060, 1067, 3, 68, 34, 0, 1061, 1067, 3, 476, 238, 0, 1062, 1064, 5, 581, 0, 0, 1063, 1065, 5, 582, 0, 0, 1064, 1063, 1, 0, 0, 0, 1064, 1065, 1, 0, 0, 0, 1065, 1067, 1, 0, 0, 0, 1066, 946, 1, 0, 0, 0, 1066, 947, 1, 0, 0, 0, 1066, 948, 1, 0, 0, 0, 1066, 949, 1, 0, 0, 0, 1066, 950, 1, 0, 0, 0, 1066, 951, 1, 0, 0, 0, 1066, 952, 1, 0, 0, 0, 1066, 953, 1, 0, 0, 0, 1066, 954, 1, 0, 0, 0, 1066, 955, 1, 0, 0, 0, 1066, 956, 1, 0, 0, 0, 1066, 957, 1, 0, 0, 0, 1066, 958, 1, 0, 0, 0, 1066, 959, 1, 0, 0, 0, 1066, 960, 1, 0, 0, 0, 1066, 961, 1, 0, 0, 0, 1066, 962, 1, 0, 0, 0, 1066, 963, 1, 0, 0, 0, 1066, 964, 1, 0, 0, 0, 1066, 965, 1, 0, 0, 0, 1066, 966, 1, 0, 0, 0, 1066, 967, 1, 0, 0, 0, 1066, 968, 1, 0, 0, 0, 1066, 969, 1, 0, 0, 0, 1066, 970, 1, 0, 0, 0, 1066, 971, 1, 0, 0, 0, 1066, 972, 1, 0, 0, 0, 1066, 973, 1, 0, 0, 0, 1066, 974, 1, 0, 0, 0, 1066, 975, 1, 0, 0, 0, 1066, 976, 1, 0, 0, 0, 1066, 977, 1, 0, 0, 0, 1066, 978, 1, 0, 0, 0, 1066, 979, 1, 0, 0, 0, 1066, 980, 1, 0, 0, 0, 1066, 981, 1, 0, 0, 0, 1066, 982, 1, 0, 0, 0, 1066, 983, 1, 0, 0, 0, 1066, 984, 1, 0, 0, 0, 1066, 985, 1, 0, 0, 0, 1066, 986, 1, 0, 0, 0, 1066, 987, 1, 0, 0, 0, 1066, 988, 1, 0, 0, 0, 1066, 989, 1, 0, 0, 0, 1066, 990, 1, 0, 0, 0, 1066, 991, 1, 0, 0, 0, 1066, 992, 1, 0, 0, 0, 1066, 993, 1, 0, 0, 0, 1066, 994, 1, 0, 0, 0, 1066, 995, 1, 0, 0, 0, 1066, 996, 1, 0, 0, 0, 1066, 997, 1, 0, 0, 0, 1066, 998, 1, 0, 0, 0, 1066, 999, 1, 0, 0, 0, 1066, 1000, 1, 0, 0, 0, 1066, 1001, 1, 0, 0, 0, 1066, 1002, 1, 0, 0, 0, 1066, 1003, 1, 0, 0, 0, 1066, 1004, 1, 0, 0, 0, 1066, 1005, 1, 0, 0, 0, 1066, 1006, 1, 0, 0, 0, 1066, 1007, 1, 0, 0, 0, 1066, 1008, 1, 0, 0, 0, 1066, 1009, 1, 0, 0, 0, 1066, 1010, 1, 0, 0, 0, 1066, 1011, 1, 0, 0, 0, 1066, 1012, 1, 0, 0, 0, 1066, 1013, 1, 0, 0, 0, 1066, 1014, 1, 0, 0, 0, 1066, 1015, 1, 0, 0, 0, 1066, 1016, 1, 0, 0, 0, 1066, 1017, 1, 0, 0, 0, 1066, 1018, 1, 0, 0, 0, 1066, 1019, 1, 0, 0, 0, 1066, 1020, 1, 0, 0, 0, 1066, 1021, 1, 0, 0, 0, 1066, 1022, 1, 0, 0, 0, 1066, 1023, 1, 0, 0, 0, 1066, 1024, 1, 0, 0, 0, 1066, 1025, 1, 0, 0, 0, 1066, 1026, 1, 0, 0, 0, 1066, 1027, 1, 0, 0, 0, 1066, 1028, 1, 0, 0, 0, 1066, 1029, 1, 0, 0, 0, 1066, 1030, 1, 0, 0, 0, 1066, 1031, 1, 0, 0, 0, 1066, 1032, 1, 0, 0, 0, 1066, 1033, 1, 0, 0, 0, 1066, 1034, 1, 0, 0, 0, 1066, 1035, 1, 0, 0, 0, 1066, 1036, 1, 0, 0, 0, 1066, 1037, 1, 0, 0, 0, 1066, 1038, 1, 0, 0, 0, 1066, 1039, 1, 0, 0, 0, 1066, 1040, 1, 0, 0, 0, 1066, 1041, 1, 0, 0, 0, 1066, 1042, 1, 0, 0, 0, 1066, 1043, 1, 0, 0, 0, 1066, 1044, 1, 0, 0, 0, 1066, 1045, 1, 0, 0, 0, 1066, 1046, 1, 0, 0, 0, 1066, 1047, 1, 0, 0, 0, 1066, 1048, 1, 0, 0, 0, 1066, 1049, 1, 0, 0, 0, 1066, 1050, 1, 0, 0, 0, 1066, 1051, 1, 0, 0, 0, 1066, 1052, 1, 0, 0, 0, 1066, 1053, 1, 0, 0, 0, 1066, 1054, 1, 0, 0, 0, 1066, 1055, 1, 0, 0, 0, 1066, 1056, 1, 0, 0, 0, 1066, 1057, 1, 0, 0, 0, 1066, 1058, 1, 0, 0, 0, 1066, 1059, 1, 0, 0, 0, 1066, 1060, 1, 0, 0, 0, 1066, 1061, 1, 0, 0, 0, 1066, 1062, 1, 0, 0, 0, 1067, 5, 1, 0, 0, 0, 1068, 1069, 5, 433, 0, 0, 1069, 1070, 3, 684, 342, 0, 1070, 7, 1, 0, 0, 0, 1071, 1072, 5, 46, 0, 0, 1072, 1073, 5, 318, 0, 0, 1073, 1075, 3, 814, 407, 0, 1074, 1076, 5, 105, 0, 0, 1075, 1074, 1, 0, 0, 0, 1075, 1076, 1, 0, 0, 0, 1076, 1080, 1, 0, 0, 0, 1077, 1079, 3, 12, 6, 0, 1078, 1077, 1, 0, 0, 0, 1079, 1082, 1, 0, 0, 0, 1080, 1078, 1, 0, 0, 0, 1080, 1081, 1, 0, 0, 0, 1081, 9, 1, 0, 0, 0, 1082, 1080, 1, 0, 0, 0, 1083, 1086, 5, 287, 0, 0, 1084, 1087, 3, 808, 404, 0, 1085, 1087, 5, 78, 0, 0, 1086, 1084, 1, 0, 0, 0, 1086, 1085, 1, 0, 0, 0, 1087, 1122, 1, 0, 0, 0, 1088, 1089, 7, 0, 0, 0, 1089, 1090, 5, 287, 0, 0, 1090, 1122, 3, 808, 404, 0, 1091, 1122, 5, 228, 0, 0, 1092, 1122, 5, 229, 0, 0, 1093, 1122, 5, 236, 0, 0, 1094, 1122, 5, 237, 0, 0, 1095, 1122, 5, 234, 0, 0, 1096, 1122, 5, 235, 0, 0, 1097, 1122, 5, 232, 0, 0, 1098, 1122, 5, 233, 0, 0, 1099, 1122, 5, 230, 0, 0, 1100, 1122, 5, 231, 0, 0, 1101, 1122, 5, 535, 0, 0, 1102, 1122, 5, 536, 0, 0, 1103, 1122, 5, 537, 0, 0, 1104, 1122, 5, 538, 0, 0, 1105, 1122, 5, 539, 0, 0, 1106, 1122, 5, 540, 0, 0, 1107, 1108, 5, 164, 0, 0, 1108, 1109, 5, 74, 0, 0, 1109, 1122, 3, 812, 406, 0, 1110, 1111, 5, 371, 0, 0, 1111, 1112, 5, 368, 0, 0, 1112, 1122, 3, 808, 404, 0, 1113, 1114, 5, 68, 0, 0, 1114, 1115, 7, 1, 0, 0, 1115, 1122, 3, 784, 392, 0, 1116, 1117, 7, 2, 0, 0, 1117, 1122, 3, 816, 408, 0, 1118, 1119, 5, 134, 0, 0, 1119, 1122, 3, 784, 392, 0, 1120, 1122, 3, 826, 413, 0, 1121, 1083, 1, 0, 0, 0, 1121, 1088, 1, 0, 0, 0, 1121, 1091, 1, 0, 0, 0, 1121, 1092, 1, 0, 0, 0, 1121, 1093, 1, 0, 0, 0, 1121, 1094, 1, 0, 0, 0, 1121, 1095, 1, 0, 0, 0, 1121, 1096, 1, 0, 0, 0, 1121, 1097, 1, 0, 0, 0, 1121, 1098, 1, 0, 0, 0, 1121, 1099, 1, 0, 0, 0, 1121, 1100, 1, 0, 0, 0, 1121, 1101, 1, 0, 0, 0, 1121, 1102, 1, 0, 0, 0, 1121, 1103, 1, 0, 0, 0, 1121, 1104, 1, 0, 0, 0, 1121, 1105, 1, 0, 0, 0, 1121, 1106, 1, 0, 0, 0, 1121, 1107, 1, 0, 0, 0, 1121, 1110, 1, 0, 0, 0, 1121, 1113, 1, 0, 0, 0, 1121, 1116, 1, 0, 0, 0, 1121, 1118, 1, 0, 0, 0, 1121, 1120, 1, 0, 0, 0, 1122, 11, 1, 0, 0, 0, 1123, 1132, 3, 10, 5, 0, 1124, 1125, 5, 348, 0, 0, 1125, 1132, 5, 571, 0, 0, 1126, 1127, 7, 3, 0, 0, 1127, 1132, 3, 816, 408, 0, 1128, 1129, 5, 68, 0, 0, 1129, 1130, 7, 1, 0, 0, 1130, 1132, 3, 816, 408, 0, 1131, 1123, 1, 0, 0, 0, 1131, 1124, 1, 0, 0, 0, 1131, 1126, 1, 0, 0, 0, 1131, 1128, 1, 0, 0, 0, 1132, 13, 1, 0, 0, 0, 1133, 1134, 5, 46, 0, 0, 1134, 1135, 5, 99, 0, 0, 1135, 1137, 3, 814, 407, 0, 1136, 1138, 5, 105, 0, 0, 1137, 1136, 1, 0, 0, 0, 1137, 1138, 1, 0, 0, 0, 1138, 1142, 1, 0, 0, 0, 1139, 1141, 3, 12, 6, 0, 1140, 1139, 1, 0, 0, 0, 1141, 1144, 1, 0, 0, 0, 1142, 1140, 1, 0, 0, 0, 1142, 1143, 1, 0, 0, 0, 1143, 15, 1, 0, 0, 0, 1144, 1142, 1, 0, 0, 0, 1145, 1146, 5, 138, 0, 0, 1146, 1147, 7, 2, 0, 0, 1147, 1149, 3, 814, 407, 0, 1148, 1150, 5, 105, 0, 0, 1149, 1148, 1, 0, 0, 0, 1149, 1150, 1, 0, 0, 0, 1150, 1154, 1, 0, 0, 0, 1151, 1153, 3, 10, 5, 0, 1152, 1151, 1, 0, 0, 0, 1153, 1156, 1, 0, 0, 0, 1154, 1152, 1, 0, 0, 0, 1154, 1155, 1, 0, 0, 0, 1155, 17, 1, 0, 0, 0, 1156, 1154, 1, 0, 0, 0, 1157, 1158, 5, 138, 0, 0, 1158, 1161, 7, 2, 0, 0, 1159, 1162, 5, 30, 0, 0, 1160, 1162, 3, 814, 407, 0, 1161, 1159, 1, 0, 0, 0, 1161, 1160, 1, 0, 0, 0, 1162, 1163, 1, 0, 0, 0, 1163, 1164, 5, 68, 0, 0, 1164, 1165, 5, 175, 0, 0, 1165, 1166, 3, 788, 394, 0, 1166, 1167, 3, 64, 32, 0, 1167, 19, 1, 0, 0, 0, 1168, 1169, 5, 138, 0, 0, 1169, 1170, 5, 442, 0, 0, 1170, 1172, 3, 794, 397, 0, 1171, 1173, 3, 368, 184, 0, 1172, 1171, 1, 0, 0, 0, 1172, 1173, 1, 0, 0, 0, 1173, 1174, 1, 0, 0, 0, 1174, 1175, 3, 22, 11, 0, 1175, 21, 1, 0, 0, 0, 1176, 1180, 3, 24, 12, 0, 1177, 1179, 3, 24, 12, 0, 1178, 1177, 1, 0, 0, 0, 1179, 1182, 1, 0, 0, 0, 1180, 1178, 1, 0, 0, 0, 1180, 1181, 1, 0, 0, 0, 1181, 1184, 1, 0, 0, 0, 1182, 1180, 1, 0, 0, 0, 1183, 1185, 5, 315, 0, 0, 1184, 1183, 1, 0, 0, 0, 1184, 1185, 1, 0, 0, 0, 1185, 1203, 1, 0, 0, 0, 1186, 1187, 5, 309, 0, 0, 1187, 1188, 5, 94, 0, 0, 1188, 1203, 3, 792, 396, 0, 1189, 1190, 5, 282, 0, 0, 1190, 1191, 5, 94, 0, 0, 1191, 1203, 3, 814, 407, 0, 1192, 1193, 5, 333, 0, 0, 1193, 1194, 5, 323, 0, 0, 1194, 1203, 3, 32, 16, 0, 1195, 1197, 5, 269, 0, 0, 1196, 1195, 1, 0, 0, 0, 1196, 1197, 1, 0, 0, 0, 1197, 1198, 1, 0, 0, 0, 1198, 1199, 5, 462, 0, 0, 1199, 1200, 5, 80, 0, 0, 1200, 1201, 5, 204, 0, 0, 1201, 1203, 3, 818, 409, 0, 1202, 1176, 1, 0, 0, 0, 1202, 1186, 1, 0, 0, 0, 1202, 1189, 1, 0, 0, 0, 1202, 1192, 1, 0, 0, 0, 1202, 1196, 1, 0, 0, 0, 1203, 23, 1, 0, 0, 0, 1204, 1247, 5, 222, 0, 0, 1205, 1247, 5, 338, 0, 0, 1206, 1247, 5, 377, 0, 0, 1207, 1209, 5, 77, 0, 0, 1208, 1207, 1, 0, 0, 0, 1208, 1209, 1, 0, 0, 0, 1209, 1210, 1, 0, 0, 0, 1210, 1247, 5, 250, 0, 0, 1211, 1213, 5, 205, 0, 0, 1212, 1211, 1, 0, 0, 0, 1212, 1213, 1, 0, 0, 0, 1213, 1214, 1, 0, 0, 0, 1214, 1215, 5, 327, 0, 0, 1215, 1222, 5, 243, 0, 0, 1216, 1218, 5, 205, 0, 0, 1217, 1216, 1, 0, 0, 0, 1217, 1218, 1, 0, 0, 0, 1218, 1219, 1, 0, 0, 0, 1219, 1220, 5, 327, 0, 0, 1220, 1222, 5, 181, 0, 0, 1221, 1212, 1, 0, 0, 0, 1221, 1217, 1, 0, 0, 0, 1222, 1247, 1, 0, 0, 0, 1223, 1224, 5, 460, 0, 0, 1224, 1247, 7, 4, 0, 0, 1225, 1226, 5, 170, 0, 0, 1226, 1247, 3, 824, 412, 0, 1227, 1228, 5, 320, 0, 0, 1228, 1247, 3, 818, 409, 0, 1229, 1230, 5, 333, 0, 0, 1230, 1231, 3, 818, 409, 0, 1231, 1234, 7, 5, 0, 0, 1232, 1235, 3, 818, 409, 0, 1233, 1235, 5, 53, 0, 0, 1234, 1232, 1, 0, 0, 0, 1234, 1233, 1, 0, 0, 0, 1235, 1247, 1, 0, 0, 0, 1236, 1237, 5, 333, 0, 0, 1237, 1238, 3, 818, 409, 0, 1238, 1239, 5, 64, 0, 0, 1239, 1240, 5, 434, 0, 0, 1240, 1247, 1, 0, 0, 0, 1241, 1244, 5, 313, 0, 0, 1242, 1245, 3, 818, 409, 0, 1243, 1245, 5, 30, 0, 0, 1244, 1242, 1, 0, 0, 0, 1244, 1243, 1, 0, 0, 0, 1245, 1247, 1, 0, 0, 0, 1246, 1204, 1, 0, 0, 0, 1246, 1205, 1, 0, 0, 0, 1246, 1206, 1, 0, 0, 0, 1246, 1208, 1, 0, 0, 0, 1246, 1221, 1, 0, 0, 0, 1246, 1223, 1, 0, 0, 0, 1246, 1225, 1, 0, 0, 0, 1246, 1227, 1, 0, 0, 0, 1246, 1229, 1, 0, 0, 0, 1246, 1236, 1, 0, 0, 0, 1246, 1241, 1, 0, 0, 0, 1247, 25, 1, 0, 0, 0, 1248, 1249, 5, 46, 0, 0, 1249, 1250, 5, 66, 0, 0, 1250, 1252, 3, 814, 407, 0, 1251, 1253, 5, 105, 0, 0, 1252, 1251, 1, 0, 0, 0, 1252, 1253, 1, 0, 0, 0, 1253, 1257, 1, 0, 0, 0, 1254, 1256, 3, 12, 6, 0, 1255, 1254, 1, 0, 0, 0, 1256, 1259, 1, 0, 0, 0, 1257, 1255, 1, 0, 0, 0, 1257, 1258, 1, 0, 0, 0, 1258, 27, 1, 0, 0, 0, 1259, 1257, 1, 0, 0, 0, 1260, 1261, 5, 138, 0, 0, 1261, 1262, 5, 66, 0, 0, 1262, 1263, 3, 814, 407, 0, 1263, 1264, 7, 6, 0, 0, 1264, 1265, 5, 99, 0, 0, 1265, 1266, 3, 816, 408, 0, 1266, 29, 1, 0, 0, 0, 1267, 1268, 5, 46, 0, 0, 1268, 1270, 5, 323, 0, 0, 1269, 1271, 3, 294, 147, 0, 1270, 1269, 1, 0, 0, 0, 1270, 1271, 1, 0, 0, 0, 1271, 1278, 1, 0, 0, 0, 1272, 1274, 3, 32, 16, 0, 1273, 1272, 1, 0, 0, 0, 1273, 1274, 1, 0, 0, 0, 1274, 1275, 1, 0, 0, 0, 1275, 1276, 5, 106, 0, 0, 1276, 1279, 3, 814, 407, 0, 1277, 1279, 3, 32, 16, 0, 1278, 1273, 1, 0, 0, 0, 1278, 1277, 1, 0, 0, 0, 1279, 1283, 1, 0, 0, 0, 1280, 1282, 3, 34, 17, 0, 1281, 1280, 1, 0, 0, 0, 1282, 1285, 1, 0, 0, 0, 1283, 1281, 1, 0, 0, 0, 1283, 1284, 1, 0, 0, 0, 1284, 31, 1, 0, 0, 0, 1285, 1283, 1, 0, 0, 0, 1286, 1287, 3, 316, 158, 0, 1287, 33, 1, 0, 0, 0, 1288, 1295, 3, 120, 60, 0, 1289, 1295, 3, 358, 179, 0, 1290, 1295, 3, 196, 98, 0, 1291, 1295, 3, 256, 128, 0, 1292, 1295, 3, 334, 167, 0, 1293, 1295, 3, 476, 238, 0, 1294, 1288, 1, 0, 0, 0, 1294, 1289, 1, 0, 0, 0, 1294, 1290, 1, 0, 0, 0, 1294, 1291, 1, 0, 0, 0, 1294, 1292, 1, 0, 0, 0, 1294, 1293, 1, 0, 0, 0, 1295, 35, 1, 0, 0, 0, 1296, 1298, 5, 333, 0, 0, 1297, 1299, 7, 7, 0, 0, 1298, 1297, 1, 0, 0, 0, 1298, 1299, 1, 0, 0, 0, 1299, 1300, 1, 0, 0, 0, 1300, 1301, 3, 38, 19, 0, 1301, 37, 1, 0, 0, 0, 1302, 1303, 5, 356, 0, 0, 1303, 1311, 3, 474, 237, 0, 1304, 1305, 5, 332, 0, 0, 1305, 1306, 5, 154, 0, 0, 1306, 1307, 5, 36, 0, 0, 1307, 1308, 5, 356, 0, 0, 1308, 1311, 3, 474, 237, 0, 1309, 1311, 3, 42, 21, 0, 1310, 1302, 1, 0, 0, 0, 1310, 1304, 1, 0, 0, 0, 1310, 1309, 1, 0, 0, 0, 1311, 39, 1, 0, 0, 0, 1312, 1315, 5, 30, 0, 0, 1313, 1315, 3, 44, 22, 0, 1314, 1312, 1, 0, 0, 0, 1314, 1313, 1, 0, 0, 0, 1315, 1317, 1, 0, 0, 0, 1316, 1318, 7, 5, 0, 0, 1317, 1316, 1, 0, 0, 0, 1317, 1318, 1, 0, 0, 0, 1318, 1321, 1, 0, 0, 0, 1319, 1322, 5, 53, 0, 0, 1320, 1322, 3, 46, 23, 0, 1321, 1319, 1, 0, 0, 0, 1321, 1320, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 41, 1, 0, 0, 0, 1323, 1324, 5, 418, 0, 0, 1324, 1325, 5, 386, 0, 0, 1325, 1352, 3, 56, 28, 0, 1326, 1327, 5, 152, 0, 0, 1327, 1352, 3, 808, 404, 0, 1328, 1329, 5, 323, 0, 0, 1329, 1352, 3, 790, 395, 0, 1330, 1333, 5, 267, 0, 0, 1331, 1334, 3, 808, 404, 0, 1332, 1334, 5, 53, 0, 0, 1333, 1331, 1, 0, 0, 0, 1333, 1332, 1, 0, 0, 0, 1333, 1334, 1, 0, 0, 0, 1334, 1352, 1, 0, 0, 0, 1335, 1336, 5, 318, 0, 0, 1336, 1352, 3, 58, 29, 0, 1337, 1338, 5, 332, 0, 0, 1338, 1339, 5, 106, 0, 0, 1339, 1352, 3, 58, 29, 0, 1340, 1341, 5, 383, 0, 0, 1341, 1342, 5, 279, 0, 0, 1342, 1352, 3, 696, 348, 0, 1343, 1344, 5, 356, 0, 0, 1344, 1345, 5, 337, 0, 0, 1345, 1352, 3, 808, 404, 0, 1346, 1347, 3, 44, 22, 0, 1347, 1348, 5, 64, 0, 0, 1348, 1349, 5, 434, 0, 0, 1349, 1352, 1, 0, 0, 0, 1350, 1352, 3, 40, 20, 0, 1351, 1323, 1, 0, 0, 0, 1351, 1326, 1, 0, 0, 0, 1351, 1328, 1, 0, 0, 0, 1351, 1330, 1, 0, 0, 0, 1351, 1335, 1, 0, 0, 0, 1351, 1337, 1, 0, 0, 0, 1351, 1340, 1, 0, 0, 0, 1351, 1343, 1, 0, 0, 0, 1351, 1346, 1, 0, 0, 0, 1351, 1350, 1, 0, 0, 0, 1352, 43, 1, 0, 0, 0, 1353, 1358, 3, 818, 409, 0, 1354, 1355, 5, 11, 0, 0, 1355, 1357, 3, 818, 409, 0, 1356, 1354, 1, 0, 0, 0, 1357, 1360, 1, 0, 0, 0, 1358, 1356, 1, 0, 0, 0, 1358, 1359, 1, 0, 0, 0, 1359, 45, 1, 0, 0, 0, 1360, 1358, 1, 0, 0, 0, 1361, 1366, 3, 48, 24, 0, 1362, 1363, 5, 6, 0, 0, 1363, 1365, 3, 48, 24, 0, 1364, 1362, 1, 0, 0, 0, 1365, 1368, 1, 0, 0, 0, 1366, 1364, 1, 0, 0, 0, 1366, 1367, 1, 0, 0, 0, 1367, 47, 1, 0, 0, 0, 1368, 1366, 1, 0, 0, 0, 1369, 1372, 3, 54, 27, 0, 1370, 1372, 3, 202, 101, 0, 1371, 1369, 1, 0, 0, 0, 1371, 1370, 1, 0, 0, 0, 1372, 49, 1, 0, 0, 0, 1373, 1374, 5, 300, 0, 0, 1374, 1379, 7, 8, 0, 0, 1375, 1376, 5, 310, 0, 0, 1376, 1379, 5, 300, 0, 0, 1377, 1379, 5, 330, 0, 0, 1378, 1373, 1, 0, 0, 0, 1378, 1375, 1, 0, 0, 0, 1378, 1377, 1, 0, 0, 0, 1379, 51, 1, 0, 0, 0, 1380, 1387, 5, 96, 0, 0, 1381, 1387, 5, 60, 0, 0, 1382, 1387, 5, 80, 0, 0, 1383, 1387, 3, 800, 400, 0, 1384, 1387, 3, 832, 416, 0, 1385, 1387, 3, 808, 404, 0, 1386, 1380, 1, 0, 0, 0, 1386, 1381, 1, 0, 0, 0, 1386, 1382, 1, 0, 0, 0, 1386, 1383, 1, 0, 0, 0, 1386, 1384, 1, 0, 0, 0, 1386, 1385, 1, 0, 0, 0, 1387, 53, 1, 0, 0, 0, 1388, 1393, 5, 96, 0, 0, 1389, 1393, 5, 60, 0, 0, 1390, 1393, 5, 80, 0, 0, 1391, 1393, 3, 58, 29, 0, 1392, 1388, 1, 0, 0, 0, 1392, 1389, 1, 0, 0, 0, 1392, 1390, 1, 0, 0, 0, 1392, 1391, 1, 0, 0, 0, 1393, 55, 1, 0, 0, 0, 1394, 1409, 3, 808, 404, 0, 1395, 1409, 5, 53, 0, 0, 1396, 1409, 3, 826, 413, 0, 1397, 1398, 5, 403, 0, 0, 1398, 1400, 3, 808, 404, 0, 1399, 1401, 3, 668, 334, 0, 1400, 1399, 1, 0, 0, 0, 1400, 1401, 1, 0, 0, 0, 1401, 1409, 1, 0, 0, 0, 1402, 1403, 5, 403, 0, 0, 1403, 1404, 3, 660, 330, 0, 1404, 1405, 3, 808, 404, 0, 1405, 1409, 1, 0, 0, 0, 1406, 1409, 3, 202, 101, 0, 1407, 1409, 5, 254, 0, 0, 1408, 1394, 1, 0, 0, 0, 1408, 1395, 1, 0, 0, 0, 1408, 1396, 1, 0, 0, 0, 1408, 1397, 1, 0, 0, 0, 1408, 1402, 1, 0, 0, 0, 1408, 1406, 1, 0, 0, 0, 1408, 1407, 1, 0, 0, 0, 1409, 57, 1, 0, 0, 0, 1410, 1413, 3, 822, 411, 0, 1411, 1413, 3, 808, 404, 0, 1412, 1410, 1, 0, 0, 0, 1412, 1411, 1, 0, 0, 0, 1413, 59, 1, 0, 0, 0, 1414, 1415, 5, 313, 0, 0, 1415, 1416, 3, 62, 31, 0, 1416, 61, 1, 0, 0, 0, 1417, 1418, 5, 418, 0, 0, 1418, 1427, 5, 386, 0, 0, 1419, 1420, 5, 356, 0, 0, 1420, 1421, 5, 244, 0, 0, 1421, 1427, 5, 251, 0, 0, 1422, 1423, 5, 332, 0, 0, 1423, 1427, 5, 106, 0, 0, 1424, 1427, 5, 30, 0, 0, 1425, 1427, 3, 44, 22, 0, 1426, 1417, 1, 0, 0, 0, 1426, 1419, 1, 0, 0, 0, 1426, 1422, 1, 0, 0, 0, 1426, 1424, 1, 0, 0, 0, 1426, 1425, 1, 0, 0, 0, 1427, 63, 1, 0, 0, 0, 1428, 1429, 5, 333, 0, 0, 1429, 1432, 3, 38, 19, 0, 1430, 1432, 3, 60, 30, 0, 1431, 1428, 1, 0, 0, 0, 1431, 1430, 1, 0, 0, 0, 1432, 65, 1, 0, 0, 0, 1433, 1434, 5, 333, 0, 0, 1434, 1437, 3, 42, 21, 0, 1435, 1437, 3, 60, 30, 0, 1436, 1433, 1, 0, 0, 0, 1436, 1435, 1, 0, 0, 0, 1437, 67, 1, 0, 0, 0, 1438, 1448, 5, 335, 0, 0, 1439, 1449, 3, 44, 22, 0, 1440, 1441, 5, 418, 0, 0, 1441, 1449, 5, 386, 0, 0, 1442, 1443, 5, 356, 0, 0, 1443, 1444, 5, 244, 0, 0, 1444, 1449, 5, 251, 0, 0, 1445, 1446, 5, 332, 0, 0, 1446, 1449, 5, 106, 0, 0, 1447, 1449, 5, 30, 0, 0, 1448, 1439, 1, 0, 0, 0, 1448, 1440, 1, 0, 0, 0, 1448, 1442, 1, 0, 0, 0, 1448, 1445, 1, 0, 0, 0, 1448, 1447, 1, 0, 0, 0, 1449, 69, 1, 0, 0, 0, 1450, 1451, 5, 333, 0, 0, 1451, 1454, 5, 165, 0, 0, 1452, 1455, 5, 30, 0, 0, 1453, 1455, 3, 760, 380, 0, 1454, 1452, 1, 0, 0, 0, 1454, 1453, 1, 0, 0, 0, 1455, 1456, 1, 0, 0, 0, 1456, 1457, 7, 9, 0, 0, 1457, 71, 1, 0, 0, 0, 1458, 1459, 5, 155, 0, 0, 1459, 73, 1, 0, 0, 0, 1460, 1461, 5, 187, 0, 0, 1461, 1462, 7, 10, 0, 0, 1462, 75, 1, 0, 0, 0, 1463, 1464, 5, 138, 0, 0, 1464, 1466, 5, 92, 0, 0, 1465, 1467, 3, 422, 211, 0, 1466, 1465, 1, 0, 0, 0, 1466, 1467, 1, 0, 0, 0, 1467, 1468, 1, 0, 0, 0, 1468, 1471, 3, 624, 312, 0, 1469, 1472, 3, 78, 39, 0, 1470, 1472, 3, 88, 44, 0, 1471, 1469, 1, 0, 0, 0, 1471, 1470, 1, 0, 0, 0, 1472, 1585, 1, 0, 0, 0, 1473, 1474, 5, 138, 0, 0, 1474, 1475, 5, 92, 0, 0, 1475, 1476, 5, 30, 0, 0, 1476, 1477, 5, 68, 0, 0, 1477, 1481, 3, 176, 88, 0, 1478, 1479, 5, 281, 0, 0, 1479, 1480, 5, 147, 0, 0, 1480, 1482, 3, 816, 408, 0, 1481, 1478, 1, 0, 0, 0, 1481, 1482, 1, 0, 0, 0, 1482, 1483, 1, 0, 0, 0, 1483, 1484, 5, 333, 0, 0, 1484, 1485, 5, 351, 0, 0, 1485, 1487, 3, 768, 384, 0, 1486, 1488, 5, 272, 0, 0, 1487, 1486, 1, 0, 0, 0, 1487, 1488, 1, 0, 0, 0, 1488, 1585, 1, 0, 0, 0, 1489, 1490, 5, 138, 0, 0, 1490, 1492, 5, 92, 0, 0, 1491, 1493, 3, 422, 211, 0, 1492, 1491, 1, 0, 0, 0, 1492, 1493, 1, 0, 0, 0, 1493, 1494, 1, 0, 0, 0, 1494, 1495, 3, 774, 387, 0, 1495, 1500, 3, 90, 45, 0, 1496, 1497, 5, 62, 0, 0, 1497, 1498, 5, 422, 0, 0, 1498, 1501, 3, 80, 40, 0, 1499, 1501, 5, 53, 0, 0, 1500, 1496, 1, 0, 0, 0, 1500, 1499, 1, 0, 0, 0, 1501, 1585, 1, 0, 0, 0, 1502, 1503, 5, 138, 0, 0, 1503, 1505, 5, 92, 0, 0, 1504, 1506, 3, 422, 211, 0, 1505, 1504, 1, 0, 0, 0, 1505, 1506, 1, 0, 0, 0, 1506, 1507, 1, 0, 0, 0, 1507, 1508, 3, 774, 387, 0, 1508, 1509, 5, 436, 0, 0, 1509, 1510, 5, 285, 0, 0, 1510, 1512, 3, 780, 390, 0, 1511, 1513, 7, 11, 0, 0, 1512, 1511, 1, 0, 0, 0, 1512, 1513, 1, 0, 0, 0, 1513, 1585, 1, 0, 0, 0, 1514, 1515, 5, 138, 0, 0, 1515, 1517, 5, 226, 0, 0, 1516, 1518, 3, 422, 211, 0, 1517, 1516, 1, 0, 0, 0, 1517, 1518, 1, 0, 0, 0, 1518, 1519, 1, 0, 0, 0, 1519, 1522, 3, 780, 390, 0, 1520, 1523, 3, 78, 39, 0, 1521, 1523, 3, 90, 45, 0, 1522, 1520, 1, 0, 0, 0, 1522, 1521, 1, 0, 0, 0, 1523, 1585, 1, 0, 0, 0, 1524, 1525, 5, 138, 0, 0, 1525, 1526, 5, 226, 0, 0, 1526, 1527, 5, 30, 0, 0, 1527, 1528, 5, 68, 0, 0, 1528, 1532, 3, 176, 88, 0, 1529, 1530, 5, 281, 0, 0, 1530, 1531, 5, 147, 0, 0, 1531, 1533, 3, 816, 408, 0, 1532, 1529, 1, 0, 0, 0, 1532, 1533, 1, 0, 0, 0, 1533, 1534, 1, 0, 0, 0, 1534, 1535, 5, 333, 0, 0, 1535, 1537, 3, 176, 88, 0, 1536, 1538, 5, 272, 0, 0, 1537, 1536, 1, 0, 0, 0, 1537, 1538, 1, 0, 0, 0, 1538, 1585, 1, 0, 0, 0, 1539, 1540, 5, 138, 0, 0, 1540, 1542, 5, 328, 0, 0, 1541, 1543, 3, 422, 211, 0, 1542, 1541, 1, 0, 0, 0, 1542, 1543, 1, 0, 0, 0, 1543, 1544, 1, 0, 0, 0, 1544, 1545, 3, 780, 390, 0, 1545, 1546, 3, 78, 39, 0, 1546, 1585, 1, 0, 0, 0, 1547, 1549, 5, 138, 0, 0, 1548, 1550, 5, 259, 0, 0, 1549, 1548, 1, 0, 0, 0, 1549, 1550, 1, 0, 0, 0, 1550, 1551, 1, 0, 0, 0, 1551, 1553, 5, 376, 0, 0, 1552, 1554, 3, 422, 211, 0, 1553, 1552, 1, 0, 0, 0, 1553, 1554, 1, 0, 0, 0, 1554, 1555, 1, 0, 0, 0, 1555, 1556, 3, 778, 389, 0, 1556, 1557, 3, 78, 39, 0, 1557, 1585, 1, 0, 0, 0, 1558, 1559, 5, 138, 0, 0, 1559, 1560, 5, 259, 0, 0, 1560, 1561, 5, 376, 0, 0, 1561, 1562, 5, 30, 0, 0, 1562, 1563, 5, 68, 0, 0, 1563, 1567, 3, 176, 88, 0, 1564, 1565, 5, 281, 0, 0, 1565, 1566, 5, 147, 0, 0, 1566, 1568, 3, 816, 408, 0, 1567, 1564, 1, 0, 0, 0, 1567, 1568, 1, 0, 0, 0, 1568, 1569, 1, 0, 0, 0, 1569, 1570, 5, 333, 0, 0, 1570, 1571, 5, 351, 0, 0, 1571, 1573, 3, 768, 384, 0, 1572, 1574, 5, 272, 0, 0, 1573, 1572, 1, 0, 0, 0, 1573, 1574, 1, 0, 0, 0, 1574, 1585, 1, 0, 0, 0, 1575, 1576, 5, 138, 0, 0, 1576, 1577, 5, 63, 0, 0, 1577, 1579, 5, 92, 0, 0, 1578, 1580, 3, 422, 211, 0, 1579, 1578, 1, 0, 0, 0, 1579, 1580, 1, 0, 0, 0, 1580, 1581, 1, 0, 0, 0, 1581, 1582, 3, 624, 312, 0, 1582, 1583, 3, 78, 39, 0, 1583, 1585, 1, 0, 0, 0, 1584, 1463, 1, 0, 0, 0, 1584, 1473, 1, 0, 0, 0, 1584, 1489, 1, 0, 0, 0, 1584, 1502, 1, 0, 0, 0, 1584, 1514, 1, 0, 0, 0, 1584, 1524, 1, 0, 0, 0, 1584, 1539, 1, 0, 0, 0, 1584, 1547, 1, 0, 0, 0, 1584, 1558, 1, 0, 0, 0, 1584, 1575, 1, 0, 0, 0, 1585, 77, 1, 0, 0, 0, 1586, 1591, 3, 92, 46, 0, 1587, 1588, 5, 6, 0, 0, 1588, 1590, 3, 92, 46, 0, 1589, 1587, 1, 0, 0, 0, 1590, 1593, 1, 0, 0, 0, 1591, 1589, 1, 0, 0, 0, 1591, 1592, 1, 0, 0, 0, 1592, 79, 1, 0, 0, 0, 1593, 1591, 1, 0, 0, 0, 1594, 1595, 5, 68, 0, 0, 1595, 1604, 3, 534, 267, 0, 1596, 1597, 5, 64, 0, 0, 1597, 1598, 3, 82, 41, 0, 1598, 1599, 5, 94, 0, 0, 1599, 1600, 3, 82, 41, 0, 1600, 1604, 1, 0, 0, 0, 1601, 1602, 5, 105, 0, 0, 1602, 1604, 3, 86, 43, 0, 1603, 1594, 1, 0, 0, 0, 1603, 1596, 1, 0, 0, 0, 1603, 1601, 1, 0, 0, 0, 1604, 81, 1, 0, 0, 0, 1605, 1606, 5, 2, 0, 0, 1606, 1611, 3, 84, 42, 0, 1607, 1608, 5, 6, 0, 0, 1608, 1610, 3, 84, 42, 0, 1609, 1607, 1, 0, 0, 0, 1610, 1613, 1, 0, 0, 0, 1611, 1609, 1, 0, 0, 0, 1611, 1612, 1, 0, 0, 0, 1612, 1614, 1, 0, 0, 0, 1613, 1611, 1, 0, 0, 0, 1614, 1615, 5, 3, 0, 0, 1615, 83, 1, 0, 0, 0, 1616, 1620, 3, 534, 267, 0, 1617, 1620, 5, 262, 0, 0, 1618, 1620, 5, 260, 0, 0, 1619, 1616, 1, 0, 0, 0, 1619, 1617, 1, 0, 0, 0, 1619, 1618, 1, 0, 0, 0, 1620, 85, 1, 0, 0, 0, 1621, 1622, 5, 2, 0, 0, 1622, 1623, 5, 533, 0, 0, 1623, 1624, 3, 202, 101, 0, 1624, 1625, 5, 6, 0, 0, 1625, 1626, 5, 534, 0, 0, 1626, 1627, 3, 202, 101, 0, 1627, 1628, 5, 3, 0, 0, 1628, 87, 1, 0, 0, 0, 1629, 1630, 3, 90, 45, 0, 1630, 1631, 3, 106, 53, 0, 1631, 1636, 1, 0, 0, 0, 1632, 1633, 5, 436, 0, 0, 1633, 1634, 5, 285, 0, 0, 1634, 1636, 3, 780, 390, 0, 1635, 1629, 1, 0, 0, 0, 1635, 1632, 1, 0, 0, 0, 1636, 89, 1, 0, 0, 0, 1637, 1638, 5, 435, 0, 0, 1638, 1639, 5, 285, 0, 0, 1639, 1640, 3, 780, 390, 0, 1640, 91, 1, 0, 0, 0, 1641, 1644, 5, 133, 0, 0, 1642, 1643, 5, 45, 0, 0, 1643, 1645, 3, 818, 409, 0, 1644, 1642, 1, 0, 0, 0, 1644, 1645, 1, 0, 0, 0, 1645, 1646, 1, 0, 0, 0, 1646, 1875, 3, 142, 71, 0, 1647, 1648, 5, 138, 0, 0, 1648, 1649, 5, 45, 0, 0, 1649, 1653, 3, 818, 409, 0, 1650, 1652, 3, 272, 136, 0, 1651, 1650, 1, 0, 0, 0, 1652, 1655, 1, 0, 0, 0, 1653, 1651, 1, 0, 0, 0, 1653, 1654, 1, 0, 0, 0, 1654, 1875, 1, 0, 0, 0, 1655, 1653, 1, 0, 0, 0, 1656, 1657, 5, 372, 0, 0, 1657, 1658, 5, 45, 0, 0, 1658, 1875, 3, 818, 409, 0, 1659, 1660, 5, 191, 0, 0, 1660, 1662, 5, 45, 0, 0, 1661, 1663, 3, 422, 211, 0, 1662, 1661, 1, 0, 0, 0, 1662, 1663, 1, 0, 0, 0, 1663, 1664, 1, 0, 0, 0, 1664, 1666, 3, 818, 409, 0, 1665, 1667, 3, 96, 48, 0, 1666, 1665, 1, 0, 0, 0, 1666, 1667, 1, 0, 0, 0, 1667, 1875, 1, 0, 0, 0, 1668, 1669, 5, 333, 0, 0, 1669, 1670, 5, 379, 0, 0, 1670, 1875, 7, 12, 0, 0, 1671, 1672, 5, 158, 0, 0, 1672, 1673, 5, 80, 0, 0, 1673, 1875, 3, 818, 409, 0, 1674, 1675, 5, 333, 0, 0, 1675, 1875, 7, 13, 0, 0, 1676, 1678, 5, 193, 0, 0, 1677, 1679, 7, 14, 0, 0, 1678, 1677, 1, 0, 0, 0, 1678, 1679, 1, 0, 0, 0, 1679, 1680, 1, 0, 0, 0, 1680, 1875, 5, 357, 0, 0, 1681, 1682, 5, 186, 0, 0, 1682, 1686, 5, 357, 0, 0, 1683, 1687, 5, 30, 0, 0, 1684, 1687, 5, 99, 0, 0, 1685, 1687, 3, 818, 409, 0, 1686, 1683, 1, 0, 0, 0, 1686, 1684, 1, 0, 0, 0, 1686, 1685, 1, 0, 0, 0, 1687, 1875, 1, 0, 0, 0, 1688, 1689, 5, 193, 0, 0, 1689, 1690, 7, 14, 0, 0, 1690, 1691, 5, 321, 0, 0, 1691, 1875, 3, 818, 409, 0, 1692, 1693, 5, 186, 0, 0, 1693, 1694, 5, 321, 0, 0, 1694, 1875, 3, 818, 409, 0, 1695, 1697, 5, 269, 0, 0, 1696, 1695, 1, 0, 0, 0, 1696, 1697, 1, 0, 0, 0, 1697, 1698, 1, 0, 0, 0, 1698, 1699, 5, 228, 0, 0, 1699, 1875, 3, 780, 390, 0, 1700, 1701, 5, 275, 0, 0, 1701, 1875, 3, 316, 158, 0, 1702, 1703, 5, 77, 0, 0, 1703, 1875, 5, 275, 0, 0, 1704, 1705, 5, 282, 0, 0, 1705, 1706, 5, 94, 0, 0, 1706, 1875, 3, 814, 407, 0, 1707, 1708, 5, 333, 0, 0, 1708, 1709, 5, 351, 0, 0, 1709, 1875, 3, 768, 384, 0, 1710, 1711, 5, 312, 0, 0, 1711, 1716, 5, 219, 0, 0, 1712, 1717, 5, 270, 0, 0, 1713, 1717, 5, 113, 0, 0, 1714, 1717, 5, 53, 0, 0, 1715, 1717, 3, 180, 90, 0, 1716, 1712, 1, 0, 0, 0, 1716, 1713, 1, 0, 0, 0, 1716, 1714, 1, 0, 0, 0, 1716, 1715, 1, 0, 0, 0, 1717, 1875, 1, 0, 0, 0, 1718, 1725, 5, 193, 0, 0, 1719, 1725, 5, 186, 0, 0, 1720, 1722, 5, 269, 0, 0, 1721, 1720, 1, 0, 0, 0, 1721, 1722, 1, 0, 0, 0, 1722, 1723, 1, 0, 0, 0, 1723, 1725, 5, 209, 0, 0, 1724, 1718, 1, 0, 0, 0, 1724, 1719, 1, 0, 0, 0, 1724, 1721, 1, 0, 0, 0, 1725, 1726, 1, 0, 0, 0, 1726, 1727, 5, 414, 0, 0, 1727, 1728, 5, 251, 0, 0, 1728, 1875, 5, 327, 0, 0, 1729, 1731, 5, 191, 0, 0, 1730, 1732, 5, 44, 0, 0, 1731, 1730, 1, 0, 0, 0, 1731, 1732, 1, 0, 0, 0, 1732, 1734, 1, 0, 0, 0, 1733, 1735, 3, 422, 211, 0, 1734, 1733, 1, 0, 0, 0, 1734, 1735, 1, 0, 0, 0, 1735, 1736, 1, 0, 0, 0, 1736, 1738, 3, 800, 400, 0, 1737, 1739, 3, 96, 48, 0, 1738, 1737, 1, 0, 0, 0, 1738, 1739, 1, 0, 0, 0, 1739, 1875, 1, 0, 0, 0, 1740, 1742, 5, 133, 0, 0, 1741, 1743, 5, 44, 0, 0, 1742, 1741, 1, 0, 0, 0, 1742, 1743, 1, 0, 0, 0, 1743, 1745, 1, 0, 0, 0, 1744, 1746, 3, 294, 147, 0, 1745, 1744, 1, 0, 0, 0, 1745, 1746, 1, 0, 0, 0, 1746, 1747, 1, 0, 0, 0, 1747, 1875, 3, 132, 66, 0, 1748, 1750, 5, 138, 0, 0, 1749, 1751, 5, 44, 0, 0, 1750, 1749, 1, 0, 0, 0, 1750, 1751, 1, 0, 0, 0, 1751, 1752, 1, 0, 0, 0, 1752, 1755, 3, 800, 400, 0, 1753, 1756, 3, 94, 47, 0, 1754, 1756, 3, 222, 111, 0, 1755, 1753, 1, 0, 0, 0, 1755, 1754, 1, 0, 0, 0, 1756, 1875, 1, 0, 0, 0, 1757, 1759, 5, 138, 0, 0, 1758, 1760, 5, 44, 0, 0, 1759, 1758, 1, 0, 0, 0, 1759, 1760, 1, 0, 0, 0, 1760, 1761, 1, 0, 0, 0, 1761, 1762, 3, 800, 400, 0, 1762, 1763, 7, 15, 0, 0, 1763, 1764, 5, 77, 0, 0, 1764, 1765, 5, 78, 0, 0, 1765, 1875, 1, 0, 0, 0, 1766, 1768, 5, 138, 0, 0, 1767, 1769, 5, 44, 0, 0, 1768, 1767, 1, 0, 0, 0, 1768, 1769, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1770, 1771, 3, 800, 400, 0, 1771, 1772, 5, 191, 0, 0, 1772, 1774, 5, 437, 0, 0, 1773, 1775, 3, 422, 211, 0, 1774, 1773, 1, 0, 0, 0, 1774, 1775, 1, 0, 0, 0, 1775, 1875, 1, 0, 0, 0, 1776, 1778, 5, 138, 0, 0, 1777, 1779, 5, 44, 0, 0, 1778, 1777, 1, 0, 0, 0, 1778, 1779, 1, 0, 0, 0, 1779, 1780, 1, 0, 0, 0, 1780, 1781, 3, 800, 400, 0, 1781, 1782, 5, 333, 0, 0, 1782, 1783, 5, 342, 0, 0, 1783, 1784, 3, 812, 406, 0, 1784, 1875, 1, 0, 0, 0, 1785, 1787, 5, 138, 0, 0, 1786, 1788, 5, 44, 0, 0, 1787, 1786, 1, 0, 0, 0, 1787, 1788, 1, 0, 0, 0, 1788, 1789, 1, 0, 0, 0, 1789, 1791, 3, 800, 400, 0, 1790, 1785, 1, 0, 0, 0, 1790, 1791, 1, 0, 0, 0, 1791, 1792, 1, 0, 0, 0, 1792, 1793, 7, 16, 0, 0, 1793, 1875, 3, 100, 50, 0, 1794, 1796, 5, 138, 0, 0, 1795, 1797, 5, 44, 0, 0, 1796, 1795, 1, 0, 0, 0, 1796, 1797, 1, 0, 0, 0, 1797, 1798, 1, 0, 0, 0, 1798, 1799, 3, 800, 400, 0, 1799, 1800, 5, 333, 0, 0, 1800, 1801, 5, 345, 0, 0, 1801, 1802, 3, 818, 409, 0, 1802, 1875, 1, 0, 0, 0, 1803, 1805, 5, 138, 0, 0, 1804, 1806, 5, 44, 0, 0, 1805, 1804, 1, 0, 0, 0, 1805, 1806, 1, 0, 0, 0, 1806, 1807, 1, 0, 0, 0, 1807, 1808, 3, 800, 400, 0, 1808, 1809, 5, 133, 0, 0, 1809, 1810, 5, 438, 0, 0, 1810, 1811, 3, 138, 69, 0, 1811, 1812, 5, 36, 0, 0, 1812, 1821, 5, 219, 0, 0, 1813, 1815, 5, 2, 0, 0, 1814, 1816, 3, 200, 100, 0, 1815, 1814, 1, 0, 0, 0, 1816, 1817, 1, 0, 0, 0, 1817, 1815, 1, 0, 0, 0, 1817, 1818, 1, 0, 0, 0, 1818, 1819, 1, 0, 0, 0, 1819, 1820, 5, 3, 0, 0, 1820, 1822, 1, 0, 0, 0, 1821, 1813, 1, 0, 0, 0, 1821, 1822, 1, 0, 0, 0, 1822, 1875, 1, 0, 0, 0, 1823, 1825, 5, 138, 0, 0, 1824, 1826, 5, 44, 0, 0, 1825, 1824, 1, 0, 0, 0, 1825, 1826, 1, 0, 0, 0, 1826, 1827, 1, 0, 0, 0, 1827, 1841, 3, 800, 400, 0, 1828, 1833, 5, 314, 0, 0, 1829, 1831, 5, 105, 0, 0, 1830, 1829, 1, 0, 0, 0, 1830, 1831, 1, 0, 0, 0, 1831, 1832, 1, 0, 0, 0, 1832, 1834, 3, 202, 101, 0, 1833, 1830, 1, 0, 0, 0, 1833, 1834, 1, 0, 0, 0, 1834, 1842, 1, 0, 0, 0, 1835, 1839, 5, 333, 0, 0, 1836, 1840, 3, 200, 100, 0, 1837, 1838, 5, 438, 0, 0, 1838, 1840, 3, 138, 69, 0, 1839, 1836, 1, 0, 0, 0, 1839, 1837, 1, 0, 0, 0, 1840, 1842, 1, 0, 0, 0, 1841, 1828, 1, 0, 0, 0, 1841, 1835, 1, 0, 0, 0, 1842, 1843, 1, 0, 0, 0, 1843, 1841, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1875, 1, 0, 0, 0, 1845, 1847, 5, 138, 0, 0, 1846, 1848, 5, 44, 0, 0, 1847, 1846, 1, 0, 0, 0, 1847, 1848, 1, 0, 0, 0, 1848, 1849, 1, 0, 0, 0, 1849, 1850, 3, 800, 400, 0, 1850, 1851, 5, 191, 0, 0, 1851, 1853, 5, 219, 0, 0, 1852, 1854, 3, 422, 211, 0, 1853, 1852, 1, 0, 0, 0, 1853, 1854, 1, 0, 0, 0, 1854, 1875, 1, 0, 0, 0, 1855, 1857, 5, 138, 0, 0, 1856, 1858, 5, 44, 0, 0, 1857, 1856, 1, 0, 0, 0, 1857, 1858, 1, 0, 0, 0, 1858, 1859, 1, 0, 0, 0, 1859, 1862, 3, 800, 400, 0, 1860, 1861, 5, 333, 0, 0, 1861, 1863, 5, 174, 0, 0, 1862, 1860, 1, 0, 0, 0, 1862, 1863, 1, 0, 0, 0, 1863, 1864, 1, 0, 0, 0, 1864, 1865, 5, 360, 0, 0, 1865, 1867, 3, 652, 326, 0, 1866, 1868, 3, 98, 49, 0, 1867, 1866, 1, 0, 0, 0, 1867, 1868, 1, 0, 0, 0, 1868, 1871, 1, 0, 0, 0, 1869, 1870, 5, 100, 0, 0, 1870, 1872, 3, 674, 337, 0, 1871, 1869, 1, 0, 0, 0, 1871, 1872, 1, 0, 0, 0, 1872, 1875, 1, 0, 0, 0, 1873, 1875, 3, 222, 111, 0, 1874, 1641, 1, 0, 0, 0, 1874, 1647, 1, 0, 0, 0, 1874, 1656, 1, 0, 0, 0, 1874, 1659, 1, 0, 0, 0, 1874, 1668, 1, 0, 0, 0, 1874, 1671, 1, 0, 0, 0, 1874, 1674, 1, 0, 0, 0, 1874, 1676, 1, 0, 0, 0, 1874, 1681, 1, 0, 0, 0, 1874, 1688, 1, 0, 0, 0, 1874, 1692, 1, 0, 0, 0, 1874, 1696, 1, 0, 0, 0, 1874, 1700, 1, 0, 0, 0, 1874, 1702, 1, 0, 0, 0, 1874, 1704, 1, 0, 0, 0, 1874, 1707, 1, 0, 0, 0, 1874, 1710, 1, 0, 0, 0, 1874, 1724, 1, 0, 0, 0, 1874, 1729, 1, 0, 0, 0, 1874, 1740, 1, 0, 0, 0, 1874, 1748, 1, 0, 0, 0, 1874, 1757, 1, 0, 0, 0, 1874, 1766, 1, 0, 0, 0, 1874, 1776, 1, 0, 0, 0, 1874, 1790, 1, 0, 0, 0, 1874, 1794, 1, 0, 0, 0, 1874, 1803, 1, 0, 0, 0, 1874, 1823, 1, 0, 0, 0, 1874, 1845, 1, 0, 0, 0, 1874, 1855, 1, 0, 0, 0, 1874, 1873, 1, 0, 0, 0, 1875, 93, 1, 0, 0, 0, 1876, 1877, 5, 333, 0, 0, 1877, 1878, 5, 53, 0, 0, 1878, 1882, 3, 674, 337, 0, 1879, 1880, 5, 191, 0, 0, 1880, 1882, 5, 53, 0, 0, 1881, 1876, 1, 0, 0, 0, 1881, 1879, 1, 0, 0, 0, 1882, 95, 1, 0, 0, 0, 1883, 1884, 7, 17, 0, 0, 1884, 97, 1, 0, 0, 0, 1885, 1886, 5, 43, 0, 0, 1886, 1887, 3, 316, 158, 0, 1887, 99, 1, 0, 0, 0, 1888, 1889, 5, 2, 0, 0, 1889, 1894, 3, 104, 52, 0, 1890, 1891, 5, 6, 0, 0, 1891, 1893, 3, 104, 52, 0, 1892, 1890, 1, 0, 0, 0, 1893, 1896, 1, 0, 0, 0, 1894, 1892, 1, 0, 0, 0, 1894, 1895, 1, 0, 0, 0, 1895, 1897, 1, 0, 0, 0, 1896, 1894, 1, 0, 0, 0, 1897, 1898, 5, 3, 0, 0, 1898, 101, 1, 0, 0, 0, 1899, 1900, 5, 105, 0, 0, 1900, 1901, 3, 100, 50, 0, 1901, 103, 1, 0, 0, 0, 1902, 1907, 3, 824, 412, 0, 1903, 1904, 5, 10, 0, 0, 1904, 1908, 3, 288, 144, 0, 1905, 1906, 5, 11, 0, 0, 1906, 1908, 3, 286, 143, 0, 1907, 1903, 1, 0, 0, 0, 1907, 1905, 1, 0, 0, 0, 1907, 1908, 1, 0, 0, 0, 1908, 105, 1, 0, 0, 0, 1909, 1910, 5, 62, 0, 0, 1910, 1911, 5, 422, 0, 0, 1911, 1912, 5, 105, 0, 0, 1912, 1913, 5, 2, 0, 0, 1913, 1914, 3, 822, 411, 0, 1914, 1921, 5, 571, 0, 0, 1915, 1916, 5, 6, 0, 0, 1916, 1917, 3, 822, 411, 0, 1917, 1918, 5, 571, 0, 0, 1918, 1920, 1, 0, 0, 0, 1919, 1915, 1, 0, 0, 0, 1920, 1923, 1, 0, 0, 0, 1921, 1919, 1, 0, 0, 0, 1921, 1922, 1, 0, 0, 0, 1922, 1924, 1, 0, 0, 0, 1923, 1921, 1, 0, 0, 0, 1924, 1925, 5, 3, 0, 0, 1925, 1939, 1, 0, 0, 0, 1926, 1927, 5, 62, 0, 0, 1927, 1928, 5, 422, 0, 0, 1928, 1929, 5, 68, 0, 0, 1929, 1939, 3, 534, 267, 0, 1930, 1931, 5, 62, 0, 0, 1931, 1932, 5, 422, 0, 0, 1932, 1933, 5, 64, 0, 0, 1933, 1934, 3, 534, 267, 0, 1934, 1935, 5, 94, 0, 0, 1935, 1936, 3, 534, 267, 0, 1936, 1939, 1, 0, 0, 0, 1937, 1939, 5, 53, 0, 0, 1938, 1909, 1, 0, 0, 0, 1938, 1926, 1, 0, 0, 0, 1938, 1930, 1, 0, 0, 0, 1938, 1937, 1, 0, 0, 0, 1939, 107, 1, 0, 0, 0, 1940, 1941, 5, 138, 0, 0, 1941, 1942, 5, 360, 0, 0, 1942, 1943, 3, 316, 158, 0, 1943, 1948, 3, 110, 55, 0, 1944, 1945, 5, 6, 0, 0, 1945, 1947, 3, 110, 55, 0, 1946, 1944, 1, 0, 0, 0, 1947, 1950, 1, 0, 0, 0, 1948, 1946, 1, 0, 0, 0, 1948, 1949, 1, 0, 0, 0, 1949, 109, 1, 0, 0, 0, 1950, 1948, 1, 0, 0, 0, 1951, 1952, 5, 133, 0, 0, 1952, 1953, 5, 143, 0, 0, 1953, 1955, 3, 644, 322, 0, 1954, 1956, 3, 96, 48, 0, 1955, 1954, 1, 0, 0, 0, 1955, 1956, 1, 0, 0, 0, 1956, 1982, 1, 0, 0, 0, 1957, 1958, 5, 191, 0, 0, 1958, 1960, 5, 143, 0, 0, 1959, 1961, 3, 422, 211, 0, 1960, 1959, 1, 0, 0, 0, 1960, 1961, 1, 0, 0, 0, 1961, 1962, 1, 0, 0, 0, 1962, 1964, 3, 818, 409, 0, 1963, 1965, 3, 96, 48, 0, 1964, 1963, 1, 0, 0, 0, 1964, 1965, 1, 0, 0, 0, 1965, 1982, 1, 0, 0, 0, 1966, 1967, 5, 138, 0, 0, 1967, 1968, 5, 143, 0, 0, 1968, 1971, 3, 818, 409, 0, 1969, 1970, 5, 333, 0, 0, 1970, 1972, 5, 174, 0, 0, 1971, 1969, 1, 0, 0, 0, 1971, 1972, 1, 0, 0, 0, 1972, 1973, 1, 0, 0, 0, 1973, 1974, 5, 360, 0, 0, 1974, 1976, 3, 652, 326, 0, 1975, 1977, 3, 98, 49, 0, 1976, 1975, 1, 0, 0, 0, 1976, 1977, 1, 0, 0, 0, 1977, 1979, 1, 0, 0, 0, 1978, 1980, 3, 96, 48, 0, 1979, 1978, 1, 0, 0, 0, 1979, 1980, 1, 0, 0, 0, 1980, 1982, 1, 0, 0, 0, 1981, 1951, 1, 0, 0, 0, 1981, 1957, 1, 0, 0, 0, 1981, 1966, 1, 0, 0, 0, 1982, 111, 1, 0, 0, 0, 1983, 1986, 5, 157, 0, 0, 1984, 1987, 3, 818, 409, 0, 1985, 1987, 5, 30, 0, 0, 1986, 1984, 1, 0, 0, 0, 1986, 1985, 1, 0, 0, 0, 1987, 113, 1, 0, 0, 0, 1988, 1990, 5, 169, 0, 0, 1989, 1991, 5, 107, 0, 0, 1990, 1989, 1, 0, 0, 0, 1990, 1991, 1, 0, 0, 0, 1991, 1992, 1, 0, 0, 0, 1992, 1994, 3, 774, 387, 0, 1993, 1995, 3, 144, 72, 0, 1994, 1993, 1, 0, 0, 0, 1994, 1995, 1, 0, 0, 0, 1995, 1996, 1, 0, 0, 0, 1996, 1998, 7, 18, 0, 0, 1997, 1999, 5, 297, 0, 0, 1998, 1997, 1, 0, 0, 0, 1998, 1999, 1, 0, 0, 0, 1999, 2003, 1, 0, 0, 0, 2000, 2004, 3, 808, 404, 0, 2001, 2004, 5, 343, 0, 0, 2002, 2004, 5, 344, 0, 0, 2003, 2000, 1, 0, 0, 0, 2003, 2001, 1, 0, 0, 0, 2003, 2002, 1, 0, 0, 0, 2004, 2010, 1, 0, 0, 0, 2005, 2007, 5, 100, 0, 0, 2006, 2005, 1, 0, 0, 0, 2006, 2007, 1, 0, 0, 0, 2007, 2008, 1, 0, 0, 0, 2008, 2009, 5, 184, 0, 0, 2009, 2011, 3, 808, 404, 0, 2010, 2006, 1, 0, 0, 0, 2010, 2011, 1, 0, 0, 0, 2011, 2013, 1, 0, 0, 0, 2012, 2014, 5, 105, 0, 0, 2013, 2012, 1, 0, 0, 0, 2013, 2014, 1, 0, 0, 0, 2014, 2015, 1, 0, 0, 0, 2015, 2017, 3, 116, 58, 0, 2016, 2018, 3, 638, 319, 0, 2017, 2016, 1, 0, 0, 0, 2017, 2018, 1, 0, 0, 0, 2018, 2038, 1, 0, 0, 0, 2019, 2020, 5, 169, 0, 0, 2020, 2021, 5, 2, 0, 0, 2021, 2022, 3, 530, 265, 0, 2022, 2023, 5, 3, 0, 0, 2023, 2025, 5, 94, 0, 0, 2024, 2026, 5, 297, 0, 0, 2025, 2024, 1, 0, 0, 0, 2025, 2026, 1, 0, 0, 0, 2026, 2030, 1, 0, 0, 0, 2027, 2031, 3, 808, 404, 0, 2028, 2031, 5, 343, 0, 0, 2029, 2031, 5, 344, 0, 0, 2030, 2027, 1, 0, 0, 0, 2030, 2028, 1, 0, 0, 0, 2030, 2029, 1, 0, 0, 0, 2031, 2033, 1, 0, 0, 0, 2032, 2034, 5, 105, 0, 0, 2033, 2032, 1, 0, 0, 0, 2033, 2034, 1, 0, 0, 0, 2034, 2035, 1, 0, 0, 0, 2035, 2036, 3, 116, 58, 0, 2036, 2038, 1, 0, 0, 0, 2037, 1988, 1, 0, 0, 0, 2037, 2019, 1, 0, 0, 0, 2038, 115, 1, 0, 0, 0, 2039, 2063, 5, 107, 0, 0, 2040, 2063, 5, 112, 0, 0, 2041, 2043, 7, 19, 0, 0, 2042, 2044, 5, 36, 0, 0, 2043, 2042, 1, 0, 0, 0, 2043, 2044, 1, 0, 0, 0, 2044, 2045, 1, 0, 0, 0, 2045, 2063, 3, 808, 404, 0, 2046, 2063, 5, 171, 0, 0, 2047, 2063, 5, 216, 0, 0, 2048, 2049, 5, 209, 0, 0, 2049, 2052, 5, 298, 0, 0, 2050, 2053, 3, 148, 74, 0, 2051, 2053, 5, 9, 0, 0, 2052, 2050, 1, 0, 0, 0, 2052, 2051, 1, 0, 0, 0, 2053, 2063, 1, 0, 0, 0, 2054, 2056, 5, 209, 0, 0, 2055, 2057, 5, 77, 0, 0, 2056, 2055, 1, 0, 0, 0, 2056, 2057, 1, 0, 0, 0, 2057, 2058, 1, 0, 0, 0, 2058, 2059, 5, 78, 0, 0, 2059, 2063, 3, 148, 74, 0, 2060, 2061, 5, 194, 0, 0, 2061, 2063, 3, 808, 404, 0, 2062, 2039, 1, 0, 0, 0, 2062, 2040, 1, 0, 0, 0, 2062, 2041, 1, 0, 0, 0, 2062, 2046, 1, 0, 0, 0, 2062, 2047, 1, 0, 0, 0, 2062, 2048, 1, 0, 0, 0, 2062, 2054, 1, 0, 0, 0, 2062, 2060, 1, 0, 0, 0, 2063, 2066, 1, 0, 0, 0, 2064, 2062, 1, 0, 0, 0, 2064, 2065, 1, 0, 0, 0, 2065, 2079, 1, 0, 0, 0, 2066, 2064, 1, 0, 0, 0, 2067, 2068, 5, 2, 0, 0, 2068, 2073, 3, 118, 59, 0, 2069, 2070, 5, 6, 0, 0, 2070, 2072, 3, 118, 59, 0, 2071, 2069, 1, 0, 0, 0, 2072, 2075, 1, 0, 0, 0, 2073, 2071, 1, 0, 0, 0, 2073, 2074, 1, 0, 0, 0, 2074, 2076, 1, 0, 0, 0, 2075, 2073, 1, 0, 0, 0, 2076, 2077, 5, 3, 0, 0, 2077, 2079, 1, 0, 0, 0, 2078, 2064, 1, 0, 0, 0, 2078, 2067, 1, 0, 0, 0, 2079, 117, 1, 0, 0, 0, 2080, 2095, 3, 824, 412, 0, 2081, 2096, 3, 54, 27, 0, 2082, 2096, 3, 202, 101, 0, 2083, 2096, 5, 9, 0, 0, 2084, 2085, 5, 2, 0, 0, 2085, 2090, 3, 52, 26, 0, 2086, 2087, 5, 6, 0, 0, 2087, 2089, 3, 52, 26, 0, 2088, 2086, 1, 0, 0, 0, 2089, 2092, 1, 0, 0, 0, 2090, 2088, 1, 0, 0, 0, 2090, 2091, 1, 0, 0, 0, 2091, 2093, 1, 0, 0, 0, 2092, 2090, 1, 0, 0, 0, 2093, 2094, 5, 3, 0, 0, 2094, 2096, 1, 0, 0, 0, 2095, 2081, 1, 0, 0, 0, 2095, 2082, 1, 0, 0, 0, 2095, 2083, 1, 0, 0, 0, 2095, 2084, 1, 0, 0, 0, 2095, 2096, 1, 0, 0, 0, 2096, 119, 1, 0, 0, 0, 2097, 2099, 5, 46, 0, 0, 2098, 2100, 3, 122, 61, 0, 2099, 2098, 1, 0, 0, 0, 2099, 2100, 1, 0, 0, 0, 2100, 2101, 1, 0, 0, 0, 2101, 2103, 5, 92, 0, 0, 2102, 2104, 3, 294, 147, 0, 2103, 2102, 1, 0, 0, 0, 2103, 2104, 1, 0, 0, 0, 2104, 2105, 1, 0, 0, 0, 2105, 2171, 3, 772, 386, 0, 2106, 2108, 5, 2, 0, 0, 2107, 2109, 3, 126, 63, 0, 2108, 2107, 1, 0, 0, 0, 2108, 2109, 1, 0, 0, 0, 2109, 2110, 1, 0, 0, 0, 2110, 2112, 5, 3, 0, 0, 2111, 2113, 3, 164, 82, 0, 2112, 2111, 1, 0, 0, 0, 2112, 2113, 1, 0, 0, 0, 2113, 2115, 1, 0, 0, 0, 2114, 2116, 3, 166, 83, 0, 2115, 2114, 1, 0, 0, 0, 2115, 2116, 1, 0, 0, 0, 2116, 2118, 1, 0, 0, 0, 2117, 2119, 3, 170, 85, 0, 2118, 2117, 1, 0, 0, 0, 2118, 2119, 1, 0, 0, 0, 2119, 2121, 1, 0, 0, 0, 2120, 2122, 3, 172, 86, 0, 2121, 2120, 1, 0, 0, 0, 2121, 2122, 1, 0, 0, 0, 2122, 2124, 1, 0, 0, 0, 2123, 2125, 3, 174, 87, 0, 2124, 2123, 1, 0, 0, 0, 2124, 2125, 1, 0, 0, 0, 2125, 2127, 1, 0, 0, 0, 2126, 2128, 3, 176, 88, 0, 2127, 2126, 1, 0, 0, 0, 2127, 2128, 1, 0, 0, 0, 2128, 2172, 1, 0, 0, 0, 2129, 2130, 5, 275, 0, 0, 2130, 2132, 3, 316, 158, 0, 2131, 2133, 3, 124, 62, 0, 2132, 2131, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, 0, 2133, 2135, 1, 0, 0, 0, 2134, 2136, 3, 166, 83, 0, 2135, 2134, 1, 0, 0, 0, 2135, 2136, 1, 0, 0, 0, 2136, 2138, 1, 0, 0, 0, 2137, 2139, 3, 170, 85, 0, 2138, 2137, 1, 0, 0, 0, 2138, 2139, 1, 0, 0, 0, 2139, 2141, 1, 0, 0, 0, 2140, 2142, 3, 172, 86, 0, 2141, 2140, 1, 0, 0, 0, 2141, 2142, 1, 0, 0, 0, 2142, 2144, 1, 0, 0, 0, 2143, 2145, 3, 174, 87, 0, 2144, 2143, 1, 0, 0, 0, 2144, 2145, 1, 0, 0, 0, 2145, 2147, 1, 0, 0, 0, 2146, 2148, 3, 176, 88, 0, 2147, 2146, 1, 0, 0, 0, 2147, 2148, 1, 0, 0, 0, 2148, 2172, 1, 0, 0, 0, 2149, 2150, 5, 285, 0, 0, 2150, 2151, 5, 275, 0, 0, 2151, 2153, 3, 780, 390, 0, 2152, 2154, 3, 124, 62, 0, 2153, 2152, 1, 0, 0, 0, 2153, 2154, 1, 0, 0, 0, 2154, 2155, 1, 0, 0, 0, 2155, 2157, 3, 106, 53, 0, 2156, 2158, 3, 166, 83, 0, 2157, 2156, 1, 0, 0, 0, 2157, 2158, 1, 0, 0, 0, 2158, 2160, 1, 0, 0, 0, 2159, 2161, 3, 170, 85, 0, 2160, 2159, 1, 0, 0, 0, 2160, 2161, 1, 0, 0, 0, 2161, 2163, 1, 0, 0, 0, 2162, 2164, 3, 172, 86, 0, 2163, 2162, 1, 0, 0, 0, 2163, 2164, 1, 0, 0, 0, 2164, 2166, 1, 0, 0, 0, 2165, 2167, 3, 174, 87, 0, 2166, 2165, 1, 0, 0, 0, 2166, 2167, 1, 0, 0, 0, 2167, 2169, 1, 0, 0, 0, 2168, 2170, 3, 176, 88, 0, 2169, 2168, 1, 0, 0, 0, 2169, 2170, 1, 0, 0, 0, 2170, 2172, 1, 0, 0, 0, 2171, 2106, 1, 0, 0, 0, 2171, 2129, 1, 0, 0, 0, 2171, 2149, 1, 0, 0, 0, 2172, 121, 1, 0, 0, 0, 2173, 2179, 5, 354, 0, 0, 2174, 2179, 5, 352, 0, 0, 2175, 2176, 7, 20, 0, 0, 2176, 2179, 7, 21, 0, 0, 2177, 2179, 5, 367, 0, 0, 2178, 2173, 1, 0, 0, 0, 2178, 2174, 1, 0, 0, 0, 2178, 2175, 1, 0, 0, 0, 2178, 2177, 1, 0, 0, 0, 2179, 123, 1, 0, 0, 0, 2180, 2181, 5, 2, 0, 0, 2181, 2186, 3, 130, 65, 0, 2182, 2183, 5, 6, 0, 0, 2183, 2185, 3, 130, 65, 0, 2184, 2182, 1, 0, 0, 0, 2185, 2188, 1, 0, 0, 0, 2186, 2184, 1, 0, 0, 0, 2186, 2187, 1, 0, 0, 0, 2187, 2189, 1, 0, 0, 0, 2188, 2186, 1, 0, 0, 0, 2189, 2190, 5, 3, 0, 0, 2190, 125, 1, 0, 0, 0, 2191, 2196, 3, 128, 64, 0, 2192, 2193, 5, 6, 0, 0, 2193, 2195, 3, 128, 64, 0, 2194, 2192, 1, 0, 0, 0, 2195, 2198, 1, 0, 0, 0, 2196, 2194, 1, 0, 0, 0, 2196, 2197, 1, 0, 0, 0, 2197, 127, 1, 0, 0, 0, 2198, 2196, 1, 0, 0, 0, 2199, 2215, 3, 132, 66, 0, 2200, 2201, 5, 120, 0, 0, 2201, 2206, 3, 780, 390, 0, 2202, 2203, 7, 22, 0, 0, 2203, 2205, 3, 140, 70, 0, 2204, 2202, 1, 0, 0, 0, 2205, 2208, 1, 0, 0, 0, 2206, 2204, 1, 0, 0, 0, 2206, 2207, 1, 0, 0, 0, 2207, 2215, 1, 0, 0, 0, 2208, 2206, 1, 0, 0, 0, 2209, 2210, 5, 45, 0, 0, 2210, 2212, 3, 818, 409, 0, 2211, 2209, 1, 0, 0, 0, 2211, 2212, 1, 0, 0, 0, 2212, 2213, 1, 0, 0, 0, 2213, 2215, 3, 142, 71, 0, 2214, 2199, 1, 0, 0, 0, 2214, 2200, 1, 0, 0, 0, 2214, 2211, 1, 0, 0, 0, 2215, 129, 1, 0, 0, 0, 2216, 2219, 3, 802, 401, 0, 2217, 2218, 5, 105, 0, 0, 2218, 2220, 5, 280, 0, 0, 2219, 2217, 1, 0, 0, 0, 2219, 2220, 1, 0, 0, 0, 2220, 2224, 1, 0, 0, 0, 2221, 2223, 3, 134, 67, 0, 2222, 2221, 1, 0, 0, 0, 2223, 2226, 1, 0, 0, 0, 2224, 2222, 1, 0, 0, 0, 2224, 2225, 1, 0, 0, 0, 2225, 2233, 1, 0, 0, 0, 2226, 2224, 1, 0, 0, 0, 2227, 2228, 5, 45, 0, 0, 2228, 2230, 3, 818, 409, 0, 2229, 2227, 1, 0, 0, 0, 2229, 2230, 1, 0, 0, 0, 2230, 2231, 1, 0, 0, 0, 2231, 2233, 3, 142, 71, 0, 2232, 2216, 1, 0, 0, 0, 2232, 2229, 1, 0, 0, 0, 2233, 131, 1, 0, 0, 0, 2234, 2235, 3, 802, 401, 0, 2235, 2237, 3, 652, 326, 0, 2236, 2238, 3, 220, 110, 0, 2237, 2236, 1, 0, 0, 0, 2237, 2238, 1, 0, 0, 0, 2238, 2248, 1, 0, 0, 0, 2239, 2246, 5, 345, 0, 0, 2240, 2247, 5, 544, 0, 0, 2241, 2247, 5, 205, 0, 0, 2242, 2247, 5, 545, 0, 0, 2243, 2247, 5, 546, 0, 0, 2244, 2247, 5, 53, 0, 0, 2245, 2247, 3, 818, 409, 0, 2246, 2240, 1, 0, 0, 0, 2246, 2241, 1, 0, 0, 0, 2246, 2242, 1, 0, 0, 0, 2246, 2243, 1, 0, 0, 0, 2246, 2244, 1, 0, 0, 0, 2246, 2245, 1, 0, 0, 0, 2247, 2249, 1, 0, 0, 0, 2248, 2239, 1, 0, 0, 0, 2248, 2249, 1, 0, 0, 0, 2249, 2252, 1, 0, 0, 0, 2250, 2251, 5, 543, 0, 0, 2251, 2253, 3, 818, 409, 0, 2252, 2250, 1, 0, 0, 0, 2252, 2253, 1, 0, 0, 0, 2253, 2255, 1, 0, 0, 0, 2254, 2256, 3, 98, 49, 0, 2255, 2254, 1, 0, 0, 0, 2255, 2256, 1, 0, 0, 0, 2256, 2259, 1, 0, 0, 0, 2257, 2258, 5, 105, 0, 0, 2258, 2260, 5, 280, 0, 0, 2259, 2257, 1, 0, 0, 0, 2259, 2260, 1, 0, 0, 0, 2260, 2264, 1, 0, 0, 0, 2261, 2263, 3, 134, 67, 0, 2262, 2261, 1, 0, 0, 0, 2263, 2266, 1, 0, 0, 0, 2264, 2262, 1, 0, 0, 0, 2264, 2265, 1, 0, 0, 0, 2265, 133, 1, 0, 0, 0, 2266, 2264, 1, 0, 0, 0, 2267, 2268, 5, 45, 0, 0, 2268, 2270, 3, 818, 409, 0, 2269, 2267, 1, 0, 0, 0, 2269, 2270, 1, 0, 0, 0, 2270, 2271, 1, 0, 0, 0, 2271, 2276, 3, 136, 68, 0, 2272, 2274, 5, 77, 0, 0, 2273, 2272, 1, 0, 0, 0, 2273, 2274, 1, 0, 0, 0, 2274, 2275, 1, 0, 0, 0, 2275, 2277, 5, 54, 0, 0, 2276, 2273, 1, 0, 0, 0, 2276, 2277, 1, 0, 0, 0, 2277, 2280, 1, 0, 0, 0, 2278, 2279, 5, 69, 0, 0, 2279, 2281, 7, 9, 0, 0, 2280, 2278, 1, 0, 0, 0, 2280, 2281, 1, 0, 0, 0, 2281, 135, 1, 0, 0, 0, 2282, 2284, 5, 77, 0, 0, 2283, 2282, 1, 0, 0, 0, 2283, 2284, 1, 0, 0, 0, 2284, 2285, 1, 0, 0, 0, 2285, 2363, 5, 78, 0, 0, 2286, 2288, 5, 98, 0, 0, 2287, 2289, 3, 400, 200, 0, 2288, 2287, 1, 0, 0, 0, 2288, 2289, 1, 0, 0, 0, 2289, 2291, 1, 0, 0, 0, 2290, 2292, 3, 178, 89, 0, 2291, 2290, 1, 0, 0, 0, 2291, 2292, 1, 0, 0, 0, 2292, 2363, 1, 0, 0, 0, 2293, 2299, 5, 98, 0, 0, 2294, 2296, 5, 273, 0, 0, 2295, 2297, 5, 77, 0, 0, 2296, 2295, 1, 0, 0, 0, 2296, 2297, 1, 0, 0, 0, 2297, 2298, 1, 0, 0, 0, 2298, 2300, 5, 56, 0, 0, 2299, 2294, 1, 0, 0, 0, 2299, 2300, 1, 0, 0, 0, 2300, 2303, 1, 0, 0, 0, 2301, 2302, 5, 441, 0, 0, 2302, 2304, 3, 360, 180, 0, 2303, 2301, 1, 0, 0, 0, 2303, 2304, 1, 0, 0, 0, 2304, 2306, 1, 0, 0, 0, 2305, 2307, 3, 572, 286, 0, 2306, 2305, 1, 0, 0, 0, 2306, 2307, 1, 0, 0, 0, 2307, 2309, 1, 0, 0, 0, 2308, 2310, 3, 178, 89, 0, 2309, 2308, 1, 0, 0, 0, 2309, 2310, 1, 0, 0, 0, 2310, 2363, 1, 0, 0, 0, 2311, 2312, 5, 85, 0, 0, 2312, 2314, 5, 245, 0, 0, 2313, 2315, 3, 400, 200, 0, 2314, 2313, 1, 0, 0, 0, 2314, 2315, 1, 0, 0, 0, 2315, 2317, 1, 0, 0, 0, 2316, 2318, 3, 178, 89, 0, 2317, 2316, 1, 0, 0, 0, 2317, 2318, 1, 0, 0, 0, 2318, 2363, 1, 0, 0, 0, 2319, 2320, 5, 42, 0, 0, 2320, 2321, 5, 2, 0, 0, 2321, 2322, 3, 674, 337, 0, 2322, 2325, 5, 3, 0, 0, 2323, 2324, 5, 269, 0, 0, 2324, 2326, 5, 228, 0, 0, 2325, 2323, 1, 0, 0, 0, 2325, 2326, 1, 0, 0, 0, 2326, 2363, 1, 0, 0, 0, 2327, 2328, 5, 53, 0, 0, 2328, 2363, 3, 682, 341, 0, 2329, 2330, 5, 438, 0, 0, 2330, 2331, 3, 138, 69, 0, 2331, 2348, 5, 36, 0, 0, 2332, 2341, 5, 219, 0, 0, 2333, 2335, 5, 2, 0, 0, 2334, 2336, 3, 200, 100, 0, 2335, 2334, 1, 0, 0, 0, 2336, 2337, 1, 0, 0, 0, 2337, 2335, 1, 0, 0, 0, 2337, 2338, 1, 0, 0, 0, 2338, 2339, 1, 0, 0, 0, 2339, 2340, 5, 3, 0, 0, 2340, 2342, 1, 0, 0, 0, 2341, 2333, 1, 0, 0, 0, 2341, 2342, 1, 0, 0, 0, 2342, 2349, 1, 0, 0, 0, 2343, 2344, 5, 2, 0, 0, 2344, 2345, 3, 674, 337, 0, 2345, 2346, 5, 3, 0, 0, 2346, 2347, 5, 440, 0, 0, 2347, 2349, 1, 0, 0, 0, 2348, 2332, 1, 0, 0, 0, 2348, 2343, 1, 0, 0, 0, 2349, 2363, 1, 0, 0, 0, 2350, 2351, 5, 86, 0, 0, 2351, 2353, 3, 780, 390, 0, 2352, 2354, 3, 144, 72, 0, 2353, 2352, 1, 0, 0, 0, 2353, 2354, 1, 0, 0, 0, 2354, 2356, 1, 0, 0, 0, 2355, 2357, 3, 152, 76, 0, 2356, 2355, 1, 0, 0, 0, 2356, 2357, 1, 0, 0, 0, 2357, 2359, 1, 0, 0, 0, 2358, 2360, 3, 156, 78, 0, 2359, 2358, 1, 0, 0, 0, 2359, 2360, 1, 0, 0, 0, 2360, 2363, 1, 0, 0, 0, 2361, 2363, 3, 98, 49, 0, 2362, 2283, 1, 0, 0, 0, 2362, 2286, 1, 0, 0, 0, 2362, 2293, 1, 0, 0, 0, 2362, 2311, 1, 0, 0, 0, 2362, 2319, 1, 0, 0, 0, 2362, 2327, 1, 0, 0, 0, 2362, 2329, 1, 0, 0, 0, 2362, 2350, 1, 0, 0, 0, 2362, 2361, 1, 0, 0, 0, 2363, 137, 1, 0, 0, 0, 2364, 2368, 5, 139, 0, 0, 2365, 2366, 5, 147, 0, 0, 2366, 2368, 5, 53, 0, 0, 2367, 2364, 1, 0, 0, 0, 2367, 2365, 1, 0, 0, 0, 2368, 139, 1, 0, 0, 0, 2369, 2370, 7, 23, 0, 0, 2370, 141, 1, 0, 0, 0, 2371, 2372, 5, 42, 0, 0, 2372, 2373, 5, 2, 0, 0, 2373, 2374, 3, 674, 337, 0, 2374, 2378, 5, 3, 0, 0, 2375, 2377, 3, 272, 136, 0, 2376, 2375, 1, 0, 0, 0, 2377, 2380, 1, 0, 0, 0, 2378, 2376, 1, 0, 0, 0, 2378, 2379, 1, 0, 0, 0, 2379, 2468, 1, 0, 0, 0, 2380, 2378, 1, 0, 0, 0, 2381, 2385, 5, 98, 0, 0, 2382, 2383, 5, 85, 0, 0, 2383, 2385, 5, 245, 0, 0, 2384, 2381, 1, 0, 0, 0, 2384, 2382, 1, 0, 0, 0, 2385, 2409, 1, 0, 0, 0, 2386, 2388, 3, 144, 72, 0, 2387, 2389, 3, 150, 75, 0, 2388, 2387, 1, 0, 0, 0, 2388, 2389, 1, 0, 0, 0, 2389, 2391, 1, 0, 0, 0, 2390, 2392, 3, 400, 200, 0, 2391, 2390, 1, 0, 0, 0, 2391, 2392, 1, 0, 0, 0, 2392, 2394, 1, 0, 0, 0, 2393, 2395, 3, 178, 89, 0, 2394, 2393, 1, 0, 0, 0, 2394, 2395, 1, 0, 0, 0, 2395, 2399, 1, 0, 0, 0, 2396, 2398, 3, 272, 136, 0, 2397, 2396, 1, 0, 0, 0, 2398, 2401, 1, 0, 0, 0, 2399, 2397, 1, 0, 0, 0, 2399, 2400, 1, 0, 0, 0, 2400, 2410, 1, 0, 0, 0, 2401, 2399, 1, 0, 0, 0, 2402, 2406, 3, 180, 90, 0, 2403, 2405, 3, 272, 136, 0, 2404, 2403, 1, 0, 0, 0, 2405, 2408, 1, 0, 0, 0, 2406, 2404, 1, 0, 0, 0, 2406, 2407, 1, 0, 0, 0, 2407, 2410, 1, 0, 0, 0, 2408, 2406, 1, 0, 0, 0, 2409, 2386, 1, 0, 0, 0, 2409, 2402, 1, 0, 0, 0, 2410, 2468, 1, 0, 0, 0, 2411, 2413, 5, 199, 0, 0, 2412, 2414, 3, 170, 85, 0, 2413, 2412, 1, 0, 0, 0, 2413, 2414, 1, 0, 0, 0, 2414, 2415, 1, 0, 0, 0, 2415, 2416, 5, 2, 0, 0, 2416, 2421, 3, 154, 77, 0, 2417, 2418, 5, 6, 0, 0, 2418, 2420, 3, 154, 77, 0, 2419, 2417, 1, 0, 0, 0, 2420, 2423, 1, 0, 0, 0, 2421, 2419, 1, 0, 0, 0, 2421, 2422, 1, 0, 0, 0, 2422, 2424, 1, 0, 0, 0, 2423, 2421, 1, 0, 0, 0, 2424, 2426, 5, 3, 0, 0, 2425, 2427, 3, 150, 75, 0, 2426, 2425, 1, 0, 0, 0, 2426, 2427, 1, 0, 0, 0, 2427, 2429, 1, 0, 0, 0, 2428, 2430, 3, 400, 200, 0, 2429, 2428, 1, 0, 0, 0, 2429, 2430, 1, 0, 0, 0, 2430, 2432, 1, 0, 0, 0, 2431, 2433, 3, 178, 89, 0, 2432, 2431, 1, 0, 0, 0, 2432, 2433, 1, 0, 0, 0, 2433, 2439, 1, 0, 0, 0, 2434, 2435, 5, 103, 0, 0, 2435, 2436, 5, 2, 0, 0, 2436, 2437, 3, 674, 337, 0, 2437, 2438, 5, 3, 0, 0, 2438, 2440, 1, 0, 0, 0, 2439, 2434, 1, 0, 0, 0, 2439, 2440, 1, 0, 0, 0, 2440, 2444, 1, 0, 0, 0, 2441, 2443, 3, 272, 136, 0, 2442, 2441, 1, 0, 0, 0, 2443, 2446, 1, 0, 0, 0, 2444, 2442, 1, 0, 0, 0, 2444, 2445, 1, 0, 0, 0, 2445, 2468, 1, 0, 0, 0, 2446, 2444, 1, 0, 0, 0, 2447, 2448, 5, 63, 0, 0, 2448, 2449, 5, 245, 0, 0, 2449, 2450, 3, 144, 72, 0, 2450, 2451, 5, 86, 0, 0, 2451, 2453, 3, 780, 390, 0, 2452, 2454, 3, 144, 72, 0, 2453, 2452, 1, 0, 0, 0, 2453, 2454, 1, 0, 0, 0, 2454, 2456, 1, 0, 0, 0, 2455, 2457, 3, 152, 76, 0, 2456, 2455, 1, 0, 0, 0, 2456, 2457, 1, 0, 0, 0, 2457, 2459, 1, 0, 0, 0, 2458, 2460, 3, 156, 78, 0, 2459, 2458, 1, 0, 0, 0, 2459, 2460, 1, 0, 0, 0, 2460, 2464, 1, 0, 0, 0, 2461, 2463, 3, 272, 136, 0, 2462, 2461, 1, 0, 0, 0, 2463, 2466, 1, 0, 0, 0, 2464, 2462, 1, 0, 0, 0, 2464, 2465, 1, 0, 0, 0, 2465, 2468, 1, 0, 0, 0, 2466, 2464, 1, 0, 0, 0, 2467, 2371, 1, 0, 0, 0, 2467, 2384, 1, 0, 0, 0, 2467, 2411, 1, 0, 0, 0, 2467, 2447, 1, 0, 0, 0, 2468, 143, 1, 0, 0, 0, 2469, 2470, 5, 2, 0, 0, 2470, 2471, 3, 148, 74, 0, 2471, 2472, 5, 3, 0, 0, 2472, 145, 1, 0, 0, 0, 2473, 2474, 5, 2, 0, 0, 2474, 2479, 3, 802, 401, 0, 2475, 2476, 5, 6, 0, 0, 2476, 2478, 3, 802, 401, 0, 2477, 2475, 1, 0, 0, 0, 2478, 2481, 1, 0, 0, 0, 2479, 2477, 1, 0, 0, 0, 2479, 2480, 1, 0, 0, 0, 2480, 2482, 1, 0, 0, 0, 2481, 2479, 1, 0, 0, 0, 2482, 2483, 5, 3, 0, 0, 2483, 147, 1, 0, 0, 0, 2484, 2489, 3, 800, 400, 0, 2485, 2486, 5, 6, 0, 0, 2486, 2488, 3, 800, 400, 0, 2487, 2485, 1, 0, 0, 0, 2488, 2491, 1, 0, 0, 0, 2489, 2487, 1, 0, 0, 0, 2489, 2490, 1, 0, 0, 0, 2490, 149, 1, 0, 0, 0, 2491, 2489, 1, 0, 0, 0, 2492, 2493, 5, 441, 0, 0, 2493, 2494, 3, 144, 72, 0, 2494, 151, 1, 0, 0, 0, 2495, 2496, 5, 258, 0, 0, 2496, 2497, 7, 24, 0, 0, 2497, 153, 1, 0, 0, 0, 2498, 2499, 3, 362, 181, 0, 2499, 2506, 5, 105, 0, 0, 2500, 2507, 3, 414, 207, 0, 2501, 2502, 5, 278, 0, 0, 2502, 2503, 5, 2, 0, 0, 2503, 2504, 3, 414, 207, 0, 2504, 2505, 5, 3, 0, 0, 2505, 2507, 1, 0, 0, 0, 2506, 2500, 1, 0, 0, 0, 2506, 2501, 1, 0, 0, 0, 2507, 155, 1, 0, 0, 0, 2508, 2510, 3, 158, 79, 0, 2509, 2511, 3, 160, 80, 0, 2510, 2509, 1, 0, 0, 0, 2510, 2511, 1, 0, 0, 0, 2511, 2517, 1, 0, 0, 0, 2512, 2514, 3, 160, 80, 0, 2513, 2515, 3, 158, 79, 0, 2514, 2513, 1, 0, 0, 0, 2514, 2515, 1, 0, 0, 0, 2515, 2517, 1, 0, 0, 0, 2516, 2508, 1, 0, 0, 0, 2516, 2512, 1, 0, 0, 0, 2517, 157, 1, 0, 0, 0, 2518, 2519, 5, 80, 0, 0, 2519, 2520, 5, 369, 0, 0, 2520, 2521, 3, 162, 81, 0, 2521, 159, 1, 0, 0, 0, 2522, 2523, 5, 80, 0, 0, 2523, 2524, 5, 182, 0, 0, 2524, 2525, 3, 162, 81, 0, 2525, 161, 1, 0, 0, 0, 2526, 2527, 5, 269, 0, 0, 2527, 2536, 5, 132, 0, 0, 2528, 2536, 5, 315, 0, 0, 2529, 2536, 5, 150, 0, 0, 2530, 2531, 5, 333, 0, 0, 2531, 2533, 7, 25, 0, 0, 2532, 2534, 3, 148, 74, 0, 2533, 2532, 1, 0, 0, 0, 2533, 2534, 1, 0, 0, 0, 2534, 2536, 1, 0, 0, 0, 2535, 2526, 1, 0, 0, 0, 2535, 2528, 1, 0, 0, 0, 2535, 2529, 1, 0, 0, 0, 2535, 2530, 1, 0, 0, 0, 2536, 163, 1, 0, 0, 0, 2537, 2538, 5, 238, 0, 0, 2538, 2539, 5, 2, 0, 0, 2539, 2540, 3, 760, 380, 0, 2540, 2541, 5, 3, 0, 0, 2541, 165, 1, 0, 0, 0, 2542, 2543, 5, 285, 0, 0, 2543, 2544, 5, 147, 0, 0, 2544, 2545, 3, 818, 409, 0, 2545, 2546, 5, 2, 0, 0, 2546, 2551, 3, 168, 84, 0, 2547, 2548, 5, 6, 0, 0, 2548, 2550, 3, 168, 84, 0, 2549, 2547, 1, 0, 0, 0, 2550, 2553, 1, 0, 0, 0, 2551, 2549, 1, 0, 0, 0, 2551, 2552, 1, 0, 0, 0, 2552, 2554, 1, 0, 0, 0, 2553, 2551, 1, 0, 0, 0, 2554, 2555, 5, 3, 0, 0, 2555, 167, 1, 0, 0, 0, 2556, 2563, 3, 800, 400, 0, 2557, 2563, 3, 688, 344, 0, 2558, 2559, 5, 2, 0, 0, 2559, 2560, 3, 674, 337, 0, 2560, 2561, 5, 3, 0, 0, 2561, 2563, 1, 0, 0, 0, 2562, 2556, 1, 0, 0, 0, 2562, 2557, 1, 0, 0, 0, 2562, 2558, 1, 0, 0, 0, 2563, 2565, 1, 0, 0, 0, 2564, 2566, 3, 98, 49, 0, 2565, 2564, 1, 0, 0, 0, 2565, 2566, 1, 0, 0, 0, 2566, 2568, 1, 0, 0, 0, 2567, 2569, 3, 316, 158, 0, 2568, 2567, 1, 0, 0, 0, 2568, 2569, 1, 0, 0, 0, 2569, 169, 1, 0, 0, 0, 2570, 2571, 5, 100, 0, 0, 2571, 2572, 3, 818, 409, 0, 2572, 171, 1, 0, 0, 0, 2573, 2574, 5, 105, 0, 0, 2574, 2578, 3, 100, 50, 0, 2575, 2576, 7, 26, 0, 0, 2576, 2578, 5, 277, 0, 0, 2577, 2573, 1, 0, 0, 0, 2577, 2575, 1, 0, 0, 0, 2578, 173, 1, 0, 0, 0, 2579, 2580, 5, 80, 0, 0, 2580, 2586, 5, 161, 0, 0, 2581, 2587, 5, 191, 0, 0, 2582, 2583, 5, 182, 0, 0, 2583, 2587, 5, 320, 0, 0, 2584, 2585, 5, 292, 0, 0, 2585, 2587, 5, 320, 0, 0, 2586, 2581, 1, 0, 0, 0, 2586, 2582, 1, 0, 0, 0, 2586, 2584, 1, 0, 0, 0, 2587, 175, 1, 0, 0, 0, 2588, 2589, 5, 351, 0, 0, 2589, 2590, 3, 770, 385, 0, 2590, 177, 1, 0, 0, 0, 2591, 2592, 5, 100, 0, 0, 2592, 2593, 5, 226, 0, 0, 2593, 2594, 3, 176, 88, 0, 2594, 179, 1, 0, 0, 0, 2595, 2596, 5, 100, 0, 0, 2596, 2597, 5, 226, 0, 0, 2597, 2598, 3, 818, 409, 0, 2598, 181, 1, 0, 0, 0, 2599, 2600, 5, 46, 0, 0, 2600, 2605, 5, 342, 0, 0, 2601, 2603, 3, 294, 147, 0, 2602, 2601, 1, 0, 0, 0, 2602, 2603, 1, 0, 0, 0, 2603, 2604, 1, 0, 0, 0, 2604, 2606, 3, 316, 158, 0, 2605, 2602, 1, 0, 0, 0, 2605, 2606, 1, 0, 0, 0, 2606, 2608, 1, 0, 0, 0, 2607, 2609, 3, 144, 72, 0, 2608, 2607, 1, 0, 0, 0, 2608, 2609, 1, 0, 0, 0, 2609, 2610, 1, 0, 0, 0, 2610, 2620, 5, 80, 0, 0, 2611, 2616, 3, 732, 366, 0, 2612, 2613, 5, 6, 0, 0, 2613, 2615, 3, 732, 366, 0, 2614, 2612, 1, 0, 0, 0, 2615, 2618, 1, 0, 0, 0, 2616, 2614, 1, 0, 0, 0, 2616, 2617, 1, 0, 0, 0, 2617, 2621, 1, 0, 0, 0, 2618, 2616, 1, 0, 0, 0, 2619, 2621, 3, 730, 365, 0, 2620, 2611, 1, 0, 0, 0, 2620, 2619, 1, 0, 0, 0, 2621, 2622, 1, 0, 0, 0, 2622, 2623, 3, 610, 305, 0, 2623, 183, 1, 0, 0, 0, 2624, 2625, 5, 138, 0, 0, 2625, 2627, 5, 342, 0, 0, 2626, 2628, 3, 422, 211, 0, 2627, 2626, 1, 0, 0, 0, 2627, 2628, 1, 0, 0, 0, 2628, 2629, 1, 0, 0, 0, 2629, 2630, 3, 316, 158, 0, 2630, 2631, 5, 333, 0, 0, 2631, 2632, 5, 342, 0, 0, 2632, 2633, 3, 812, 406, 0, 2633, 185, 1, 0, 0, 0, 2634, 2636, 5, 46, 0, 0, 2635, 2637, 3, 122, 61, 0, 2636, 2635, 1, 0, 0, 0, 2636, 2637, 1, 0, 0, 0, 2637, 2638, 1, 0, 0, 0, 2638, 2640, 5, 92, 0, 0, 2639, 2641, 3, 294, 147, 0, 2640, 2639, 1, 0, 0, 0, 2640, 2641, 1, 0, 0, 0, 2641, 2642, 1, 0, 0, 0, 2642, 2643, 3, 188, 94, 0, 2643, 2644, 5, 36, 0, 0, 2644, 2646, 3, 560, 280, 0, 2645, 2647, 3, 190, 95, 0, 2646, 2645, 1, 0, 0, 0, 2646, 2647, 1, 0, 0, 0, 2647, 187, 1, 0, 0, 0, 2648, 2650, 3, 772, 386, 0, 2649, 2651, 3, 146, 73, 0, 2650, 2649, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 2653, 1, 0, 0, 0, 2652, 2654, 3, 170, 85, 0, 2653, 2652, 1, 0, 0, 0, 2653, 2654, 1, 0, 0, 0, 2654, 2656, 1, 0, 0, 0, 2655, 2657, 3, 172, 86, 0, 2656, 2655, 1, 0, 0, 0, 2656, 2657, 1, 0, 0, 0, 2657, 2659, 1, 0, 0, 0, 2658, 2660, 3, 174, 87, 0, 2659, 2658, 1, 0, 0, 0, 2659, 2660, 1, 0, 0, 0, 2660, 2662, 1, 0, 0, 0, 2661, 2663, 3, 176, 88, 0, 2662, 2661, 1, 0, 0, 0, 2662, 2663, 1, 0, 0, 0, 2663, 189, 1, 0, 0, 0, 2664, 2668, 5, 105, 0, 0, 2665, 2669, 5, 174, 0, 0, 2666, 2667, 5, 269, 0, 0, 2667, 2669, 5, 174, 0, 0, 2668, 2665, 1, 0, 0, 0, 2668, 2666, 1, 0, 0, 0, 2669, 191, 1, 0, 0, 0, 2670, 2672, 5, 46, 0, 0, 2671, 2673, 5, 367, 0, 0, 2672, 2671, 1, 0, 0, 0, 2672, 2673, 1, 0, 0, 0, 2673, 2674, 1, 0, 0, 0, 2674, 2675, 5, 259, 0, 0, 2675, 2677, 5, 376, 0, 0, 2676, 2678, 3, 294, 147, 0, 2677, 2676, 1, 0, 0, 0, 2677, 2678, 1, 0, 0, 0, 2678, 2679, 1, 0, 0, 0, 2679, 2681, 3, 776, 388, 0, 2680, 2682, 3, 146, 73, 0, 2681, 2680, 1, 0, 0, 0, 2681, 2682, 1, 0, 0, 0, 2682, 2684, 1, 0, 0, 0, 2683, 2685, 3, 170, 85, 0, 2684, 2683, 1, 0, 0, 0, 2684, 2685, 1, 0, 0, 0, 2685, 2687, 1, 0, 0, 0, 2686, 2688, 3, 102, 51, 0, 2687, 2686, 1, 0, 0, 0, 2687, 2688, 1, 0, 0, 0, 2688, 2690, 1, 0, 0, 0, 2689, 2691, 3, 176, 88, 0, 2690, 2689, 1, 0, 0, 0, 2690, 2691, 1, 0, 0, 0, 2691, 2692, 1, 0, 0, 0, 2692, 2693, 5, 36, 0, 0, 2693, 2695, 3, 560, 280, 0, 2694, 2696, 3, 190, 95, 0, 2695, 2694, 1, 0, 0, 0, 2695, 2696, 1, 0, 0, 0, 2696, 193, 1, 0, 0, 0, 2697, 2698, 5, 305, 0, 0, 2698, 2699, 5, 259, 0, 0, 2699, 2701, 5, 376, 0, 0, 2700, 2702, 5, 109, 0, 0, 2701, 2700, 1, 0, 0, 0, 2701, 2702, 1, 0, 0, 0, 2702, 2703, 1, 0, 0, 0, 2703, 2705, 3, 778, 389, 0, 2704, 2706, 3, 190, 95, 0, 2705, 2704, 1, 0, 0, 0, 2705, 2706, 1, 0, 0, 0, 2706, 195, 1, 0, 0, 0, 2707, 2709, 5, 46, 0, 0, 2708, 2710, 3, 122, 61, 0, 2709, 2708, 1, 0, 0, 0, 2709, 2710, 1, 0, 0, 0, 2710, 2711, 1, 0, 0, 0, 2711, 2713, 5, 328, 0, 0, 2712, 2714, 3, 294, 147, 0, 2713, 2712, 1, 0, 0, 0, 2713, 2714, 1, 0, 0, 0, 2714, 2715, 1, 0, 0, 0, 2715, 2721, 3, 780, 390, 0, 2716, 2718, 3, 200, 100, 0, 2717, 2716, 1, 0, 0, 0, 2718, 2719, 1, 0, 0, 0, 2719, 2717, 1, 0, 0, 0, 2719, 2720, 1, 0, 0, 0, 2720, 2722, 1, 0, 0, 0, 2721, 2717, 1, 0, 0, 0, 2721, 2722, 1, 0, 0, 0, 2722, 197, 1, 0, 0, 0, 2723, 2724, 5, 138, 0, 0, 2724, 2726, 5, 328, 0, 0, 2725, 2727, 3, 422, 211, 0, 2726, 2725, 1, 0, 0, 0, 2726, 2727, 1, 0, 0, 0, 2727, 2728, 1, 0, 0, 0, 2728, 2730, 3, 780, 390, 0, 2729, 2731, 3, 200, 100, 0, 2730, 2729, 1, 0, 0, 0, 2731, 2732, 1, 0, 0, 0, 2732, 2730, 1, 0, 0, 0, 2732, 2733, 1, 0, 0, 0, 2733, 199, 1, 0, 0, 0, 2734, 2735, 5, 36, 0, 0, 2735, 2768, 3, 654, 327, 0, 2736, 2738, 5, 148, 0, 0, 2737, 2739, 3, 202, 101, 0, 2738, 2737, 1, 0, 0, 0, 2738, 2739, 1, 0, 0, 0, 2739, 2768, 1, 0, 0, 0, 2740, 2742, 5, 225, 0, 0, 2741, 2743, 5, 147, 0, 0, 2742, 2741, 1, 0, 0, 0, 2742, 2743, 1, 0, 0, 0, 2743, 2744, 1, 0, 0, 0, 2744, 2768, 3, 202, 101, 0, 2745, 2746, 7, 27, 0, 0, 2746, 2768, 3, 202, 101, 0, 2747, 2748, 5, 269, 0, 0, 2748, 2768, 7, 28, 0, 0, 2749, 2750, 5, 281, 0, 0, 2750, 2751, 5, 147, 0, 0, 2751, 2768, 3, 800, 400, 0, 2752, 2753, 5, 328, 0, 0, 2753, 2754, 5, 266, 0, 0, 2754, 2768, 3, 316, 158, 0, 2755, 2757, 5, 340, 0, 0, 2756, 2758, 5, 105, 0, 0, 2757, 2756, 1, 0, 0, 0, 2757, 2758, 1, 0, 0, 0, 2758, 2759, 1, 0, 0, 0, 2759, 2768, 3, 202, 101, 0, 2760, 2762, 5, 314, 0, 0, 2761, 2763, 5, 105, 0, 0, 2762, 2761, 1, 0, 0, 0, 2762, 2763, 1, 0, 0, 0, 2763, 2765, 1, 0, 0, 0, 2764, 2766, 3, 202, 101, 0, 2765, 2764, 1, 0, 0, 0, 2765, 2766, 1, 0, 0, 0, 2766, 2768, 1, 0, 0, 0, 2767, 2734, 1, 0, 0, 0, 2767, 2736, 1, 0, 0, 0, 2767, 2740, 1, 0, 0, 0, 2767, 2745, 1, 0, 0, 0, 2767, 2747, 1, 0, 0, 0, 2767, 2749, 1, 0, 0, 0, 2767, 2752, 1, 0, 0, 0, 2767, 2755, 1, 0, 0, 0, 2767, 2760, 1, 0, 0, 0, 2768, 201, 1, 0, 0, 0, 2769, 2771, 7, 29, 0, 0, 2770, 2769, 1, 0, 0, 0, 2770, 2771, 1, 0, 0, 0, 2771, 2772, 1, 0, 0, 0, 2772, 2775, 5, 573, 0, 0, 2773, 2775, 3, 812, 406, 0, 2774, 2770, 1, 0, 0, 0, 2774, 2773, 1, 0, 0, 0, 2775, 203, 1, 0, 0, 0, 2776, 2778, 5, 46, 0, 0, 2777, 2779, 3, 366, 183, 0, 2778, 2777, 1, 0, 0, 0, 2778, 2779, 1, 0, 0, 0, 2779, 2781, 1, 0, 0, 0, 2780, 2782, 5, 359, 0, 0, 2781, 2780, 1, 0, 0, 0, 2781, 2782, 1, 0, 0, 0, 2782, 2784, 1, 0, 0, 0, 2783, 2785, 5, 295, 0, 0, 2784, 2783, 1, 0, 0, 0, 2784, 2785, 1, 0, 0, 0, 2785, 2786, 1, 0, 0, 0, 2786, 2787, 5, 247, 0, 0, 2787, 2800, 3, 818, 409, 0, 2788, 2789, 5, 215, 0, 0, 2789, 2792, 3, 316, 158, 0, 2790, 2791, 5, 239, 0, 0, 2791, 2793, 3, 316, 158, 0, 2792, 2790, 1, 0, 0, 0, 2792, 2793, 1, 0, 0, 0, 2793, 2798, 1, 0, 0, 0, 2794, 2795, 5, 373, 0, 0, 2795, 2799, 3, 316, 158, 0, 2796, 2797, 5, 269, 0, 0, 2797, 2799, 5, 373, 0, 0, 2798, 2794, 1, 0, 0, 0, 2798, 2796, 1, 0, 0, 0, 2798, 2799, 1, 0, 0, 0, 2799, 2801, 1, 0, 0, 0, 2800, 2788, 1, 0, 0, 0, 2800, 2801, 1, 0, 0, 0, 2801, 205, 1, 0, 0, 0, 2802, 2803, 5, 46, 0, 0, 2803, 2806, 3, 176, 88, 0, 2804, 2805, 5, 282, 0, 0, 2805, 2807, 3, 814, 407, 0, 2806, 2804, 1, 0, 0, 0, 2806, 2807, 1, 0, 0, 0, 2807, 2808, 1, 0, 0, 0, 2808, 2809, 5, 255, 0, 0, 2809, 2811, 3, 808, 404, 0, 2810, 2812, 3, 102, 51, 0, 2811, 2810, 1, 0, 0, 0, 2811, 2812, 1, 0, 0, 0, 2812, 207, 1, 0, 0, 0, 2813, 2814, 5, 46, 0, 0, 2814, 2816, 5, 204, 0, 0, 2815, 2817, 3, 294, 147, 0, 2816, 2815, 1, 0, 0, 0, 2816, 2817, 1, 0, 0, 0, 2817, 2818, 1, 0, 0, 0, 2818, 2820, 3, 818, 409, 0, 2819, 2821, 5, 105, 0, 0, 2820, 2819, 1, 0, 0, 0, 2820, 2821, 1, 0, 0, 0, 2821, 2829, 1, 0, 0, 0, 2822, 2823, 5, 323, 0, 0, 2823, 2828, 3, 790, 395, 0, 2824, 2825, 7, 30, 0, 0, 2825, 2828, 3, 58, 29, 0, 2826, 2828, 5, 150, 0, 0, 2827, 2822, 1, 0, 0, 0, 2827, 2824, 1, 0, 0, 0, 2827, 2826, 1, 0, 0, 0, 2828, 2831, 1, 0, 0, 0, 2829, 2827, 1, 0, 0, 0, 2829, 2830, 1, 0, 0, 0, 2830, 209, 1, 0, 0, 0, 2831, 2829, 1, 0, 0, 0, 2832, 2833, 5, 138, 0, 0, 2833, 2834, 5, 204, 0, 0, 2834, 2835, 3, 818, 409, 0, 2835, 2840, 5, 369, 0, 0, 2836, 2837, 5, 94, 0, 0, 2837, 2839, 3, 58, 29, 0, 2838, 2836, 1, 0, 0, 0, 2839, 2842, 1, 0, 0, 0, 2840, 2838, 1, 0, 0, 0, 2840, 2841, 1, 0, 0, 0, 2841, 211, 1, 0, 0, 0, 2842, 2840, 1, 0, 0, 0, 2843, 2844, 5, 138, 0, 0, 2844, 2845, 5, 204, 0, 0, 2845, 2846, 3, 818, 409, 0, 2846, 2879, 7, 6, 0, 0, 2847, 2848, 5, 443, 0, 0, 2848, 2849, 5, 62, 0, 0, 2849, 2850, 3, 652, 326, 0, 2850, 2851, 5, 247, 0, 0, 2851, 2852, 3, 818, 409, 0, 2852, 2880, 1, 0, 0, 0, 2853, 2854, 5, 442, 0, 0, 2854, 2880, 3, 374, 187, 0, 2855, 2856, 5, 296, 0, 0, 2856, 2880, 3, 378, 189, 0, 2857, 2858, 5, 278, 0, 0, 2858, 2859, 7, 31, 0, 0, 2859, 2860, 3, 316, 158, 0, 2860, 2861, 3, 170, 85, 0, 2861, 2880, 1, 0, 0, 0, 2862, 2863, 5, 278, 0, 0, 2863, 2880, 3, 416, 208, 0, 2864, 2865, 5, 211, 0, 0, 2865, 2880, 3, 382, 191, 0, 2866, 2867, 7, 32, 0, 0, 2867, 2880, 3, 652, 326, 0, 2868, 2869, 5, 41, 0, 0, 2869, 2870, 5, 2, 0, 0, 2870, 2871, 3, 652, 326, 0, 2871, 2872, 5, 36, 0, 0, 2872, 2873, 3, 652, 326, 0, 2873, 2874, 5, 3, 0, 0, 2874, 2880, 1, 0, 0, 0, 2875, 2876, 5, 136, 0, 0, 2876, 2880, 3, 394, 197, 0, 2877, 2880, 3, 312, 156, 0, 2878, 2880, 3, 310, 155, 0, 2879, 2847, 1, 0, 0, 0, 2879, 2853, 1, 0, 0, 0, 2879, 2855, 1, 0, 0, 0, 2879, 2857, 1, 0, 0, 0, 2879, 2862, 1, 0, 0, 0, 2879, 2864, 1, 0, 0, 0, 2879, 2866, 1, 0, 0, 0, 2879, 2868, 1, 0, 0, 0, 2879, 2875, 1, 0, 0, 0, 2879, 2877, 1, 0, 0, 0, 2879, 2878, 1, 0, 0, 0, 2880, 213, 1, 0, 0, 0, 2881, 2882, 5, 46, 0, 0, 2882, 2883, 5, 63, 0, 0, 2883, 2884, 5, 174, 0, 0, 2884, 2885, 5, 381, 0, 0, 2885, 2891, 3, 818, 409, 0, 2886, 2888, 3, 216, 108, 0, 2887, 2886, 1, 0, 0, 0, 2888, 2889, 1, 0, 0, 0, 2889, 2887, 1, 0, 0, 0, 2889, 2890, 1, 0, 0, 0, 2890, 2892, 1, 0, 0, 0, 2891, 2887, 1, 0, 0, 0, 2891, 2892, 1, 0, 0, 0, 2892, 2894, 1, 0, 0, 0, 2893, 2895, 3, 220, 110, 0, 2894, 2893, 1, 0, 0, 0, 2894, 2895, 1, 0, 0, 0, 2895, 215, 1, 0, 0, 0, 2896, 2898, 7, 33, 0, 0, 2897, 2899, 3, 316, 158, 0, 2898, 2897, 1, 0, 0, 0, 2898, 2899, 1, 0, 0, 0, 2899, 2903, 1, 0, 0, 0, 2900, 2901, 5, 269, 0, 0, 2901, 2903, 7, 33, 0, 0, 2902, 2896, 1, 0, 0, 0, 2902, 2900, 1, 0, 0, 0, 2903, 217, 1, 0, 0, 0, 2904, 2905, 5, 138, 0, 0, 2905, 2906, 5, 63, 0, 0, 2906, 2907, 5, 174, 0, 0, 2907, 2908, 5, 381, 0, 0, 2908, 2922, 3, 818, 409, 0, 2909, 2911, 3, 216, 108, 0, 2910, 2909, 1, 0, 0, 0, 2911, 2912, 1, 0, 0, 0, 2912, 2910, 1, 0, 0, 0, 2912, 2913, 1, 0, 0, 0, 2913, 2915, 1, 0, 0, 0, 2914, 2910, 1, 0, 0, 0, 2914, 2915, 1, 0, 0, 0, 2915, 2916, 1, 0, 0, 0, 2916, 2923, 3, 222, 111, 0, 2917, 2919, 3, 216, 108, 0, 2918, 2917, 1, 0, 0, 0, 2919, 2920, 1, 0, 0, 0, 2920, 2918, 1, 0, 0, 0, 2920, 2921, 1, 0, 0, 0, 2921, 2923, 1, 0, 0, 0, 2922, 2914, 1, 0, 0, 0, 2922, 2918, 1, 0, 0, 0, 2923, 219, 1, 0, 0, 0, 2924, 2925, 5, 280, 0, 0, 2925, 2926, 5, 2, 0, 0, 2926, 2931, 3, 226, 113, 0, 2927, 2928, 5, 6, 0, 0, 2928, 2930, 3, 226, 113, 0, 2929, 2927, 1, 0, 0, 0, 2930, 2933, 1, 0, 0, 0, 2931, 2929, 1, 0, 0, 0, 2931, 2932, 1, 0, 0, 0, 2932, 2934, 1, 0, 0, 0, 2933, 2931, 1, 0, 0, 0, 2934, 2935, 5, 3, 0, 0, 2935, 221, 1, 0, 0, 0, 2936, 2937, 5, 280, 0, 0, 2937, 2938, 5, 2, 0, 0, 2938, 2943, 3, 224, 112, 0, 2939, 2940, 5, 6, 0, 0, 2940, 2942, 3, 224, 112, 0, 2941, 2939, 1, 0, 0, 0, 2942, 2945, 1, 0, 0, 0, 2943, 2941, 1, 0, 0, 0, 2943, 2944, 1, 0, 0, 0, 2944, 2946, 1, 0, 0, 0, 2945, 2943, 1, 0, 0, 0, 2946, 2947, 5, 3, 0, 0, 2947, 223, 1, 0, 0, 0, 2948, 2949, 7, 34, 0, 0, 2949, 2950, 3, 226, 113, 0, 2950, 225, 1, 0, 0, 0, 2951, 2952, 3, 824, 412, 0, 2952, 2953, 3, 808, 404, 0, 2953, 227, 1, 0, 0, 0, 2954, 2955, 5, 46, 0, 0, 2955, 2957, 5, 331, 0, 0, 2956, 2958, 3, 294, 147, 0, 2957, 2956, 1, 0, 0, 0, 2957, 2958, 1, 0, 0, 0, 2958, 2959, 1, 0, 0, 0, 2959, 2962, 3, 818, 409, 0, 2960, 2961, 5, 360, 0, 0, 2961, 2963, 3, 808, 404, 0, 2962, 2960, 1, 0, 0, 0, 2962, 2963, 1, 0, 0, 0, 2963, 2965, 1, 0, 0, 0, 2964, 2966, 3, 230, 115, 0, 2965, 2964, 1, 0, 0, 0, 2965, 2966, 1, 0, 0, 0, 2966, 2967, 1, 0, 0, 0, 2967, 2968, 5, 63, 0, 0, 2968, 2969, 5, 174, 0, 0, 2969, 2970, 5, 381, 0, 0, 2970, 2972, 3, 818, 409, 0, 2971, 2973, 3, 220, 110, 0, 2972, 2971, 1, 0, 0, 0, 2972, 2973, 1, 0, 0, 0, 2973, 229, 1, 0, 0, 0, 2974, 2977, 5, 375, 0, 0, 2975, 2978, 3, 808, 404, 0, 2976, 2978, 5, 78, 0, 0, 2977, 2975, 1, 0, 0, 0, 2977, 2976, 1, 0, 0, 0, 2978, 231, 1, 0, 0, 0, 2979, 2980, 5, 138, 0, 0, 2980, 2981, 5, 331, 0, 0, 2981, 2987, 3, 818, 409, 0, 2982, 2988, 3, 222, 111, 0, 2983, 2985, 3, 230, 115, 0, 2984, 2986, 3, 222, 111, 0, 2985, 2984, 1, 0, 0, 0, 2985, 2986, 1, 0, 0, 0, 2986, 2988, 1, 0, 0, 0, 2987, 2982, 1, 0, 0, 0, 2987, 2983, 1, 0, 0, 0, 2988, 233, 1, 0, 0, 0, 2989, 2990, 5, 46, 0, 0, 2990, 2991, 5, 63, 0, 0, 2991, 2993, 5, 92, 0, 0, 2992, 2994, 3, 294, 147, 0, 2993, 2992, 1, 0, 0, 0, 2993, 2994, 1, 0, 0, 0, 2994, 2995, 1, 0, 0, 0, 2995, 2996, 3, 772, 386, 0, 2996, 2998, 5, 2, 0, 0, 2997, 2999, 3, 126, 63, 0, 2998, 2997, 1, 0, 0, 0, 2998, 2999, 1, 0, 0, 0, 2999, 3000, 1, 0, 0, 0, 3000, 3002, 5, 3, 0, 0, 3001, 3003, 3, 164, 82, 0, 3002, 3001, 1, 0, 0, 0, 3002, 3003, 1, 0, 0, 0, 3003, 3004, 1, 0, 0, 0, 3004, 3005, 5, 331, 0, 0, 3005, 3007, 3, 818, 409, 0, 3006, 3008, 3, 220, 110, 0, 3007, 3006, 1, 0, 0, 0, 3007, 3008, 1, 0, 0, 0, 3008, 3029, 1, 0, 0, 0, 3009, 3010, 5, 46, 0, 0, 3010, 3011, 5, 63, 0, 0, 3011, 3013, 5, 92, 0, 0, 3012, 3014, 3, 294, 147, 0, 3013, 3012, 1, 0, 0, 0, 3013, 3014, 1, 0, 0, 0, 3014, 3015, 1, 0, 0, 0, 3015, 3016, 3, 772, 386, 0, 3016, 3017, 5, 285, 0, 0, 3017, 3018, 5, 275, 0, 0, 3018, 3020, 3, 774, 387, 0, 3019, 3021, 3, 124, 62, 0, 3020, 3019, 1, 0, 0, 0, 3020, 3021, 1, 0, 0, 0, 3021, 3022, 1, 0, 0, 0, 3022, 3023, 3, 106, 53, 0, 3023, 3024, 5, 331, 0, 0, 3024, 3026, 3, 818, 409, 0, 3025, 3027, 3, 220, 110, 0, 3026, 3025, 1, 0, 0, 0, 3026, 3027, 1, 0, 0, 0, 3027, 3029, 1, 0, 0, 0, 3028, 2989, 1, 0, 0, 0, 3028, 3009, 1, 0, 0, 0, 3029, 235, 1, 0, 0, 0, 3030, 3031, 5, 444, 0, 0, 3031, 3032, 5, 63, 0, 0, 3032, 3033, 5, 323, 0, 0, 3033, 3043, 3, 790, 395, 0, 3034, 3035, 5, 74, 0, 0, 3035, 3038, 5, 94, 0, 0, 3036, 3038, 5, 59, 0, 0, 3037, 3034, 1, 0, 0, 0, 3037, 3036, 1, 0, 0, 0, 3038, 3039, 1, 0, 0, 0, 3039, 3040, 5, 2, 0, 0, 3040, 3041, 3, 628, 314, 0, 3041, 3042, 5, 3, 0, 0, 3042, 3044, 1, 0, 0, 0, 3043, 3037, 1, 0, 0, 0, 3043, 3044, 1, 0, 0, 0, 3044, 3045, 1, 0, 0, 0, 3045, 3046, 5, 64, 0, 0, 3046, 3047, 5, 331, 0, 0, 3047, 3048, 3, 818, 409, 0, 3048, 3049, 5, 71, 0, 0, 3049, 3051, 3, 818, 409, 0, 3050, 3052, 3, 220, 110, 0, 3051, 3050, 1, 0, 0, 0, 3051, 3052, 1, 0, 0, 0, 3052, 237, 1, 0, 0, 0, 3053, 3054, 5, 46, 0, 0, 3054, 3055, 5, 99, 0, 0, 3055, 3057, 5, 257, 0, 0, 3056, 3058, 3, 294, 147, 0, 3057, 3056, 1, 0, 0, 0, 3057, 3058, 1, 0, 0, 0, 3058, 3059, 1, 0, 0, 0, 3059, 3062, 5, 62, 0, 0, 3060, 3063, 3, 814, 407, 0, 3061, 3063, 5, 99, 0, 0, 3062, 3060, 1, 0, 0, 0, 3062, 3061, 1, 0, 0, 0, 3063, 3064, 1, 0, 0, 0, 3064, 3065, 5, 331, 0, 0, 3065, 3067, 3, 818, 409, 0, 3066, 3068, 3, 220, 110, 0, 3067, 3066, 1, 0, 0, 0, 3067, 3068, 1, 0, 0, 0, 3068, 239, 1, 0, 0, 0, 3069, 3070, 5, 138, 0, 0, 3070, 3071, 5, 99, 0, 0, 3071, 3072, 5, 257, 0, 0, 3072, 3075, 5, 62, 0, 0, 3073, 3076, 3, 814, 407, 0, 3074, 3076, 5, 99, 0, 0, 3075, 3073, 1, 0, 0, 0, 3075, 3074, 1, 0, 0, 0, 3076, 3077, 1, 0, 0, 0, 3077, 3078, 5, 331, 0, 0, 3078, 3079, 3, 818, 409, 0, 3079, 3080, 3, 222, 111, 0, 3080, 241, 1, 0, 0, 0, 3081, 3082, 5, 46, 0, 0, 3082, 3083, 5, 445, 0, 0, 3083, 3084, 3, 818, 409, 0, 3084, 3085, 5, 80, 0, 0, 3085, 3092, 3, 780, 390, 0, 3086, 3090, 5, 36, 0, 0, 3087, 3091, 5, 541, 0, 0, 3088, 3091, 5, 542, 0, 0, 3089, 3091, 3, 826, 413, 0, 3090, 3087, 1, 0, 0, 0, 3090, 3088, 1, 0, 0, 0, 3090, 3089, 1, 0, 0, 0, 3091, 3093, 1, 0, 0, 0, 3092, 3086, 1, 0, 0, 0, 3092, 3093, 1, 0, 0, 0, 3093, 3096, 1, 0, 0, 0, 3094, 3095, 5, 62, 0, 0, 3095, 3097, 7, 35, 0, 0, 3096, 3094, 1, 0, 0, 0, 3096, 3097, 1, 0, 0, 0, 3097, 3100, 1, 0, 0, 0, 3098, 3099, 5, 94, 0, 0, 3099, 3101, 3, 816, 408, 0, 3100, 3098, 1, 0, 0, 0, 3100, 3101, 1, 0, 0, 0, 3101, 3103, 1, 0, 0, 0, 3102, 3104, 3, 250, 125, 0, 3103, 3102, 1, 0, 0, 0, 3103, 3104, 1, 0, 0, 0, 3104, 3106, 1, 0, 0, 0, 3105, 3107, 3, 252, 126, 0, 3106, 3105, 1, 0, 0, 0, 3106, 3107, 1, 0, 0, 0, 3107, 243, 1, 0, 0, 0, 3108, 3109, 5, 138, 0, 0, 3109, 3110, 5, 445, 0, 0, 3110, 3111, 3, 818, 409, 0, 3111, 3112, 5, 80, 0, 0, 3112, 3115, 3, 780, 390, 0, 3113, 3114, 5, 94, 0, 0, 3114, 3116, 3, 816, 408, 0, 3115, 3113, 1, 0, 0, 0, 3115, 3116, 1, 0, 0, 0, 3116, 3118, 1, 0, 0, 0, 3117, 3119, 3, 250, 125, 0, 3118, 3117, 1, 0, 0, 0, 3118, 3119, 1, 0, 0, 0, 3119, 3121, 1, 0, 0, 0, 3120, 3122, 3, 252, 126, 0, 3121, 3120, 1, 0, 0, 0, 3121, 3122, 1, 0, 0, 0, 3122, 245, 1, 0, 0, 0, 3123, 3124, 5, 138, 0, 0, 3124, 3125, 5, 296, 0, 0, 3125, 3127, 3, 796, 398, 0, 3126, 3128, 3, 368, 184, 0, 3127, 3126, 1, 0, 0, 0, 3127, 3128, 1, 0, 0, 0, 3128, 3155, 1, 0, 0, 0, 3129, 3133, 3, 248, 124, 0, 3130, 3132, 3, 248, 124, 0, 3131, 3130, 1, 0, 0, 0, 3132, 3135, 1, 0, 0, 0, 3133, 3131, 1, 0, 0, 0, 3133, 3134, 1, 0, 0, 0, 3134, 3137, 1, 0, 0, 0, 3135, 3133, 1, 0, 0, 0, 3136, 3138, 5, 315, 0, 0, 3137, 3136, 1, 0, 0, 0, 3137, 3138, 1, 0, 0, 0, 3138, 3156, 1, 0, 0, 0, 3139, 3140, 5, 309, 0, 0, 3140, 3141, 5, 94, 0, 0, 3141, 3156, 3, 798, 399, 0, 3142, 3143, 5, 282, 0, 0, 3143, 3144, 5, 94, 0, 0, 3144, 3156, 3, 814, 407, 0, 3145, 3146, 5, 333, 0, 0, 3146, 3147, 5, 323, 0, 0, 3147, 3156, 3, 32, 16, 0, 3148, 3150, 5, 269, 0, 0, 3149, 3148, 1, 0, 0, 0, 3149, 3150, 1, 0, 0, 0, 3150, 3151, 1, 0, 0, 0, 3151, 3152, 5, 462, 0, 0, 3152, 3153, 5, 80, 0, 0, 3153, 3154, 5, 204, 0, 0, 3154, 3156, 3, 818, 409, 0, 3155, 3129, 1, 0, 0, 0, 3155, 3139, 1, 0, 0, 0, 3155, 3142, 1, 0, 0, 0, 3155, 3145, 1, 0, 0, 0, 3155, 3149, 1, 0, 0, 0, 3156, 247, 1, 0, 0, 0, 3157, 3159, 5, 205, 0, 0, 3158, 3157, 1, 0, 0, 0, 3158, 3159, 1, 0, 0, 0, 3159, 3160, 1, 0, 0, 0, 3160, 3161, 5, 327, 0, 0, 3161, 3168, 5, 243, 0, 0, 3162, 3164, 5, 205, 0, 0, 3163, 3162, 1, 0, 0, 0, 3163, 3164, 1, 0, 0, 0, 3164, 3165, 1, 0, 0, 0, 3165, 3166, 5, 327, 0, 0, 3166, 3168, 5, 181, 0, 0, 3167, 3158, 1, 0, 0, 0, 3167, 3163, 1, 0, 0, 0, 3168, 3187, 1, 0, 0, 0, 3169, 3170, 5, 333, 0, 0, 3170, 3171, 3, 818, 409, 0, 3171, 3174, 7, 36, 0, 0, 3172, 3175, 3, 818, 409, 0, 3173, 3175, 5, 53, 0, 0, 3174, 3172, 1, 0, 0, 0, 3174, 3173, 1, 0, 0, 0, 3175, 3187, 1, 0, 0, 0, 3176, 3177, 5, 333, 0, 0, 3177, 3178, 3, 818, 409, 0, 3178, 3179, 5, 64, 0, 0, 3179, 3180, 5, 434, 0, 0, 3180, 3187, 1, 0, 0, 0, 3181, 3184, 5, 313, 0, 0, 3182, 3185, 3, 818, 409, 0, 3183, 3185, 5, 30, 0, 0, 3184, 3182, 1, 0, 0, 0, 3184, 3183, 1, 0, 0, 0, 3185, 3187, 1, 0, 0, 0, 3186, 3167, 1, 0, 0, 0, 3186, 3169, 1, 0, 0, 0, 3186, 3176, 1, 0, 0, 0, 3186, 3181, 1, 0, 0, 0, 3187, 249, 1, 0, 0, 0, 3188, 3189, 5, 100, 0, 0, 3189, 3190, 5, 2, 0, 0, 3190, 3191, 3, 674, 337, 0, 3191, 3192, 5, 3, 0, 0, 3192, 251, 1, 0, 0, 0, 3193, 3194, 5, 105, 0, 0, 3194, 3195, 5, 42, 0, 0, 3195, 3196, 5, 2, 0, 0, 3196, 3197, 3, 674, 337, 0, 3197, 3198, 5, 3, 0, 0, 3198, 253, 1, 0, 0, 0, 3199, 3200, 5, 46, 0, 0, 3200, 3201, 5, 131, 0, 0, 3201, 3202, 5, 446, 0, 0, 3202, 3203, 3, 818, 409, 0, 3203, 3204, 5, 360, 0, 0, 3204, 3205, 7, 37, 0, 0, 3205, 3206, 5, 215, 0, 0, 3206, 3207, 3, 316, 158, 0, 3207, 255, 1, 0, 0, 0, 3208, 3210, 5, 46, 0, 0, 3209, 3211, 3, 366, 183, 0, 3210, 3209, 1, 0, 0, 0, 3210, 3211, 1, 0, 0, 0, 3211, 3212, 1, 0, 0, 0, 3212, 3213, 5, 357, 0, 0, 3213, 3214, 3, 818, 409, 0, 3214, 3215, 3, 258, 129, 0, 3215, 3216, 3, 260, 130, 0, 3216, 3217, 5, 80, 0, 0, 3217, 3229, 3, 774, 387, 0, 3218, 3225, 5, 447, 0, 0, 3219, 3220, 7, 38, 0, 0, 3220, 3222, 7, 39, 0, 0, 3221, 3223, 5, 36, 0, 0, 3222, 3221, 1, 0, 0, 0, 3222, 3223, 1, 0, 0, 0, 3223, 3224, 1, 0, 0, 0, 3224, 3226, 3, 818, 409, 0, 3225, 3219, 1, 0, 0, 0, 3226, 3227, 1, 0, 0, 0, 3227, 3225, 1, 0, 0, 0, 3227, 3228, 1, 0, 0, 0, 3228, 3230, 1, 0, 0, 0, 3229, 3218, 1, 0, 0, 0, 3229, 3230, 1, 0, 0, 0, 3230, 3236, 1, 0, 0, 0, 3231, 3233, 5, 62, 0, 0, 3232, 3234, 5, 192, 0, 0, 3233, 3232, 1, 0, 0, 0, 3233, 3234, 1, 0, 0, 0, 3234, 3235, 1, 0, 0, 0, 3235, 3237, 7, 40, 0, 0, 3236, 3231, 1, 0, 0, 0, 3236, 3237, 1, 0, 0, 0, 3237, 3239, 1, 0, 0, 0, 3238, 3240, 3, 264, 132, 0, 3239, 3238, 1, 0, 0, 0, 3239, 3240, 1, 0, 0, 0, 3240, 3241, 1, 0, 0, 0, 3241, 3242, 5, 202, 0, 0, 3242, 3243, 3, 266, 133, 0, 3243, 3244, 5, 2, 0, 0, 3244, 3245, 3, 268, 134, 0, 3245, 3246, 5, 3, 0, 0, 3246, 3287, 1, 0, 0, 0, 3247, 3249, 5, 46, 0, 0, 3248, 3250, 3, 366, 183, 0, 3249, 3248, 1, 0, 0, 0, 3249, 3250, 1, 0, 0, 0, 3250, 3252, 1, 0, 0, 0, 3251, 3253, 5, 45, 0, 0, 3252, 3251, 1, 0, 0, 0, 3252, 3253, 1, 0, 0, 0, 3253, 3254, 1, 0, 0, 0, 3254, 3255, 5, 357, 0, 0, 3255, 3256, 3, 818, 409, 0, 3256, 3257, 3, 258, 129, 0, 3257, 3258, 3, 260, 130, 0, 3258, 3259, 5, 80, 0, 0, 3259, 3262, 3, 774, 387, 0, 3260, 3261, 5, 64, 0, 0, 3261, 3263, 3, 780, 390, 0, 3262, 3260, 1, 0, 0, 0, 3262, 3263, 1, 0, 0, 0, 3263, 3267, 1, 0, 0, 0, 3264, 3266, 3, 272, 136, 0, 3265, 3264, 1, 0, 0, 0, 3266, 3269, 1, 0, 0, 0, 3267, 3265, 1, 0, 0, 0, 3267, 3268, 1, 0, 0, 0, 3268, 3275, 1, 0, 0, 0, 3269, 3267, 1, 0, 0, 0, 3270, 3272, 5, 62, 0, 0, 3271, 3273, 5, 192, 0, 0, 3272, 3271, 1, 0, 0, 0, 3272, 3273, 1, 0, 0, 0, 3273, 3274, 1, 0, 0, 0, 3274, 3276, 7, 40, 0, 0, 3275, 3270, 1, 0, 0, 0, 3275, 3276, 1, 0, 0, 0, 3276, 3278, 1, 0, 0, 0, 3277, 3279, 3, 264, 132, 0, 3278, 3277, 1, 0, 0, 0, 3278, 3279, 1, 0, 0, 0, 3279, 3280, 1, 0, 0, 0, 3280, 3281, 5, 202, 0, 0, 3281, 3282, 3, 266, 133, 0, 3282, 3283, 5, 2, 0, 0, 3283, 3284, 3, 268, 134, 0, 3284, 3285, 5, 3, 0, 0, 3285, 3287, 1, 0, 0, 0, 3286, 3208, 1, 0, 0, 0, 3286, 3247, 1, 0, 0, 0, 3287, 257, 1, 0, 0, 0, 3288, 3293, 5, 145, 0, 0, 3289, 3293, 5, 135, 0, 0, 3290, 3291, 5, 242, 0, 0, 3291, 3293, 5, 275, 0, 0, 3292, 3288, 1, 0, 0, 0, 3292, 3289, 1, 0, 0, 0, 3292, 3290, 1, 0, 0, 0, 3293, 259, 1, 0, 0, 0, 3294, 3299, 3, 262, 131, 0, 3295, 3296, 5, 82, 0, 0, 3296, 3298, 3, 262, 131, 0, 3297, 3295, 1, 0, 0, 0, 3298, 3301, 1, 0, 0, 0, 3299, 3297, 1, 0, 0, 0, 3299, 3300, 1, 0, 0, 0, 3300, 261, 1, 0, 0, 0, 3301, 3299, 1, 0, 0, 0, 3302, 3311, 5, 241, 0, 0, 3303, 3311, 5, 182, 0, 0, 3304, 3307, 5, 369, 0, 0, 3305, 3306, 5, 275, 0, 0, 3306, 3308, 3, 148, 74, 0, 3307, 3305, 1, 0, 0, 0, 3307, 3308, 1, 0, 0, 0, 3308, 3311, 1, 0, 0, 0, 3309, 3311, 5, 358, 0, 0, 3310, 3302, 1, 0, 0, 0, 3310, 3303, 1, 0, 0, 0, 3310, 3304, 1, 0, 0, 0, 3310, 3309, 1, 0, 0, 0, 3311, 263, 1, 0, 0, 0, 3312, 3313, 5, 102, 0, 0, 3313, 3314, 5, 2, 0, 0, 3314, 3315, 3, 674, 337, 0, 3315, 3316, 5, 3, 0, 0, 3316, 265, 1, 0, 0, 0, 3317, 3318, 5, 211, 0, 0, 3318, 3322, 3, 806, 403, 0, 3319, 3320, 5, 296, 0, 0, 3320, 3322, 3, 796, 398, 0, 3321, 3317, 1, 0, 0, 0, 3321, 3319, 1, 0, 0, 0, 3322, 267, 1, 0, 0, 0, 3323, 3326, 3, 270, 135, 0, 3324, 3326, 1, 0, 0, 0, 3325, 3323, 1, 0, 0, 0, 3325, 3324, 1, 0, 0, 0, 3326, 3331, 1, 0, 0, 0, 3327, 3328, 5, 6, 0, 0, 3328, 3330, 3, 270, 135, 0, 3329, 3327, 1, 0, 0, 0, 3330, 3333, 1, 0, 0, 0, 3331, 3329, 1, 0, 0, 0, 3331, 3332, 1, 0, 0, 0, 3332, 269, 1, 0, 0, 0, 3333, 3331, 1, 0, 0, 0, 3334, 3339, 5, 571, 0, 0, 3335, 3339, 5, 573, 0, 0, 3336, 3339, 3, 808, 404, 0, 3337, 3339, 3, 824, 412, 0, 3338, 3334, 1, 0, 0, 0, 3338, 3335, 1, 0, 0, 0, 3338, 3336, 1, 0, 0, 0, 3338, 3337, 1, 0, 0, 0, 3339, 271, 1, 0, 0, 0, 3340, 3342, 5, 77, 0, 0, 3341, 3340, 1, 0, 0, 0, 3341, 3342, 1, 0, 0, 0, 3342, 3343, 1, 0, 0, 0, 3343, 3351, 5, 54, 0, 0, 3344, 3345, 5, 69, 0, 0, 3345, 3351, 7, 9, 0, 0, 3346, 3347, 5, 77, 0, 0, 3347, 3351, 5, 371, 0, 0, 3348, 3349, 5, 269, 0, 0, 3349, 3351, 5, 228, 0, 0, 3350, 3341, 1, 0, 0, 0, 3350, 3344, 1, 0, 0, 0, 3350, 3346, 1, 0, 0, 0, 3350, 3348, 1, 0, 0, 0, 3351, 273, 1, 0, 0, 0, 3352, 3353, 5, 46, 0, 0, 3353, 3354, 5, 198, 0, 0, 3354, 3355, 5, 357, 0, 0, 3355, 3356, 3, 818, 409, 0, 3356, 3357, 5, 80, 0, 0, 3357, 3367, 3, 824, 412, 0, 3358, 3359, 5, 102, 0, 0, 3359, 3364, 3, 276, 138, 0, 3360, 3361, 5, 33, 0, 0, 3361, 3363, 3, 276, 138, 0, 3362, 3360, 1, 0, 0, 0, 3363, 3366, 1, 0, 0, 0, 3364, 3362, 1, 0, 0, 0, 3364, 3365, 1, 0, 0, 0, 3365, 3368, 1, 0, 0, 0, 3366, 3364, 1, 0, 0, 0, 3367, 3358, 1, 0, 0, 0, 3367, 3368, 1, 0, 0, 0, 3368, 3369, 1, 0, 0, 0, 3369, 3370, 5, 202, 0, 0, 3370, 3371, 3, 266, 133, 0, 3371, 3372, 5, 2, 0, 0, 3372, 3373, 5, 3, 0, 0, 3373, 275, 1, 0, 0, 0, 3374, 3375, 3, 818, 409, 0, 3375, 3376, 5, 68, 0, 0, 3376, 3377, 5, 2, 0, 0, 3377, 3381, 3, 808, 404, 0, 3378, 3380, 3, 462, 231, 0, 3379, 3378, 1, 0, 0, 0, 3380, 3383, 1, 0, 0, 0, 3381, 3379, 1, 0, 0, 0, 3381, 3382, 1, 0, 0, 0, 3382, 3384, 1, 0, 0, 0, 3383, 3381, 1, 0, 0, 0, 3384, 3385, 5, 3, 0, 0, 3385, 277, 1, 0, 0, 0, 3386, 3387, 5, 138, 0, 0, 3387, 3388, 5, 198, 0, 0, 3388, 3389, 5, 357, 0, 0, 3389, 3395, 3, 818, 409, 0, 3390, 3392, 5, 193, 0, 0, 3391, 3393, 7, 14, 0, 0, 3392, 3391, 1, 0, 0, 0, 3392, 3393, 1, 0, 0, 0, 3393, 3396, 1, 0, 0, 0, 3394, 3396, 5, 186, 0, 0, 3395, 3390, 1, 0, 0, 0, 3395, 3394, 1, 0, 0, 0, 3396, 279, 1, 0, 0, 0, 3397, 3398, 5, 46, 0, 0, 3398, 3399, 5, 140, 0, 0, 3399, 3400, 3, 316, 158, 0, 3400, 3401, 5, 42, 0, 0, 3401, 3402, 5, 2, 0, 0, 3402, 3403, 3, 674, 337, 0, 3403, 3407, 5, 3, 0, 0, 3404, 3406, 3, 272, 136, 0, 3405, 3404, 1, 0, 0, 0, 3406, 3409, 1, 0, 0, 0, 3407, 3405, 1, 0, 0, 0, 3407, 3408, 1, 0, 0, 0, 3408, 281, 1, 0, 0, 0, 3409, 3407, 1, 0, 0, 0, 3410, 3412, 5, 46, 0, 0, 3411, 3413, 3, 366, 183, 0, 3412, 3411, 1, 0, 0, 0, 3412, 3413, 1, 0, 0, 0, 3413, 3414, 1, 0, 0, 0, 3414, 3415, 5, 136, 0, 0, 3415, 3430, 3, 806, 403, 0, 3416, 3417, 3, 392, 196, 0, 3417, 3418, 3, 284, 142, 0, 3418, 3431, 1, 0, 0, 0, 3419, 3420, 5, 2, 0, 0, 3420, 3425, 3, 290, 145, 0, 3421, 3422, 5, 6, 0, 0, 3422, 3424, 3, 290, 145, 0, 3423, 3421, 1, 0, 0, 0, 3424, 3427, 1, 0, 0, 0, 3425, 3423, 1, 0, 0, 0, 3425, 3426, 1, 0, 0, 0, 3426, 3428, 1, 0, 0, 0, 3427, 3425, 1, 0, 0, 0, 3428, 3429, 5, 3, 0, 0, 3429, 3431, 1, 0, 0, 0, 3430, 3416, 1, 0, 0, 0, 3430, 3419, 1, 0, 0, 0, 3431, 3489, 1, 0, 0, 0, 3432, 3433, 5, 46, 0, 0, 3433, 3434, 5, 278, 0, 0, 3434, 3435, 3, 414, 207, 0, 3435, 3436, 3, 284, 142, 0, 3436, 3489, 1, 0, 0, 0, 3437, 3438, 5, 46, 0, 0, 3438, 3439, 5, 360, 0, 0, 3439, 3440, 3, 316, 158, 0, 3440, 3458, 5, 36, 0, 0, 3441, 3443, 5, 2, 0, 0, 3442, 3444, 3, 642, 321, 0, 3443, 3442, 1, 0, 0, 0, 3443, 3444, 1, 0, 0, 0, 3444, 3445, 1, 0, 0, 0, 3445, 3459, 5, 3, 0, 0, 3446, 3447, 5, 196, 0, 0, 3447, 3455, 5, 2, 0, 0, 3448, 3452, 3, 808, 404, 0, 3449, 3451, 3, 462, 231, 0, 3450, 3449, 1, 0, 0, 0, 3451, 3454, 1, 0, 0, 0, 3452, 3450, 1, 0, 0, 0, 3452, 3453, 1, 0, 0, 0, 3453, 3456, 1, 0, 0, 0, 3454, 3452, 1, 0, 0, 0, 3455, 3448, 1, 0, 0, 0, 3455, 3456, 1, 0, 0, 0, 3456, 3457, 1, 0, 0, 0, 3457, 3459, 5, 3, 0, 0, 3458, 3441, 1, 0, 0, 0, 3458, 3446, 1, 0, 0, 0, 3459, 3489, 1, 0, 0, 0, 3460, 3461, 5, 46, 0, 0, 3461, 3462, 5, 360, 0, 0, 3462, 3468, 3, 316, 158, 0, 3463, 3464, 5, 36, 0, 0, 3464, 3466, 5, 299, 0, 0, 3465, 3463, 1, 0, 0, 0, 3465, 3466, 1, 0, 0, 0, 3466, 3467, 1, 0, 0, 0, 3467, 3469, 3, 284, 142, 0, 3468, 3465, 1, 0, 0, 0, 3468, 3469, 1, 0, 0, 0, 3469, 3489, 1, 0, 0, 0, 3470, 3471, 5, 46, 0, 0, 3471, 3472, 5, 355, 0, 0, 3472, 3473, 5, 325, 0, 0, 3473, 3474, 7, 41, 0, 0, 3474, 3475, 3, 316, 158, 0, 3475, 3476, 3, 284, 142, 0, 3476, 3489, 1, 0, 0, 0, 3477, 3478, 5, 46, 0, 0, 3478, 3480, 5, 108, 0, 0, 3479, 3481, 3, 294, 147, 0, 3480, 3479, 1, 0, 0, 0, 3480, 3481, 1, 0, 0, 0, 3481, 3482, 1, 0, 0, 0, 3482, 3486, 3, 316, 158, 0, 3483, 3487, 3, 284, 142, 0, 3484, 3485, 5, 64, 0, 0, 3485, 3487, 3, 316, 158, 0, 3486, 3483, 1, 0, 0, 0, 3486, 3484, 1, 0, 0, 0, 3487, 3489, 1, 0, 0, 0, 3488, 3410, 1, 0, 0, 0, 3488, 3432, 1, 0, 0, 0, 3488, 3437, 1, 0, 0, 0, 3488, 3460, 1, 0, 0, 0, 3488, 3470, 1, 0, 0, 0, 3488, 3477, 1, 0, 0, 0, 3489, 283, 1, 0, 0, 0, 3490, 3491, 5, 2, 0, 0, 3491, 3496, 3, 286, 143, 0, 3492, 3493, 5, 6, 0, 0, 3493, 3495, 3, 286, 143, 0, 3494, 3492, 1, 0, 0, 0, 3495, 3498, 1, 0, 0, 0, 3496, 3494, 1, 0, 0, 0, 3496, 3497, 1, 0, 0, 0, 3497, 3499, 1, 0, 0, 0, 3498, 3496, 1, 0, 0, 0, 3499, 3500, 5, 3, 0, 0, 3500, 285, 1, 0, 0, 0, 3501, 3504, 3, 824, 412, 0, 3502, 3503, 5, 10, 0, 0, 3503, 3505, 3, 288, 144, 0, 3504, 3502, 1, 0, 0, 0, 3504, 3505, 1, 0, 0, 0, 3505, 287, 1, 0, 0, 0, 3506, 3513, 3, 388, 194, 0, 3507, 3513, 3, 834, 417, 0, 3508, 3513, 3, 726, 363, 0, 3509, 3513, 3, 202, 101, 0, 3510, 3513, 3, 808, 404, 0, 3511, 3513, 5, 407, 0, 0, 3512, 3506, 1, 0, 0, 0, 3512, 3507, 1, 0, 0, 0, 3512, 3508, 1, 0, 0, 0, 3512, 3509, 1, 0, 0, 0, 3512, 3510, 1, 0, 0, 0, 3512, 3511, 1, 0, 0, 0, 3513, 289, 1, 0, 0, 0, 3514, 3515, 3, 826, 413, 0, 3515, 3516, 5, 10, 0, 0, 3516, 3517, 3, 288, 144, 0, 3517, 291, 1, 0, 0, 0, 3518, 3519, 5, 138, 0, 0, 3519, 3520, 5, 360, 0, 0, 3520, 3521, 3, 316, 158, 0, 3521, 3522, 5, 133, 0, 0, 3522, 3524, 5, 450, 0, 0, 3523, 3525, 3, 294, 147, 0, 3524, 3523, 1, 0, 0, 0, 3524, 3525, 1, 0, 0, 0, 3525, 3526, 1, 0, 0, 0, 3526, 3529, 3, 808, 404, 0, 3527, 3528, 7, 42, 0, 0, 3528, 3530, 3, 808, 404, 0, 3529, 3527, 1, 0, 0, 0, 3529, 3530, 1, 0, 0, 0, 3530, 3541, 1, 0, 0, 0, 3531, 3532, 5, 138, 0, 0, 3532, 3533, 5, 360, 0, 0, 3533, 3534, 3, 316, 158, 0, 3534, 3535, 5, 309, 0, 0, 3535, 3536, 5, 450, 0, 0, 3536, 3537, 3, 808, 404, 0, 3537, 3538, 5, 94, 0, 0, 3538, 3539, 3, 808, 404, 0, 3539, 3541, 1, 0, 0, 0, 3540, 3518, 1, 0, 0, 0, 3540, 3531, 1, 0, 0, 0, 3541, 293, 1, 0, 0, 0, 3542, 3543, 5, 220, 0, 0, 3543, 3544, 5, 77, 0, 0, 3544, 3545, 5, 396, 0, 0, 3545, 295, 1, 0, 0, 0, 3546, 3547, 5, 46, 0, 0, 3547, 3548, 5, 278, 0, 0, 3548, 3549, 5, 156, 0, 0, 3549, 3551, 3, 316, 158, 0, 3550, 3552, 5, 53, 0, 0, 3551, 3550, 1, 0, 0, 0, 3551, 3552, 1, 0, 0, 0, 3552, 3553, 1, 0, 0, 0, 3553, 3554, 5, 62, 0, 0, 3554, 3555, 5, 360, 0, 0, 3555, 3556, 3, 652, 326, 0, 3556, 3559, 3, 170, 85, 0, 3557, 3558, 5, 206, 0, 0, 3558, 3560, 3, 316, 158, 0, 3559, 3557, 1, 0, 0, 0, 3559, 3560, 1, 0, 0, 0, 3560, 3561, 1, 0, 0, 0, 3561, 3562, 5, 36, 0, 0, 3562, 3567, 3, 298, 149, 0, 3563, 3564, 5, 6, 0, 0, 3564, 3566, 3, 298, 149, 0, 3565, 3563, 1, 0, 0, 0, 3566, 3569, 1, 0, 0, 0, 3567, 3565, 1, 0, 0, 0, 3567, 3568, 1, 0, 0, 0, 3568, 297, 1, 0, 0, 0, 3569, 3567, 1, 0, 0, 0, 3570, 3571, 5, 278, 0, 0, 3571, 3572, 5, 571, 0, 0, 3572, 3574, 3, 414, 207, 0, 3573, 3575, 3, 412, 206, 0, 3574, 3573, 1, 0, 0, 0, 3574, 3575, 1, 0, 0, 0, 3575, 3583, 1, 0, 0, 0, 3576, 3581, 5, 62, 0, 0, 3577, 3582, 5, 325, 0, 0, 3578, 3579, 5, 83, 0, 0, 3579, 3580, 5, 147, 0, 0, 3580, 3582, 3, 316, 158, 0, 3581, 3577, 1, 0, 0, 0, 3581, 3578, 1, 0, 0, 0, 3582, 3584, 1, 0, 0, 0, 3583, 3576, 1, 0, 0, 0, 3583, 3584, 1, 0, 0, 0, 3584, 3586, 1, 0, 0, 0, 3585, 3587, 5, 302, 0, 0, 3586, 3585, 1, 0, 0, 0, 3586, 3587, 1, 0, 0, 0, 3587, 3597, 1, 0, 0, 0, 3588, 3589, 5, 211, 0, 0, 3589, 3591, 5, 571, 0, 0, 3590, 3592, 3, 528, 264, 0, 3591, 3590, 1, 0, 0, 0, 3591, 3592, 1, 0, 0, 0, 3592, 3593, 1, 0, 0, 0, 3593, 3597, 3, 382, 191, 0, 3594, 3595, 5, 345, 0, 0, 3595, 3597, 3, 652, 326, 0, 3596, 3570, 1, 0, 0, 0, 3596, 3588, 1, 0, 0, 0, 3596, 3594, 1, 0, 0, 0, 3597, 299, 1, 0, 0, 0, 3598, 3599, 5, 46, 0, 0, 3599, 3600, 5, 278, 0, 0, 3600, 3601, 5, 206, 0, 0, 3601, 3602, 3, 316, 158, 0, 3602, 3603, 3, 170, 85, 0, 3603, 301, 1, 0, 0, 0, 3604, 3605, 5, 138, 0, 0, 3605, 3606, 5, 278, 0, 0, 3606, 3607, 5, 206, 0, 0, 3607, 3608, 3, 316, 158, 0, 3608, 3627, 3, 170, 85, 0, 3609, 3610, 5, 133, 0, 0, 3610, 3615, 3, 298, 149, 0, 3611, 3612, 5, 6, 0, 0, 3612, 3614, 3, 298, 149, 0, 3613, 3611, 1, 0, 0, 0, 3614, 3617, 1, 0, 0, 0, 3615, 3613, 1, 0, 0, 0, 3615, 3616, 1, 0, 0, 0, 3616, 3628, 1, 0, 0, 0, 3617, 3615, 1, 0, 0, 0, 3618, 3619, 5, 191, 0, 0, 3619, 3624, 3, 304, 152, 0, 3620, 3621, 5, 6, 0, 0, 3621, 3623, 3, 304, 152, 0, 3622, 3620, 1, 0, 0, 0, 3623, 3626, 1, 0, 0, 0, 3624, 3622, 1, 0, 0, 0, 3624, 3625, 1, 0, 0, 0, 3625, 3628, 1, 0, 0, 0, 3626, 3624, 1, 0, 0, 0, 3627, 3609, 1, 0, 0, 0, 3627, 3618, 1, 0, 0, 0, 3628, 303, 1, 0, 0, 0, 3629, 3630, 7, 43, 0, 0, 3630, 3631, 5, 571, 0, 0, 3631, 3632, 3, 528, 264, 0, 3632, 305, 1, 0, 0, 0, 3633, 3634, 5, 301, 0, 0, 3634, 3635, 5, 281, 0, 0, 3635, 3636, 5, 147, 0, 0, 3636, 3637, 3, 816, 408, 0, 3637, 3638, 5, 94, 0, 0, 3638, 3639, 3, 814, 407, 0, 3639, 307, 1, 0, 0, 0, 3640, 3663, 5, 191, 0, 0, 3641, 3664, 5, 328, 0, 0, 3642, 3664, 5, 226, 0, 0, 3643, 3664, 5, 108, 0, 0, 3644, 3664, 5, 168, 0, 0, 3645, 3664, 5, 342, 0, 0, 3646, 3664, 5, 452, 0, 0, 3647, 3664, 5, 331, 0, 0, 3648, 3649, 5, 131, 0, 0, 3649, 3664, 5, 446, 0, 0, 3650, 3651, 5, 198, 0, 0, 3651, 3664, 5, 357, 0, 0, 3652, 3664, 5, 204, 0, 0, 3653, 3655, 5, 295, 0, 0, 3654, 3653, 1, 0, 0, 0, 3654, 3655, 1, 0, 0, 0, 3655, 3656, 1, 0, 0, 0, 3656, 3664, 5, 247, 0, 0, 3657, 3658, 5, 63, 0, 0, 3658, 3659, 5, 174, 0, 0, 3659, 3664, 5, 381, 0, 0, 3660, 3661, 5, 355, 0, 0, 3661, 3662, 5, 325, 0, 0, 3662, 3664, 7, 41, 0, 0, 3663, 3641, 1, 0, 0, 0, 3663, 3642, 1, 0, 0, 0, 3663, 3643, 1, 0, 0, 0, 3663, 3644, 1, 0, 0, 0, 3663, 3645, 1, 0, 0, 0, 3663, 3646, 1, 0, 0, 0, 3663, 3647, 1, 0, 0, 0, 3663, 3648, 1, 0, 0, 0, 3663, 3650, 1, 0, 0, 0, 3663, 3652, 1, 0, 0, 0, 3663, 3654, 1, 0, 0, 0, 3663, 3657, 1, 0, 0, 0, 3663, 3660, 1, 0, 0, 0, 3664, 3666, 1, 0, 0, 0, 3665, 3667, 3, 422, 211, 0, 3666, 3665, 1, 0, 0, 0, 3666, 3667, 1, 0, 0, 0, 3667, 3668, 1, 0, 0, 0, 3668, 3670, 3, 784, 392, 0, 3669, 3671, 3, 96, 48, 0, 3670, 3669, 1, 0, 0, 0, 3670, 3671, 1, 0, 0, 0, 3671, 3848, 1, 0, 0, 0, 3672, 3674, 5, 191, 0, 0, 3673, 3675, 5, 259, 0, 0, 3674, 3673, 1, 0, 0, 0, 3674, 3675, 1, 0, 0, 0, 3675, 3676, 1, 0, 0, 0, 3676, 3678, 5, 376, 0, 0, 3677, 3679, 3, 422, 211, 0, 3678, 3677, 1, 0, 0, 0, 3678, 3679, 1, 0, 0, 0, 3679, 3680, 1, 0, 0, 0, 3680, 3685, 3, 778, 389, 0, 3681, 3682, 5, 6, 0, 0, 3682, 3684, 3, 778, 389, 0, 3683, 3681, 1, 0, 0, 0, 3684, 3687, 1, 0, 0, 0, 3685, 3683, 1, 0, 0, 0, 3685, 3686, 1, 0, 0, 0, 3686, 3689, 1, 0, 0, 0, 3687, 3685, 1, 0, 0, 0, 3688, 3690, 3, 96, 48, 0, 3689, 3688, 1, 0, 0, 0, 3689, 3690, 1, 0, 0, 0, 3690, 3848, 1, 0, 0, 0, 3691, 3693, 5, 191, 0, 0, 3692, 3694, 5, 63, 0, 0, 3693, 3692, 1, 0, 0, 0, 3693, 3694, 1, 0, 0, 0, 3694, 3695, 1, 0, 0, 0, 3695, 3697, 5, 92, 0, 0, 3696, 3698, 3, 422, 211, 0, 3697, 3696, 1, 0, 0, 0, 3697, 3698, 1, 0, 0, 0, 3698, 3699, 1, 0, 0, 0, 3699, 3701, 3, 762, 381, 0, 3700, 3702, 3, 96, 48, 0, 3701, 3700, 1, 0, 0, 0, 3701, 3702, 1, 0, 0, 0, 3702, 3848, 1, 0, 0, 0, 3703, 3704, 5, 191, 0, 0, 3704, 3706, 5, 323, 0, 0, 3705, 3707, 3, 422, 211, 0, 3706, 3705, 1, 0, 0, 0, 3706, 3707, 1, 0, 0, 0, 3707, 3708, 1, 0, 0, 0, 3708, 3710, 3, 764, 382, 0, 3709, 3711, 3, 96, 48, 0, 3710, 3709, 1, 0, 0, 0, 3710, 3711, 1, 0, 0, 0, 3711, 3848, 1, 0, 0, 0, 3712, 3713, 5, 191, 0, 0, 3713, 3715, 7, 44, 0, 0, 3714, 3716, 3, 422, 211, 0, 3715, 3714, 1, 0, 0, 0, 3715, 3716, 1, 0, 0, 0, 3716, 3717, 1, 0, 0, 0, 3717, 3718, 3, 818, 409, 0, 3718, 3719, 5, 80, 0, 0, 3719, 3721, 3, 316, 158, 0, 3720, 3722, 3, 96, 48, 0, 3721, 3720, 1, 0, 0, 0, 3721, 3722, 1, 0, 0, 0, 3722, 3848, 1, 0, 0, 0, 3723, 3724, 5, 191, 0, 0, 3724, 3726, 7, 32, 0, 0, 3725, 3727, 3, 422, 211, 0, 3726, 3725, 1, 0, 0, 0, 3726, 3727, 1, 0, 0, 0, 3727, 3728, 1, 0, 0, 0, 3728, 3733, 3, 652, 326, 0, 3729, 3730, 5, 6, 0, 0, 3730, 3732, 3, 652, 326, 0, 3731, 3729, 1, 0, 0, 0, 3732, 3735, 1, 0, 0, 0, 3733, 3731, 1, 0, 0, 0, 3733, 3734, 1, 0, 0, 0, 3734, 3737, 1, 0, 0, 0, 3735, 3733, 1, 0, 0, 0, 3736, 3738, 3, 96, 48, 0, 3737, 3736, 1, 0, 0, 0, 3737, 3738, 1, 0, 0, 0, 3738, 3848, 1, 0, 0, 0, 3739, 3740, 5, 191, 0, 0, 3740, 3741, 5, 226, 0, 0, 3741, 3743, 5, 109, 0, 0, 3742, 3744, 3, 422, 211, 0, 3743, 3742, 1, 0, 0, 0, 3743, 3744, 1, 0, 0, 0, 3744, 3745, 1, 0, 0, 0, 3745, 3747, 3, 314, 157, 0, 3746, 3748, 3, 96, 48, 0, 3747, 3746, 1, 0, 0, 0, 3747, 3748, 1, 0, 0, 0, 3748, 3848, 1, 0, 0, 0, 3749, 3750, 5, 191, 0, 0, 3750, 3752, 5, 41, 0, 0, 3751, 3753, 3, 422, 211, 0, 3752, 3751, 1, 0, 0, 0, 3752, 3753, 1, 0, 0, 0, 3753, 3754, 1, 0, 0, 0, 3754, 3755, 5, 2, 0, 0, 3755, 3756, 3, 652, 326, 0, 3756, 3757, 5, 36, 0, 0, 3757, 3758, 3, 652, 326, 0, 3758, 3760, 5, 3, 0, 0, 3759, 3761, 3, 96, 48, 0, 3760, 3759, 1, 0, 0, 0, 3760, 3761, 1, 0, 0, 0, 3761, 3848, 1, 0, 0, 0, 3762, 3763, 5, 191, 0, 0, 3763, 3764, 5, 278, 0, 0, 3764, 3766, 7, 31, 0, 0, 3765, 3767, 3, 422, 211, 0, 3766, 3765, 1, 0, 0, 0, 3766, 3767, 1, 0, 0, 0, 3767, 3768, 1, 0, 0, 0, 3768, 3769, 3, 316, 158, 0, 3769, 3771, 3, 170, 85, 0, 3770, 3772, 3, 96, 48, 0, 3771, 3770, 1, 0, 0, 0, 3771, 3772, 1, 0, 0, 0, 3772, 3848, 1, 0, 0, 0, 3773, 3774, 5, 191, 0, 0, 3774, 3775, 5, 281, 0, 0, 3775, 3776, 5, 147, 0, 0, 3776, 3778, 3, 816, 408, 0, 3777, 3779, 3, 96, 48, 0, 3778, 3777, 1, 0, 0, 0, 3778, 3779, 1, 0, 0, 0, 3779, 3848, 1, 0, 0, 0, 3780, 3781, 5, 191, 0, 0, 3781, 3783, 5, 451, 0, 0, 3782, 3784, 3, 422, 211, 0, 3783, 3782, 1, 0, 0, 0, 3783, 3784, 1, 0, 0, 0, 3784, 3785, 1, 0, 0, 0, 3785, 3787, 3, 818, 409, 0, 3786, 3788, 3, 96, 48, 0, 3787, 3786, 1, 0, 0, 0, 3787, 3788, 1, 0, 0, 0, 3788, 3848, 1, 0, 0, 0, 3789, 3790, 5, 191, 0, 0, 3790, 3792, 5, 351, 0, 0, 3791, 3793, 3, 422, 211, 0, 3792, 3791, 1, 0, 0, 0, 3792, 3793, 1, 0, 0, 0, 3793, 3794, 1, 0, 0, 0, 3794, 3848, 3, 770, 385, 0, 3795, 3796, 5, 191, 0, 0, 3796, 3798, 5, 443, 0, 0, 3797, 3799, 3, 422, 211, 0, 3798, 3797, 1, 0, 0, 0, 3798, 3799, 1, 0, 0, 0, 3799, 3800, 1, 0, 0, 0, 3800, 3801, 5, 62, 0, 0, 3801, 3802, 3, 652, 326, 0, 3802, 3803, 5, 247, 0, 0, 3803, 3805, 3, 818, 409, 0, 3804, 3806, 3, 96, 48, 0, 3805, 3804, 1, 0, 0, 0, 3805, 3806, 1, 0, 0, 0, 3806, 3848, 1, 0, 0, 0, 3807, 3808, 5, 191, 0, 0, 3808, 3810, 7, 45, 0, 0, 3809, 3811, 3, 422, 211, 0, 3810, 3809, 1, 0, 0, 0, 3810, 3811, 1, 0, 0, 0, 3811, 3812, 1, 0, 0, 0, 3812, 3848, 3, 816, 408, 0, 3813, 3814, 5, 191, 0, 0, 3814, 3815, 5, 99, 0, 0, 3815, 3817, 5, 257, 0, 0, 3816, 3818, 3, 422, 211, 0, 3817, 3816, 1, 0, 0, 0, 3817, 3818, 1, 0, 0, 0, 3818, 3819, 1, 0, 0, 0, 3819, 3822, 5, 62, 0, 0, 3820, 3823, 3, 814, 407, 0, 3821, 3823, 5, 99, 0, 0, 3822, 3820, 1, 0, 0, 0, 3822, 3821, 1, 0, 0, 0, 3823, 3824, 1, 0, 0, 0, 3824, 3825, 5, 331, 0, 0, 3825, 3848, 3, 818, 409, 0, 3826, 3827, 5, 191, 0, 0, 3827, 3829, 5, 175, 0, 0, 3828, 3830, 3, 422, 211, 0, 3829, 3828, 1, 0, 0, 0, 3829, 3830, 1, 0, 0, 0, 3830, 3831, 1, 0, 0, 0, 3831, 3845, 3, 788, 394, 0, 3832, 3834, 5, 105, 0, 0, 3833, 3832, 1, 0, 0, 0, 3833, 3834, 1, 0, 0, 0, 3834, 3835, 1, 0, 0, 0, 3835, 3836, 5, 2, 0, 0, 3836, 3841, 5, 209, 0, 0, 3837, 3838, 5, 6, 0, 0, 3838, 3840, 5, 209, 0, 0, 3839, 3837, 1, 0, 0, 0, 3840, 3843, 1, 0, 0, 0, 3841, 3839, 1, 0, 0, 0, 3841, 3842, 1, 0, 0, 0, 3842, 3844, 1, 0, 0, 0, 3843, 3841, 1, 0, 0, 0, 3844, 3846, 5, 3, 0, 0, 3845, 3833, 1, 0, 0, 0, 3845, 3846, 1, 0, 0, 0, 3846, 3848, 1, 0, 0, 0, 3847, 3640, 1, 0, 0, 0, 3847, 3672, 1, 0, 0, 0, 3847, 3691, 1, 0, 0, 0, 3847, 3703, 1, 0, 0, 0, 3847, 3712, 1, 0, 0, 0, 3847, 3723, 1, 0, 0, 0, 3847, 3739, 1, 0, 0, 0, 3847, 3749, 1, 0, 0, 0, 3847, 3762, 1, 0, 0, 0, 3847, 3773, 1, 0, 0, 0, 3847, 3780, 1, 0, 0, 0, 3847, 3789, 1, 0, 0, 0, 3847, 3795, 1, 0, 0, 0, 3847, 3807, 1, 0, 0, 0, 3847, 3813, 1, 0, 0, 0, 3847, 3826, 1, 0, 0, 0, 3848, 309, 1, 0, 0, 0, 3849, 3851, 5, 63, 0, 0, 3850, 3849, 1, 0, 0, 0, 3850, 3851, 1, 0, 0, 0, 3851, 3852, 1, 0, 0, 0, 3852, 3853, 5, 92, 0, 0, 3853, 3866, 3, 774, 387, 0, 3854, 3856, 5, 259, 0, 0, 3855, 3854, 1, 0, 0, 0, 3855, 3856, 1, 0, 0, 0, 3856, 3857, 1, 0, 0, 0, 3857, 3858, 5, 376, 0, 0, 3858, 3866, 3, 778, 389, 0, 3859, 3860, 7, 46, 0, 0, 3860, 3866, 3, 316, 158, 0, 3861, 3862, 5, 355, 0, 0, 3862, 3863, 5, 325, 0, 0, 3863, 3864, 7, 41, 0, 0, 3864, 3866, 3, 316, 158, 0, 3865, 3850, 1, 0, 0, 0, 3865, 3855, 1, 0, 0, 0, 3865, 3859, 1, 0, 0, 0, 3865, 3861, 1, 0, 0, 0, 3866, 311, 1, 0, 0, 0, 3867, 3868, 5, 198, 0, 0, 3868, 3884, 5, 357, 0, 0, 3869, 3870, 5, 131, 0, 0, 3870, 3884, 5, 446, 0, 0, 3871, 3884, 5, 204, 0, 0, 3872, 3884, 5, 452, 0, 0, 3873, 3884, 5, 331, 0, 0, 3874, 3884, 5, 318, 0, 0, 3875, 3884, 5, 451, 0, 0, 3876, 3877, 5, 63, 0, 0, 3877, 3878, 5, 174, 0, 0, 3878, 3884, 5, 381, 0, 0, 3879, 3881, 5, 295, 0, 0, 3880, 3879, 1, 0, 0, 0, 3880, 3881, 1, 0, 0, 0, 3881, 3882, 1, 0, 0, 0, 3882, 3884, 5, 247, 0, 0, 3883, 3867, 1, 0, 0, 0, 3883, 3869, 1, 0, 0, 0, 3883, 3871, 1, 0, 0, 0, 3883, 3872, 1, 0, 0, 0, 3883, 3873, 1, 0, 0, 0, 3883, 3874, 1, 0, 0, 0, 3883, 3875, 1, 0, 0, 0, 3883, 3876, 1, 0, 0, 0, 3883, 3880, 1, 0, 0, 0, 3884, 3885, 1, 0, 0, 0, 3885, 3892, 3, 818, 409, 0, 3886, 3887, 5, 323, 0, 0, 3887, 3892, 3, 790, 395, 0, 3888, 3889, 5, 175, 0, 0, 3889, 3892, 3, 788, 394, 0, 3890, 3892, 3, 176, 88, 0, 3891, 3883, 1, 0, 0, 0, 3891, 3886, 1, 0, 0, 0, 3891, 3888, 1, 0, 0, 0, 3891, 3890, 1, 0, 0, 0, 3892, 313, 1, 0, 0, 0, 3893, 3898, 3, 316, 158, 0, 3894, 3895, 5, 6, 0, 0, 3895, 3897, 3, 316, 158, 0, 3896, 3894, 1, 0, 0, 0, 3897, 3900, 1, 0, 0, 0, 3898, 3896, 1, 0, 0, 0, 3898, 3899, 1, 0, 0, 0, 3899, 315, 1, 0, 0, 0, 3900, 3898, 1, 0, 0, 0, 3901, 3903, 3, 818, 409, 0, 3902, 3904, 3, 318, 159, 0, 3903, 3902, 1, 0, 0, 0, 3903, 3904, 1, 0, 0, 0, 3904, 317, 1, 0, 0, 0, 3905, 3906, 5, 11, 0, 0, 3906, 3908, 3, 824, 412, 0, 3907, 3905, 1, 0, 0, 0, 3908, 3909, 1, 0, 0, 0, 3909, 3907, 1, 0, 0, 0, 3909, 3910, 1, 0, 0, 0, 3910, 319, 1, 0, 0, 0, 3911, 3913, 5, 358, 0, 0, 3912, 3914, 5, 92, 0, 0, 3913, 3912, 1, 0, 0, 0, 3913, 3914, 1, 0, 0, 0, 3914, 3915, 1, 0, 0, 0, 3915, 3920, 3, 322, 161, 0, 3916, 3917, 5, 6, 0, 0, 3917, 3919, 3, 322, 161, 0, 3918, 3916, 1, 0, 0, 0, 3919, 3922, 1, 0, 0, 0, 3920, 3918, 1, 0, 0, 0, 3920, 3921, 1, 0, 0, 0, 3921, 3925, 1, 0, 0, 0, 3922, 3920, 1, 0, 0, 0, 3923, 3924, 7, 47, 0, 0, 3924, 3926, 5, 219, 0, 0, 3925, 3923, 1, 0, 0, 0, 3925, 3926, 1, 0, 0, 0, 3926, 3928, 1, 0, 0, 0, 3927, 3929, 3, 96, 48, 0, 3928, 3927, 1, 0, 0, 0, 3928, 3929, 1, 0, 0, 0, 3929, 321, 1, 0, 0, 0, 3930, 3932, 5, 81, 0, 0, 3931, 3930, 1, 0, 0, 0, 3931, 3932, 1, 0, 0, 0, 3932, 3933, 1, 0, 0, 0, 3933, 3935, 3, 774, 387, 0, 3934, 3936, 5, 9, 0, 0, 3935, 3934, 1, 0, 0, 0, 3935, 3936, 1, 0, 0, 0, 3936, 323, 1, 0, 0, 0, 3937, 3938, 5, 159, 0, 0, 3938, 3997, 5, 80, 0, 0, 3939, 3998, 3, 310, 155, 0, 3940, 3998, 3, 312, 156, 0, 3941, 3942, 5, 44, 0, 0, 3942, 3944, 3, 818, 409, 0, 3943, 3945, 3, 318, 159, 0, 3944, 3943, 1, 0, 0, 0, 3944, 3945, 1, 0, 0, 0, 3945, 3946, 1, 0, 0, 0, 3946, 3947, 5, 11, 0, 0, 3947, 3948, 3, 800, 400, 0, 3948, 3998, 1, 0, 0, 0, 3949, 3950, 7, 32, 0, 0, 3950, 3998, 3, 652, 326, 0, 3951, 3952, 5, 136, 0, 0, 3952, 3998, 3, 394, 197, 0, 3953, 3954, 5, 211, 0, 0, 3954, 3998, 3, 382, 191, 0, 3955, 3956, 5, 278, 0, 0, 3956, 3998, 3, 416, 208, 0, 3957, 3958, 5, 45, 0, 0, 3958, 3959, 3, 818, 409, 0, 3959, 3965, 5, 80, 0, 0, 3960, 3966, 3, 774, 387, 0, 3961, 3963, 5, 189, 0, 0, 3962, 3961, 1, 0, 0, 0, 3962, 3963, 1, 0, 0, 0, 3963, 3964, 1, 0, 0, 0, 3964, 3966, 3, 316, 158, 0, 3965, 3960, 1, 0, 0, 0, 3965, 3962, 1, 0, 0, 0, 3966, 3998, 1, 0, 0, 0, 3967, 3968, 7, 44, 0, 0, 3968, 3969, 3, 818, 409, 0, 3969, 3970, 5, 80, 0, 0, 3970, 3971, 3, 316, 158, 0, 3971, 3998, 1, 0, 0, 0, 3972, 3973, 5, 296, 0, 0, 3973, 3998, 3, 378, 189, 0, 3974, 3975, 5, 442, 0, 0, 3975, 3998, 3, 374, 187, 0, 3976, 3977, 5, 443, 0, 0, 3977, 3978, 5, 62, 0, 0, 3978, 3979, 3, 652, 326, 0, 3979, 3980, 5, 247, 0, 0, 3980, 3981, 3, 818, 409, 0, 3981, 3998, 1, 0, 0, 0, 3982, 3983, 5, 278, 0, 0, 3983, 3984, 7, 31, 0, 0, 3984, 3985, 3, 316, 158, 0, 3985, 3986, 3, 170, 85, 0, 3986, 3998, 1, 0, 0, 0, 3987, 3988, 5, 248, 0, 0, 3988, 3989, 5, 274, 0, 0, 3989, 3998, 3, 202, 101, 0, 3990, 3991, 5, 41, 0, 0, 3991, 3992, 5, 2, 0, 0, 3992, 3993, 3, 652, 326, 0, 3993, 3994, 5, 36, 0, 0, 3994, 3995, 3, 652, 326, 0, 3995, 3996, 5, 3, 0, 0, 3996, 3998, 1, 0, 0, 0, 3997, 3939, 1, 0, 0, 0, 3997, 3940, 1, 0, 0, 0, 3997, 3941, 1, 0, 0, 0, 3997, 3949, 1, 0, 0, 0, 3997, 3951, 1, 0, 0, 0, 3997, 3953, 1, 0, 0, 0, 3997, 3955, 1, 0, 0, 0, 3997, 3957, 1, 0, 0, 0, 3997, 3967, 1, 0, 0, 0, 3997, 3972, 1, 0, 0, 0, 3997, 3974, 1, 0, 0, 0, 3997, 3976, 1, 0, 0, 0, 3997, 3982, 1, 0, 0, 0, 3997, 3987, 1, 0, 0, 0, 3997, 3990, 1, 0, 0, 0, 3998, 3999, 1, 0, 0, 0, 3999, 4002, 5, 116, 0, 0, 4000, 4003, 3, 808, 404, 0, 4001, 4003, 5, 78, 0, 0, 4002, 4000, 1, 0, 0, 0, 4002, 4001, 1, 0, 0, 0, 4003, 325, 1, 0, 0, 0, 4004, 4005, 5, 327, 0, 0, 4005, 4008, 5, 246, 0, 0, 4006, 4007, 5, 62, 0, 0, 4007, 4009, 3, 58, 29, 0, 4008, 4006, 1, 0, 0, 0, 4008, 4009, 1, 0, 0, 0, 4009, 4010, 1, 0, 0, 0, 4010, 4028, 5, 80, 0, 0, 4011, 4012, 7, 32, 0, 0, 4012, 4029, 3, 652, 326, 0, 4013, 4014, 5, 136, 0, 0, 4014, 4029, 3, 394, 197, 0, 4015, 4016, 5, 44, 0, 0, 4016, 4029, 3, 800, 400, 0, 4017, 4018, 5, 211, 0, 0, 4018, 4029, 3, 382, 191, 0, 4019, 4020, 5, 248, 0, 0, 4020, 4021, 5, 274, 0, 0, 4021, 4029, 3, 202, 101, 0, 4022, 4023, 5, 296, 0, 0, 4023, 4029, 3, 378, 189, 0, 4024, 4025, 5, 442, 0, 0, 4025, 4029, 3, 374, 187, 0, 4026, 4029, 3, 310, 155, 0, 4027, 4029, 3, 312, 156, 0, 4028, 4011, 1, 0, 0, 0, 4028, 4013, 1, 0, 0, 0, 4028, 4015, 1, 0, 0, 0, 4028, 4017, 1, 0, 0, 0, 4028, 4019, 1, 0, 0, 0, 4028, 4022, 1, 0, 0, 0, 4028, 4024, 1, 0, 0, 0, 4028, 4026, 1, 0, 0, 0, 4028, 4027, 1, 0, 0, 0, 4029, 4030, 1, 0, 0, 0, 4030, 4033, 5, 116, 0, 0, 4031, 4034, 3, 808, 404, 0, 4032, 4034, 5, 78, 0, 0, 4033, 4031, 1, 0, 0, 0, 4033, 4032, 1, 0, 0, 0, 4034, 327, 1, 0, 0, 0, 4035, 4036, 7, 48, 0, 0, 4036, 4037, 3, 330, 165, 0, 4037, 329, 1, 0, 0, 0, 4038, 4040, 7, 49, 0, 0, 4039, 4038, 1, 0, 0, 0, 4039, 4040, 1, 0, 0, 0, 4040, 4042, 1, 0, 0, 0, 4041, 4043, 3, 332, 166, 0, 4042, 4041, 1, 0, 0, 0, 4042, 4043, 1, 0, 0, 0, 4043, 4044, 1, 0, 0, 0, 4044, 4082, 3, 818, 409, 0, 4045, 4047, 7, 50, 0, 0, 4046, 4045, 1, 0, 0, 0, 4046, 4047, 1, 0, 0, 0, 4047, 4048, 1, 0, 0, 0, 4048, 4050, 3, 812, 406, 0, 4049, 4051, 3, 332, 166, 0, 4050, 4049, 1, 0, 0, 0, 4050, 4051, 1, 0, 0, 0, 4051, 4052, 1, 0, 0, 0, 4052, 4053, 3, 818, 409, 0, 4053, 4082, 1, 0, 0, 0, 4054, 4056, 5, 210, 0, 0, 4055, 4057, 3, 812, 406, 0, 4056, 4055, 1, 0, 0, 0, 4056, 4057, 1, 0, 0, 0, 4057, 4059, 1, 0, 0, 0, 4058, 4060, 3, 332, 166, 0, 4059, 4058, 1, 0, 0, 0, 4059, 4060, 1, 0, 0, 0, 4060, 4061, 1, 0, 0, 0, 4061, 4082, 3, 818, 409, 0, 4062, 4064, 5, 210, 0, 0, 4063, 4062, 1, 0, 0, 0, 4063, 4064, 1, 0, 0, 0, 4064, 4065, 1, 0, 0, 0, 4065, 4067, 5, 30, 0, 0, 4066, 4068, 3, 332, 166, 0, 4067, 4066, 1, 0, 0, 0, 4067, 4068, 1, 0, 0, 0, 4068, 4069, 1, 0, 0, 0, 4069, 4082, 3, 818, 409, 0, 4070, 4075, 5, 144, 0, 0, 4071, 4073, 5, 30, 0, 0, 4072, 4071, 1, 0, 0, 0, 4072, 4073, 1, 0, 0, 0, 4073, 4076, 1, 0, 0, 0, 4074, 4076, 3, 812, 406, 0, 4075, 4072, 1, 0, 0, 0, 4075, 4074, 1, 0, 0, 0, 4076, 4078, 1, 0, 0, 0, 4077, 4079, 3, 332, 166, 0, 4078, 4077, 1, 0, 0, 0, 4078, 4079, 1, 0, 0, 0, 4079, 4080, 1, 0, 0, 0, 4080, 4082, 3, 818, 409, 0, 4081, 4039, 1, 0, 0, 0, 4081, 4046, 1, 0, 0, 0, 4081, 4054, 1, 0, 0, 0, 4081, 4063, 1, 0, 0, 0, 4081, 4070, 1, 0, 0, 0, 4082, 331, 1, 0, 0, 0, 4083, 4084, 7, 51, 0, 0, 4084, 333, 1, 0, 0, 0, 4085, 4086, 5, 65, 0, 0, 4086, 4087, 3, 338, 169, 0, 4087, 4088, 5, 80, 0, 0, 4088, 4089, 3, 344, 172, 0, 4089, 4090, 5, 94, 0, 0, 4090, 4094, 3, 346, 173, 0, 4091, 4092, 5, 105, 0, 0, 4092, 4093, 5, 65, 0, 0, 4093, 4095, 5, 279, 0, 0, 4094, 4091, 1, 0, 0, 0, 4094, 4095, 1, 0, 0, 0, 4095, 335, 1, 0, 0, 0, 4096, 4100, 5, 317, 0, 0, 4097, 4098, 5, 65, 0, 0, 4098, 4099, 5, 279, 0, 0, 4099, 4101, 5, 62, 0, 0, 4100, 4097, 1, 0, 0, 0, 4100, 4101, 1, 0, 0, 0, 4101, 4102, 1, 0, 0, 0, 4102, 4103, 3, 338, 169, 0, 4103, 4104, 5, 80, 0, 0, 4104, 4105, 3, 344, 172, 0, 4105, 4106, 5, 64, 0, 0, 4106, 4108, 3, 346, 173, 0, 4107, 4109, 3, 96, 48, 0, 4108, 4107, 1, 0, 0, 0, 4108, 4109, 1, 0, 0, 0, 4109, 337, 1, 0, 0, 0, 4110, 4115, 3, 342, 171, 0, 4111, 4112, 5, 6, 0, 0, 4112, 4114, 3, 342, 171, 0, 4113, 4111, 1, 0, 0, 0, 4114, 4117, 1, 0, 0, 0, 4115, 4113, 1, 0, 0, 0, 4115, 4116, 1, 0, 0, 0, 4116, 4134, 1, 0, 0, 0, 4117, 4115, 1, 0, 0, 0, 4118, 4120, 5, 30, 0, 0, 4119, 4121, 5, 294, 0, 0, 4120, 4119, 1, 0, 0, 0, 4120, 4121, 1, 0, 0, 0, 4121, 4123, 1, 0, 0, 0, 4122, 4124, 3, 144, 72, 0, 4123, 4122, 1, 0, 0, 0, 4123, 4124, 1, 0, 0, 0, 4124, 4134, 1, 0, 0, 0, 4125, 4130, 3, 340, 170, 0, 4126, 4127, 5, 6, 0, 0, 4127, 4129, 3, 340, 170, 0, 4128, 4126, 1, 0, 0, 0, 4129, 4132, 1, 0, 0, 0, 4130, 4128, 1, 0, 0, 0, 4130, 4131, 1, 0, 0, 0, 4131, 4134, 1, 0, 0, 0, 4132, 4130, 1, 0, 0, 0, 4133, 4110, 1, 0, 0, 0, 4133, 4118, 1, 0, 0, 0, 4133, 4125, 1, 0, 0, 0, 4134, 339, 1, 0, 0, 0, 4135, 4136, 7, 52, 0, 0, 4136, 341, 1, 0, 0, 0, 4137, 4142, 5, 88, 0, 0, 4138, 4142, 5, 86, 0, 0, 4139, 4142, 5, 46, 0, 0, 4140, 4142, 3, 818, 409, 0, 4141, 4137, 1, 0, 0, 0, 4141, 4138, 1, 0, 0, 0, 4141, 4139, 1, 0, 0, 0, 4141, 4140, 1, 0, 0, 0, 4142, 4144, 1, 0, 0, 0, 4143, 4145, 3, 144, 72, 0, 4144, 4143, 1, 0, 0, 0, 4144, 4145, 1, 0, 0, 0, 4145, 343, 1, 0, 0, 0, 4146, 4147, 5, 92, 0, 0, 4147, 4192, 3, 762, 381, 0, 4148, 4150, 5, 328, 0, 0, 4149, 4148, 1, 0, 0, 0, 4149, 4150, 1, 0, 0, 0, 4150, 4151, 1, 0, 0, 0, 4151, 4192, 3, 760, 380, 0, 4152, 4156, 5, 63, 0, 0, 4153, 4154, 5, 174, 0, 0, 4154, 4157, 5, 381, 0, 0, 4155, 4157, 5, 331, 0, 0, 4156, 4153, 1, 0, 0, 0, 4156, 4155, 1, 0, 0, 0, 4157, 4160, 1, 0, 0, 0, 4158, 4160, 5, 247, 0, 0, 4159, 4152, 1, 0, 0, 0, 4159, 4158, 1, 0, 0, 0, 4160, 4161, 1, 0, 0, 0, 4161, 4192, 3, 784, 392, 0, 4162, 4163, 5, 211, 0, 0, 4163, 4192, 3, 380, 190, 0, 4164, 4165, 5, 296, 0, 0, 4165, 4192, 3, 376, 188, 0, 4166, 4167, 5, 442, 0, 0, 4167, 4192, 3, 372, 186, 0, 4168, 4169, 5, 175, 0, 0, 4169, 4192, 3, 766, 383, 0, 4170, 4171, 7, 32, 0, 0, 4171, 4192, 3, 314, 157, 0, 4172, 4173, 5, 248, 0, 0, 4173, 4174, 5, 274, 0, 0, 4174, 4179, 3, 202, 101, 0, 4175, 4176, 5, 6, 0, 0, 4176, 4178, 3, 202, 101, 0, 4177, 4175, 1, 0, 0, 0, 4178, 4181, 1, 0, 0, 0, 4179, 4177, 1, 0, 0, 0, 4179, 4180, 1, 0, 0, 0, 4180, 4192, 1, 0, 0, 0, 4181, 4179, 1, 0, 0, 0, 4182, 4183, 5, 323, 0, 0, 4183, 4192, 3, 764, 382, 0, 4184, 4185, 5, 351, 0, 0, 4185, 4192, 3, 782, 391, 0, 4186, 4187, 5, 30, 0, 0, 4187, 4188, 7, 53, 0, 0, 4188, 4189, 5, 68, 0, 0, 4189, 4190, 5, 323, 0, 0, 4190, 4192, 3, 764, 382, 0, 4191, 4146, 1, 0, 0, 0, 4191, 4149, 1, 0, 0, 0, 4191, 4159, 1, 0, 0, 0, 4191, 4162, 1, 0, 0, 0, 4191, 4164, 1, 0, 0, 0, 4191, 4166, 1, 0, 0, 0, 4191, 4168, 1, 0, 0, 0, 4191, 4170, 1, 0, 0, 0, 4191, 4172, 1, 0, 0, 0, 4191, 4182, 1, 0, 0, 0, 4191, 4184, 1, 0, 0, 0, 4191, 4186, 1, 0, 0, 0, 4192, 345, 1, 0, 0, 0, 4193, 4195, 5, 66, 0, 0, 4194, 4193, 1, 0, 0, 0, 4194, 4195, 1, 0, 0, 0, 4195, 4196, 1, 0, 0, 0, 4196, 4197, 3, 814, 407, 0, 4197, 4205, 1, 0, 0, 0, 4198, 4200, 5, 6, 0, 0, 4199, 4201, 5, 66, 0, 0, 4200, 4199, 1, 0, 0, 0, 4200, 4201, 1, 0, 0, 0, 4201, 4202, 1, 0, 0, 0, 4202, 4204, 3, 814, 407, 0, 4203, 4198, 1, 0, 0, 0, 4204, 4207, 1, 0, 0, 0, 4205, 4203, 1, 0, 0, 0, 4205, 4206, 1, 0, 0, 0, 4206, 347, 1, 0, 0, 0, 4207, 4205, 1, 0, 0, 0, 4208, 4209, 5, 65, 0, 0, 4209, 4214, 3, 342, 171, 0, 4210, 4211, 5, 6, 0, 0, 4211, 4213, 3, 342, 171, 0, 4212, 4210, 1, 0, 0, 0, 4213, 4216, 1, 0, 0, 0, 4214, 4212, 1, 0, 0, 0, 4214, 4215, 1, 0, 0, 0, 4215, 4217, 1, 0, 0, 0, 4216, 4214, 1, 0, 0, 0, 4217, 4218, 5, 94, 0, 0, 4218, 4222, 3, 816, 408, 0, 4219, 4220, 5, 105, 0, 0, 4220, 4221, 5, 134, 0, 0, 4221, 4223, 5, 279, 0, 0, 4222, 4219, 1, 0, 0, 0, 4222, 4223, 1, 0, 0, 0, 4223, 4227, 1, 0, 0, 0, 4224, 4225, 5, 214, 0, 0, 4225, 4226, 5, 147, 0, 0, 4226, 4228, 3, 814, 407, 0, 4227, 4224, 1, 0, 0, 0, 4227, 4228, 1, 0, 0, 0, 4228, 349, 1, 0, 0, 0, 4229, 4233, 5, 317, 0, 0, 4230, 4231, 5, 134, 0, 0, 4231, 4232, 5, 279, 0, 0, 4232, 4234, 5, 62, 0, 0, 4233, 4230, 1, 0, 0, 0, 4233, 4234, 1, 0, 0, 0, 4234, 4235, 1, 0, 0, 0, 4235, 4240, 3, 342, 171, 0, 4236, 4237, 5, 6, 0, 0, 4237, 4239, 3, 342, 171, 0, 4238, 4236, 1, 0, 0, 0, 4239, 4242, 1, 0, 0, 0, 4240, 4238, 1, 0, 0, 0, 4240, 4241, 1, 0, 0, 0, 4241, 4243, 1, 0, 0, 0, 4242, 4240, 1, 0, 0, 0, 4243, 4244, 5, 64, 0, 0, 4244, 4248, 3, 816, 408, 0, 4245, 4246, 5, 214, 0, 0, 4246, 4247, 5, 147, 0, 0, 4247, 4249, 3, 814, 407, 0, 4248, 4245, 1, 0, 0, 0, 4248, 4249, 1, 0, 0, 0, 4249, 4251, 1, 0, 0, 0, 4250, 4252, 3, 96, 48, 0, 4251, 4250, 1, 0, 0, 0, 4251, 4252, 1, 0, 0, 0, 4252, 351, 1, 0, 0, 0, 4253, 4254, 5, 138, 0, 0, 4254, 4255, 5, 53, 0, 0, 4255, 4264, 5, 294, 0, 0, 4256, 4257, 5, 68, 0, 0, 4257, 4258, 5, 323, 0, 0, 4258, 4263, 3, 764, 382, 0, 4259, 4260, 5, 62, 0, 0, 4260, 4261, 7, 2, 0, 0, 4261, 4263, 3, 816, 408, 0, 4262, 4256, 1, 0, 0, 0, 4262, 4259, 1, 0, 0, 0, 4263, 4266, 1, 0, 0, 0, 4264, 4262, 1, 0, 0, 0, 4264, 4265, 1, 0, 0, 0, 4265, 4267, 1, 0, 0, 0, 4266, 4264, 1, 0, 0, 0, 4267, 4268, 3, 354, 177, 0, 4268, 353, 1, 0, 0, 0, 4269, 4270, 5, 65, 0, 0, 4270, 4271, 3, 338, 169, 0, 4271, 4272, 5, 80, 0, 0, 4272, 4273, 3, 356, 178, 0, 4273, 4274, 5, 94, 0, 0, 4274, 4278, 3, 346, 173, 0, 4275, 4276, 5, 105, 0, 0, 4276, 4277, 5, 65, 0, 0, 4277, 4279, 5, 279, 0, 0, 4278, 4275, 1, 0, 0, 0, 4278, 4279, 1, 0, 0, 0, 4279, 4295, 1, 0, 0, 0, 4280, 4284, 5, 317, 0, 0, 4281, 4282, 5, 65, 0, 0, 4282, 4283, 5, 279, 0, 0, 4283, 4285, 5, 62, 0, 0, 4284, 4281, 1, 0, 0, 0, 4284, 4285, 1, 0, 0, 0, 4285, 4286, 1, 0, 0, 0, 4286, 4287, 3, 338, 169, 0, 4287, 4288, 5, 80, 0, 0, 4288, 4289, 3, 356, 178, 0, 4289, 4290, 5, 64, 0, 0, 4290, 4292, 3, 346, 173, 0, 4291, 4293, 3, 96, 48, 0, 4292, 4291, 1, 0, 0, 0, 4292, 4293, 1, 0, 0, 0, 4293, 4295, 1, 0, 0, 0, 4294, 4269, 1, 0, 0, 0, 4294, 4280, 1, 0, 0, 0, 4295, 355, 1, 0, 0, 0, 4296, 4297, 7, 54, 0, 0, 4297, 357, 1, 0, 0, 0, 4298, 4300, 5, 46, 0, 0, 4299, 4301, 5, 98, 0, 0, 4300, 4299, 1, 0, 0, 0, 4300, 4301, 1, 0, 0, 0, 4301, 4302, 1, 0, 0, 0, 4302, 4304, 5, 226, 0, 0, 4303, 4305, 5, 109, 0, 0, 4304, 4303, 1, 0, 0, 0, 4304, 4305, 1, 0, 0, 0, 4305, 4307, 1, 0, 0, 0, 4306, 4308, 3, 294, 147, 0, 4307, 4306, 1, 0, 0, 0, 4307, 4308, 1, 0, 0, 0, 4308, 4310, 1, 0, 0, 0, 4309, 4311, 3, 818, 409, 0, 4310, 4309, 1, 0, 0, 0, 4310, 4311, 1, 0, 0, 0, 4311, 4312, 1, 0, 0, 0, 4312, 4313, 5, 80, 0, 0, 4313, 4315, 3, 624, 312, 0, 4314, 4316, 3, 170, 85, 0, 4315, 4314, 1, 0, 0, 0, 4315, 4316, 1, 0, 0, 0, 4316, 4317, 1, 0, 0, 0, 4317, 4320, 3, 360, 180, 0, 4318, 4319, 5, 441, 0, 0, 4319, 4321, 3, 360, 180, 0, 4320, 4318, 1, 0, 0, 0, 4320, 4321, 1, 0, 0, 0, 4321, 4327, 1, 0, 0, 0, 4322, 4324, 5, 273, 0, 0, 4323, 4325, 5, 77, 0, 0, 4324, 4323, 1, 0, 0, 0, 4324, 4325, 1, 0, 0, 0, 4325, 4326, 1, 0, 0, 0, 4326, 4328, 5, 56, 0, 0, 4327, 4322, 1, 0, 0, 0, 4327, 4328, 1, 0, 0, 0, 4328, 4330, 1, 0, 0, 0, 4329, 4331, 3, 102, 51, 0, 4330, 4329, 1, 0, 0, 0, 4330, 4331, 1, 0, 0, 0, 4331, 4333, 1, 0, 0, 0, 4332, 4334, 3, 176, 88, 0, 4333, 4332, 1, 0, 0, 0, 4333, 4334, 1, 0, 0, 0, 4334, 4336, 1, 0, 0, 0, 4335, 4337, 3, 638, 319, 0, 4336, 4335, 1, 0, 0, 0, 4336, 4337, 1, 0, 0, 0, 4337, 359, 1, 0, 0, 0, 4338, 4339, 5, 2, 0, 0, 4339, 4344, 3, 362, 181, 0, 4340, 4341, 5, 6, 0, 0, 4341, 4343, 3, 362, 181, 0, 4342, 4340, 1, 0, 0, 0, 4343, 4346, 1, 0, 0, 0, 4344, 4342, 1, 0, 0, 0, 4344, 4345, 1, 0, 0, 0, 4345, 4347, 1, 0, 0, 0, 4346, 4344, 1, 0, 0, 0, 4347, 4348, 5, 3, 0, 0, 4348, 361, 1, 0, 0, 0, 4349, 4356, 3, 800, 400, 0, 4350, 4356, 3, 688, 344, 0, 4351, 4352, 5, 2, 0, 0, 4352, 4353, 3, 674, 337, 0, 4353, 4354, 5, 3, 0, 0, 4354, 4356, 1, 0, 0, 0, 4355, 4349, 1, 0, 0, 0, 4355, 4350, 1, 0, 0, 0, 4355, 4351, 1, 0, 0, 0, 4356, 4358, 1, 0, 0, 0, 4357, 4359, 3, 98, 49, 0, 4358, 4357, 1, 0, 0, 0, 4358, 4359, 1, 0, 0, 0, 4359, 4366, 1, 0, 0, 0, 4360, 4362, 3, 316, 158, 0, 4361, 4360, 1, 0, 0, 0, 4361, 4362, 1, 0, 0, 0, 4362, 4367, 1, 0, 0, 0, 4363, 4364, 3, 316, 158, 0, 4364, 4365, 3, 100, 50, 0, 4365, 4367, 1, 0, 0, 0, 4366, 4361, 1, 0, 0, 0, 4366, 4363, 1, 0, 0, 0, 4367, 4369, 1, 0, 0, 0, 4368, 4370, 7, 55, 0, 0, 4369, 4368, 1, 0, 0, 0, 4369, 4370, 1, 0, 0, 0, 4370, 4373, 1, 0, 0, 0, 4371, 4372, 5, 273, 0, 0, 4372, 4374, 7, 56, 0, 0, 4373, 4371, 1, 0, 0, 0, 4373, 4374, 1, 0, 0, 0, 4374, 363, 1, 0, 0, 0, 4375, 4377, 5, 46, 0, 0, 4376, 4378, 3, 366, 183, 0, 4377, 4376, 1, 0, 0, 0, 4377, 4378, 1, 0, 0, 0, 4378, 4383, 1, 0, 0, 0, 4379, 4380, 5, 211, 0, 0, 4380, 4384, 3, 804, 402, 0, 4381, 4382, 5, 296, 0, 0, 4382, 4384, 3, 798, 399, 0, 4383, 4379, 1, 0, 0, 0, 4383, 4381, 1, 0, 0, 0, 4384, 4385, 1, 0, 0, 0, 4385, 4394, 5, 2, 0, 0, 4386, 4391, 3, 390, 195, 0, 4387, 4388, 5, 6, 0, 0, 4388, 4390, 3, 390, 195, 0, 4389, 4387, 1, 0, 0, 0, 4390, 4393, 1, 0, 0, 0, 4391, 4389, 1, 0, 0, 0, 4391, 4392, 1, 0, 0, 0, 4392, 4395, 1, 0, 0, 0, 4393, 4391, 1, 0, 0, 0, 4394, 4386, 1, 0, 0, 0, 4394, 4395, 1, 0, 0, 0, 4395, 4396, 1, 0, 0, 0, 4396, 4397, 5, 3, 0, 0, 4397, 4414, 1, 0, 0, 0, 4398, 4412, 5, 316, 0, 0, 4399, 4413, 3, 388, 194, 0, 4400, 4401, 5, 92, 0, 0, 4401, 4402, 5, 2, 0, 0, 4402, 4407, 3, 402, 201, 0, 4403, 4404, 5, 6, 0, 0, 4404, 4406, 3, 402, 201, 0, 4405, 4403, 1, 0, 0, 0, 4406, 4409, 1, 0, 0, 0, 4407, 4405, 1, 0, 0, 0, 4407, 4408, 1, 0, 0, 0, 4408, 4410, 1, 0, 0, 0, 4409, 4407, 1, 0, 0, 0, 4410, 4411, 5, 3, 0, 0, 4411, 4413, 1, 0, 0, 0, 4412, 4399, 1, 0, 0, 0, 4412, 4400, 1, 0, 0, 0, 4413, 4415, 1, 0, 0, 0, 4414, 4398, 1, 0, 0, 0, 4414, 4415, 1, 0, 0, 0, 4415, 4417, 1, 0, 0, 0, 4416, 4418, 3, 398, 199, 0, 4417, 4416, 1, 0, 0, 0, 4418, 4419, 1, 0, 0, 0, 4419, 4417, 1, 0, 0, 0, 4419, 4420, 1, 0, 0, 0, 4420, 4426, 1, 0, 0, 0, 4421, 4422, 5, 105, 0, 0, 4422, 4423, 5, 2, 0, 0, 4423, 4424, 3, 784, 392, 0, 4424, 4425, 5, 3, 0, 0, 4425, 4427, 1, 0, 0, 0, 4426, 4421, 1, 0, 0, 0, 4426, 4427, 1, 0, 0, 0, 4427, 365, 1, 0, 0, 0, 4428, 4429, 5, 82, 0, 0, 4429, 4430, 5, 311, 0, 0, 4430, 367, 1, 0, 0, 0, 4431, 4433, 5, 2, 0, 0, 4432, 4434, 3, 370, 185, 0, 4433, 4432, 1, 0, 0, 0, 4433, 4434, 1, 0, 0, 0, 4434, 4435, 1, 0, 0, 0, 4435, 4436, 5, 3, 0, 0, 4436, 369, 1, 0, 0, 0, 4437, 4442, 3, 384, 192, 0, 4438, 4439, 5, 6, 0, 0, 4439, 4441, 3, 384, 192, 0, 4440, 4438, 1, 0, 0, 0, 4441, 4444, 1, 0, 0, 0, 4442, 4440, 1, 0, 0, 0, 4442, 4443, 1, 0, 0, 0, 4443, 371, 1, 0, 0, 0, 4444, 4442, 1, 0, 0, 0, 4445, 4450, 3, 374, 187, 0, 4446, 4447, 5, 6, 0, 0, 4447, 4449, 3, 374, 187, 0, 4448, 4446, 1, 0, 0, 0, 4449, 4452, 1, 0, 0, 0, 4450, 4448, 1, 0, 0, 0, 4450, 4451, 1, 0, 0, 0, 4451, 373, 1, 0, 0, 0, 4452, 4450, 1, 0, 0, 0, 4453, 4454, 3, 794, 397, 0, 4454, 4455, 3, 368, 184, 0, 4455, 4459, 1, 0, 0, 0, 4456, 4459, 3, 832, 416, 0, 4457, 4459, 3, 780, 390, 0, 4458, 4453, 1, 0, 0, 0, 4458, 4456, 1, 0, 0, 0, 4458, 4457, 1, 0, 0, 0, 4459, 375, 1, 0, 0, 0, 4460, 4465, 3, 378, 189, 0, 4461, 4462, 5, 6, 0, 0, 4462, 4464, 3, 378, 189, 0, 4463, 4461, 1, 0, 0, 0, 4464, 4467, 1, 0, 0, 0, 4465, 4463, 1, 0, 0, 0, 4465, 4466, 1, 0, 0, 0, 4466, 377, 1, 0, 0, 0, 4467, 4465, 1, 0, 0, 0, 4468, 4469, 3, 796, 398, 0, 4469, 4470, 3, 368, 184, 0, 4470, 4474, 1, 0, 0, 0, 4471, 4474, 3, 832, 416, 0, 4472, 4474, 3, 780, 390, 0, 4473, 4468, 1, 0, 0, 0, 4473, 4471, 1, 0, 0, 0, 4473, 4472, 1, 0, 0, 0, 4474, 379, 1, 0, 0, 0, 4475, 4480, 3, 382, 191, 0, 4476, 4477, 5, 6, 0, 0, 4477, 4479, 3, 382, 191, 0, 4478, 4476, 1, 0, 0, 0, 4479, 4482, 1, 0, 0, 0, 4480, 4478, 1, 0, 0, 0, 4480, 4481, 1, 0, 0, 0, 4481, 381, 1, 0, 0, 0, 4482, 4480, 1, 0, 0, 0, 4483, 4484, 3, 806, 403, 0, 4484, 4485, 3, 368, 184, 0, 4485, 4489, 1, 0, 0, 0, 4486, 4489, 3, 832, 416, 0, 4487, 4489, 3, 780, 390, 0, 4488, 4483, 1, 0, 0, 0, 4488, 4486, 1, 0, 0, 0, 4488, 4487, 1, 0, 0, 0, 4489, 383, 1, 0, 0, 0, 4490, 4492, 3, 386, 193, 0, 4491, 4493, 3, 820, 410, 0, 4492, 4491, 1, 0, 0, 0, 4492, 4493, 1, 0, 0, 0, 4493, 4499, 1, 0, 0, 0, 4494, 4496, 3, 820, 410, 0, 4495, 4497, 3, 386, 193, 0, 4496, 4495, 1, 0, 0, 0, 4496, 4497, 1, 0, 0, 0, 4497, 4499, 1, 0, 0, 0, 4498, 4490, 1, 0, 0, 0, 4498, 4494, 1, 0, 0, 0, 4498, 4499, 1, 0, 0, 0, 4499, 4500, 1, 0, 0, 0, 4500, 4501, 3, 388, 194, 0, 4501, 385, 1, 0, 0, 0, 4502, 4504, 5, 68, 0, 0, 4503, 4505, 5, 453, 0, 0, 4504, 4503, 1, 0, 0, 0, 4504, 4505, 1, 0, 0, 0, 4505, 4510, 1, 0, 0, 0, 4506, 4510, 5, 453, 0, 0, 4507, 4510, 5, 400, 0, 0, 4508, 4510, 5, 101, 0, 0, 4509, 4502, 1, 0, 0, 0, 4509, 4506, 1, 0, 0, 0, 4509, 4507, 1, 0, 0, 0, 4509, 4508, 1, 0, 0, 0, 4510, 387, 1, 0, 0, 0, 4511, 4521, 3, 652, 326, 0, 4512, 4514, 5, 415, 0, 0, 4513, 4512, 1, 0, 0, 0, 4513, 4514, 1, 0, 0, 0, 4514, 4515, 1, 0, 0, 0, 4515, 4516, 3, 820, 410, 0, 4516, 4517, 3, 318, 159, 0, 4517, 4518, 5, 27, 0, 0, 4518, 4519, 5, 360, 0, 0, 4519, 4521, 1, 0, 0, 0, 4520, 4511, 1, 0, 0, 0, 4520, 4513, 1, 0, 0, 0, 4521, 389, 1, 0, 0, 0, 4522, 4525, 3, 384, 192, 0, 4523, 4524, 7, 57, 0, 0, 4524, 4526, 3, 674, 337, 0, 4525, 4523, 1, 0, 0, 0, 4525, 4526, 1, 0, 0, 0, 4526, 391, 1, 0, 0, 0, 4527, 4537, 5, 2, 0, 0, 4528, 4538, 5, 9, 0, 0, 4529, 4531, 3, 370, 185, 0, 4530, 4529, 1, 0, 0, 0, 4530, 4531, 1, 0, 0, 0, 4531, 4535, 1, 0, 0, 0, 4532, 4533, 5, 83, 0, 0, 4533, 4534, 5, 147, 0, 0, 4534, 4536, 3, 370, 185, 0, 4535, 4532, 1, 0, 0, 0, 4535, 4536, 1, 0, 0, 0, 4536, 4538, 1, 0, 0, 0, 4537, 4528, 1, 0, 0, 0, 4537, 4530, 1, 0, 0, 0, 4538, 4539, 1, 0, 0, 0, 4539, 4540, 5, 3, 0, 0, 4540, 393, 1, 0, 0, 0, 4541, 4542, 3, 806, 403, 0, 4542, 4543, 3, 392, 196, 0, 4543, 395, 1, 0, 0, 0, 4544, 4545, 5, 316, 0, 0, 4545, 4548, 5, 78, 0, 0, 4546, 4548, 5, 149, 0, 0, 4547, 4544, 1, 0, 0, 0, 4547, 4546, 1, 0, 0, 0, 4548, 4549, 1, 0, 0, 0, 4549, 4550, 5, 80, 0, 0, 4550, 4551, 5, 78, 0, 0, 4551, 4574, 5, 458, 0, 0, 4552, 4574, 5, 346, 0, 0, 4553, 4574, 5, 222, 0, 0, 4554, 4574, 5, 338, 0, 0, 4555, 4574, 5, 377, 0, 0, 4556, 4558, 5, 205, 0, 0, 4557, 4556, 1, 0, 0, 0, 4557, 4558, 1, 0, 0, 0, 4558, 4559, 1, 0, 0, 0, 4559, 4560, 5, 327, 0, 0, 4560, 4574, 7, 58, 0, 0, 4561, 4574, 5, 250, 0, 0, 4562, 4563, 5, 77, 0, 0, 4563, 4574, 5, 250, 0, 0, 4564, 4565, 7, 59, 0, 0, 4565, 4574, 3, 202, 101, 0, 4566, 4567, 5, 459, 0, 0, 4567, 4574, 3, 316, 158, 0, 4568, 4569, 5, 333, 0, 0, 4569, 4574, 3, 42, 21, 0, 4570, 4574, 3, 60, 30, 0, 4571, 4572, 5, 460, 0, 0, 4572, 4574, 3, 818, 409, 0, 4573, 4547, 1, 0, 0, 0, 4573, 4552, 1, 0, 0, 0, 4573, 4553, 1, 0, 0, 0, 4573, 4554, 1, 0, 0, 0, 4573, 4555, 1, 0, 0, 0, 4573, 4557, 1, 0, 0, 0, 4573, 4561, 1, 0, 0, 0, 4573, 4562, 1, 0, 0, 0, 4573, 4564, 1, 0, 0, 0, 4573, 4566, 1, 0, 0, 0, 4573, 4568, 1, 0, 0, 0, 4573, 4570, 1, 0, 0, 0, 4573, 4571, 1, 0, 0, 0, 4574, 397, 1, 0, 0, 0, 4575, 4576, 5, 36, 0, 0, 4576, 4577, 3, 808, 404, 0, 4577, 4578, 3, 462, 231, 0, 4578, 4611, 1, 0, 0, 0, 4579, 4580, 5, 247, 0, 0, 4580, 4611, 3, 58, 29, 0, 4581, 4582, 5, 443, 0, 0, 4582, 4583, 5, 62, 0, 0, 4583, 4584, 5, 360, 0, 0, 4584, 4591, 3, 652, 326, 0, 4585, 4586, 5, 6, 0, 0, 4586, 4587, 5, 62, 0, 0, 4587, 4588, 5, 360, 0, 0, 4588, 4590, 3, 652, 326, 0, 4589, 4585, 1, 0, 0, 0, 4590, 4593, 1, 0, 0, 0, 4591, 4589, 1, 0, 0, 0, 4591, 4592, 1, 0, 0, 0, 4592, 4611, 1, 0, 0, 0, 4593, 4591, 1, 0, 0, 0, 4594, 4611, 5, 104, 0, 0, 4595, 4596, 5, 333, 0, 0, 4596, 4603, 3, 818, 409, 0, 4597, 4598, 5, 94, 0, 0, 4598, 4604, 3, 818, 409, 0, 4599, 4600, 5, 10, 0, 0, 4600, 4604, 3, 818, 409, 0, 4601, 4602, 5, 64, 0, 0, 4602, 4604, 5, 434, 0, 0, 4603, 4597, 1, 0, 0, 0, 4603, 4599, 1, 0, 0, 0, 4603, 4601, 1, 0, 0, 0, 4604, 4611, 1, 0, 0, 0, 4605, 4606, 5, 36, 0, 0, 4606, 4611, 3, 818, 409, 0, 4607, 4611, 3, 4, 2, 0, 4608, 4611, 3, 396, 198, 0, 4609, 4611, 3, 818, 409, 0, 4610, 4575, 1, 0, 0, 0, 4610, 4579, 1, 0, 0, 0, 4610, 4581, 1, 0, 0, 0, 4610, 4594, 1, 0, 0, 0, 4610, 4595, 1, 0, 0, 0, 4610, 4605, 1, 0, 0, 0, 4610, 4607, 1, 0, 0, 0, 4610, 4608, 1, 0, 0, 0, 4610, 4609, 1, 0, 0, 0, 4611, 399, 1, 0, 0, 0, 4612, 4613, 5, 105, 0, 0, 4613, 4614, 3, 284, 142, 0, 4614, 401, 1, 0, 0, 0, 4615, 4616, 3, 800, 400, 0, 4616, 4617, 3, 388, 194, 0, 4617, 403, 1, 0, 0, 0, 4618, 4625, 5, 138, 0, 0, 4619, 4620, 5, 211, 0, 0, 4620, 4626, 3, 382, 191, 0, 4621, 4622, 5, 296, 0, 0, 4622, 4626, 3, 378, 189, 0, 4623, 4624, 5, 442, 0, 0, 4624, 4626, 3, 374, 187, 0, 4625, 4619, 1, 0, 0, 0, 4625, 4621, 1, 0, 0, 0, 4625, 4623, 1, 0, 0, 0, 4626, 4628, 1, 0, 0, 0, 4627, 4629, 3, 396, 198, 0, 4628, 4627, 1, 0, 0, 0, 4629, 4630, 1, 0, 0, 0, 4630, 4628, 1, 0, 0, 0, 4630, 4631, 1, 0, 0, 0, 4631, 4633, 1, 0, 0, 0, 4632, 4634, 5, 315, 0, 0, 4633, 4632, 1, 0, 0, 0, 4633, 4634, 1, 0, 0, 0, 4634, 405, 1, 0, 0, 0, 4635, 4651, 5, 191, 0, 0, 4636, 4638, 5, 211, 0, 0, 4637, 4639, 3, 422, 211, 0, 4638, 4637, 1, 0, 0, 0, 4638, 4639, 1, 0, 0, 0, 4639, 4640, 1, 0, 0, 0, 4640, 4652, 3, 380, 190, 0, 4641, 4643, 5, 296, 0, 0, 4642, 4644, 3, 422, 211, 0, 4643, 4642, 1, 0, 0, 0, 4643, 4644, 1, 0, 0, 0, 4644, 4645, 1, 0, 0, 0, 4645, 4652, 3, 376, 188, 0, 4646, 4648, 5, 442, 0, 0, 4647, 4649, 3, 422, 211, 0, 4648, 4647, 1, 0, 0, 0, 4648, 4649, 1, 0, 0, 0, 4649, 4650, 1, 0, 0, 0, 4650, 4652, 3, 372, 186, 0, 4651, 4636, 1, 0, 0, 0, 4651, 4641, 1, 0, 0, 0, 4651, 4646, 1, 0, 0, 0, 4652, 4654, 1, 0, 0, 0, 4653, 4655, 3, 96, 48, 0, 4654, 4653, 1, 0, 0, 0, 4654, 4655, 1, 0, 0, 0, 4655, 407, 1, 0, 0, 0, 4656, 4657, 5, 191, 0, 0, 4657, 4659, 5, 136, 0, 0, 4658, 4660, 3, 422, 211, 0, 4659, 4658, 1, 0, 0, 0, 4659, 4660, 1, 0, 0, 0, 4660, 4661, 1, 0, 0, 0, 4661, 4666, 3, 394, 197, 0, 4662, 4663, 5, 6, 0, 0, 4663, 4665, 3, 394, 197, 0, 4664, 4662, 1, 0, 0, 0, 4665, 4668, 1, 0, 0, 0, 4666, 4664, 1, 0, 0, 0, 4666, 4667, 1, 0, 0, 0, 4667, 4670, 1, 0, 0, 0, 4668, 4666, 1, 0, 0, 0, 4669, 4671, 3, 96, 48, 0, 4670, 4669, 1, 0, 0, 0, 4670, 4671, 1, 0, 0, 0, 4671, 409, 1, 0, 0, 0, 4672, 4673, 5, 191, 0, 0, 4673, 4675, 5, 278, 0, 0, 4674, 4676, 3, 422, 211, 0, 4675, 4674, 1, 0, 0, 0, 4675, 4676, 1, 0, 0, 0, 4676, 4677, 1, 0, 0, 0, 4677, 4682, 3, 416, 208, 0, 4678, 4679, 5, 6, 0, 0, 4679, 4681, 3, 416, 208, 0, 4680, 4678, 1, 0, 0, 0, 4681, 4684, 1, 0, 0, 0, 4682, 4680, 1, 0, 0, 0, 4682, 4683, 1, 0, 0, 0, 4683, 4686, 1, 0, 0, 0, 4684, 4682, 1, 0, 0, 0, 4685, 4687, 3, 96, 48, 0, 4686, 4685, 1, 0, 0, 0, 4686, 4687, 1, 0, 0, 0, 4687, 411, 1, 0, 0, 0, 4688, 4701, 5, 2, 0, 0, 4689, 4692, 3, 652, 326, 0, 4690, 4691, 5, 6, 0, 0, 4691, 4693, 3, 652, 326, 0, 4692, 4690, 1, 0, 0, 0, 4692, 4693, 1, 0, 0, 0, 4693, 4702, 1, 0, 0, 0, 4694, 4695, 5, 407, 0, 0, 4695, 4696, 5, 6, 0, 0, 4696, 4702, 3, 652, 326, 0, 4697, 4698, 3, 652, 326, 0, 4698, 4699, 5, 6, 0, 0, 4699, 4700, 5, 407, 0, 0, 4700, 4702, 1, 0, 0, 0, 4701, 4689, 1, 0, 0, 0, 4701, 4694, 1, 0, 0, 0, 4701, 4697, 1, 0, 0, 0, 4702, 4703, 1, 0, 0, 0, 4703, 4704, 5, 3, 0, 0, 4704, 413, 1, 0, 0, 0, 4705, 4706, 3, 818, 409, 0, 4706, 4707, 5, 11, 0, 0, 4707, 4709, 1, 0, 0, 0, 4708, 4705, 1, 0, 0, 0, 4709, 4712, 1, 0, 0, 0, 4710, 4708, 1, 0, 0, 0, 4710, 4711, 1, 0, 0, 0, 4711, 4713, 1, 0, 0, 0, 4712, 4710, 1, 0, 0, 0, 4713, 4714, 3, 720, 360, 0, 4714, 415, 1, 0, 0, 0, 4715, 4716, 3, 414, 207, 0, 4716, 4717, 3, 412, 206, 0, 4717, 417, 1, 0, 0, 0, 4718, 4722, 5, 57, 0, 0, 4719, 4723, 3, 808, 404, 0, 4720, 4721, 5, 247, 0, 0, 4721, 4723, 3, 58, 29, 0, 4722, 4719, 1, 0, 0, 0, 4722, 4720, 1, 0, 0, 0, 4723, 4724, 1, 0, 0, 0, 4724, 4722, 1, 0, 0, 0, 4724, 4725, 1, 0, 0, 0, 4725, 419, 1, 0, 0, 0, 4726, 4727, 5, 46, 0, 0, 4727, 4728, 5, 41, 0, 0, 4728, 4729, 5, 2, 0, 0, 4729, 4730, 3, 652, 326, 0, 4730, 4731, 5, 36, 0, 0, 4731, 4732, 3, 652, 326, 0, 4732, 4749, 5, 3, 0, 0, 4733, 4734, 5, 379, 0, 0, 4734, 4737, 5, 211, 0, 0, 4735, 4736, 5, 36, 0, 0, 4736, 4738, 7, 60, 0, 0, 4737, 4735, 1, 0, 0, 0, 4737, 4738, 1, 0, 0, 0, 4738, 4750, 1, 0, 0, 0, 4739, 4743, 5, 105, 0, 0, 4740, 4741, 5, 211, 0, 0, 4741, 4744, 3, 382, 191, 0, 4742, 4744, 5, 400, 0, 0, 4743, 4740, 1, 0, 0, 0, 4743, 4742, 1, 0, 0, 0, 4744, 4747, 1, 0, 0, 0, 4745, 4746, 5, 36, 0, 0, 4746, 4748, 7, 60, 0, 0, 4747, 4745, 1, 0, 0, 0, 4747, 4748, 1, 0, 0, 0, 4748, 4750, 1, 0, 0, 0, 4749, 4733, 1, 0, 0, 0, 4749, 4739, 1, 0, 0, 0, 4750, 421, 1, 0, 0, 0, 4751, 4752, 5, 220, 0, 0, 4752, 4753, 5, 396, 0, 0, 4753, 423, 1, 0, 0, 0, 4754, 4756, 5, 46, 0, 0, 4755, 4757, 3, 366, 183, 0, 4756, 4755, 1, 0, 0, 0, 4756, 4757, 1, 0, 0, 0, 4757, 4758, 1, 0, 0, 0, 4758, 4759, 5, 443, 0, 0, 4759, 4760, 5, 62, 0, 0, 4760, 4761, 3, 652, 326, 0, 4761, 4762, 5, 247, 0, 0, 4762, 4763, 3, 818, 409, 0, 4763, 4778, 5, 2, 0, 0, 4764, 4765, 5, 64, 0, 0, 4765, 4769, 3, 426, 213, 0, 4766, 4767, 5, 6, 0, 0, 4767, 4768, 5, 94, 0, 0, 4768, 4770, 3, 426, 213, 0, 4769, 4766, 1, 0, 0, 0, 4769, 4770, 1, 0, 0, 0, 4770, 4779, 1, 0, 0, 0, 4771, 4772, 5, 94, 0, 0, 4772, 4776, 3, 426, 213, 0, 4773, 4774, 5, 6, 0, 0, 4774, 4775, 5, 64, 0, 0, 4775, 4777, 3, 426, 213, 0, 4776, 4773, 1, 0, 0, 0, 4776, 4777, 1, 0, 0, 0, 4777, 4779, 1, 0, 0, 0, 4778, 4764, 1, 0, 0, 0, 4778, 4771, 1, 0, 0, 0, 4779, 4780, 1, 0, 0, 0, 4780, 4781, 5, 3, 0, 0, 4781, 425, 1, 0, 0, 0, 4782, 4783, 5, 461, 0, 0, 4783, 4784, 5, 105, 0, 0, 4784, 4785, 5, 211, 0, 0, 4785, 4786, 3, 382, 191, 0, 4786, 427, 1, 0, 0, 0, 4787, 4798, 5, 306, 0, 0, 4788, 4789, 5, 2, 0, 0, 4789, 4794, 5, 128, 0, 0, 4790, 4791, 5, 6, 0, 0, 4791, 4793, 5, 128, 0, 0, 4792, 4790, 1, 0, 0, 0, 4793, 4796, 1, 0, 0, 0, 4794, 4792, 1, 0, 0, 0, 4794, 4795, 1, 0, 0, 0, 4795, 4797, 1, 0, 0, 0, 4796, 4794, 1, 0, 0, 0, 4797, 4799, 5, 3, 0, 0, 4798, 4788, 1, 0, 0, 0, 4798, 4799, 1, 0, 0, 0, 4799, 4825, 1, 0, 0, 0, 4800, 4802, 5, 226, 0, 0, 4801, 4803, 5, 109, 0, 0, 4802, 4801, 1, 0, 0, 0, 4802, 4803, 1, 0, 0, 0, 4803, 4804, 1, 0, 0, 0, 4804, 4826, 3, 780, 390, 0, 4805, 4807, 5, 92, 0, 0, 4806, 4808, 5, 109, 0, 0, 4807, 4806, 1, 0, 0, 0, 4807, 4808, 1, 0, 0, 0, 4808, 4809, 1, 0, 0, 0, 4809, 4826, 3, 774, 387, 0, 4810, 4812, 5, 323, 0, 0, 4811, 4813, 5, 109, 0, 0, 4812, 4811, 1, 0, 0, 0, 4812, 4813, 1, 0, 0, 0, 4813, 4814, 1, 0, 0, 0, 4814, 4826, 3, 790, 395, 0, 4815, 4817, 5, 349, 0, 0, 4816, 4818, 5, 109, 0, 0, 4817, 4816, 1, 0, 0, 0, 4817, 4818, 1, 0, 0, 0, 4818, 4819, 1, 0, 0, 0, 4819, 4826, 3, 818, 409, 0, 4820, 4822, 5, 175, 0, 0, 4821, 4823, 5, 109, 0, 0, 4822, 4821, 1, 0, 0, 0, 4822, 4823, 1, 0, 0, 0, 4823, 4824, 1, 0, 0, 0, 4824, 4826, 3, 788, 394, 0, 4825, 4800, 1, 0, 0, 0, 4825, 4805, 1, 0, 0, 0, 4825, 4810, 1, 0, 0, 0, 4825, 4815, 1, 0, 0, 0, 4825, 4820, 1, 0, 0, 0, 4826, 429, 1, 0, 0, 0, 4827, 4828, 5, 138, 0, 0, 4828, 4829, 3, 176, 88, 0, 4829, 4830, 7, 16, 0, 0, 4830, 4831, 3, 100, 50, 0, 4831, 431, 1, 0, 0, 0, 4832, 4837, 5, 138, 0, 0, 4833, 4834, 5, 136, 0, 0, 4834, 4838, 3, 394, 197, 0, 4835, 4836, 5, 442, 0, 0, 4836, 4838, 3, 374, 187, 0, 4837, 4833, 1, 0, 0, 0, 4837, 4835, 1, 0, 0, 0, 4838, 4839, 1, 0, 0, 0, 4839, 4840, 5, 309, 0, 0, 4840, 4841, 5, 94, 0, 0, 4841, 4842, 3, 818, 409, 0, 4842, 5040, 1, 0, 0, 0, 4843, 4844, 5, 138, 0, 0, 4844, 4845, 5, 175, 0, 0, 4845, 4846, 3, 788, 394, 0, 4846, 4847, 5, 309, 0, 0, 4847, 4848, 5, 94, 0, 0, 4848, 4849, 3, 786, 393, 0, 4849, 5040, 1, 0, 0, 0, 4850, 4851, 5, 138, 0, 0, 4851, 4852, 7, 61, 0, 0, 4852, 4853, 3, 316, 158, 0, 4853, 4854, 5, 309, 0, 0, 4854, 4855, 5, 94, 0, 0, 4855, 4856, 3, 818, 409, 0, 4856, 5040, 1, 0, 0, 0, 4857, 4858, 5, 138, 0, 0, 4858, 4859, 5, 211, 0, 0, 4859, 4860, 3, 382, 191, 0, 4860, 4861, 5, 309, 0, 0, 4861, 4862, 5, 94, 0, 0, 4862, 4863, 3, 804, 402, 0, 4863, 5040, 1, 0, 0, 0, 4864, 4865, 5, 138, 0, 0, 4865, 4866, 5, 278, 0, 0, 4866, 4867, 7, 31, 0, 0, 4867, 4868, 3, 316, 158, 0, 4868, 4869, 3, 170, 85, 0, 4869, 4870, 5, 309, 0, 0, 4870, 4871, 5, 94, 0, 0, 4871, 4872, 3, 818, 409, 0, 4872, 5040, 1, 0, 0, 0, 4873, 4874, 5, 138, 0, 0, 4874, 4875, 5, 296, 0, 0, 4875, 4876, 3, 378, 189, 0, 4876, 4877, 5, 309, 0, 0, 4877, 4878, 5, 94, 0, 0, 4878, 4879, 3, 798, 399, 0, 4879, 5040, 1, 0, 0, 0, 4880, 4881, 5, 138, 0, 0, 4881, 4882, 5, 323, 0, 0, 4882, 4883, 3, 790, 395, 0, 4883, 4884, 5, 309, 0, 0, 4884, 4885, 5, 94, 0, 0, 4885, 4886, 3, 32, 16, 0, 4886, 5040, 1, 0, 0, 0, 4887, 4888, 5, 138, 0, 0, 4888, 4890, 7, 62, 0, 0, 4889, 4891, 3, 422, 211, 0, 4890, 4889, 1, 0, 0, 0, 4890, 4891, 1, 0, 0, 0, 4891, 4892, 1, 0, 0, 0, 4892, 4893, 3, 780, 390, 0, 4893, 4894, 5, 309, 0, 0, 4894, 4895, 5, 94, 0, 0, 4895, 4896, 3, 818, 409, 0, 4896, 5040, 1, 0, 0, 0, 4897, 4899, 5, 138, 0, 0, 4898, 4900, 5, 259, 0, 0, 4899, 4898, 1, 0, 0, 0, 4899, 4900, 1, 0, 0, 0, 4900, 4901, 1, 0, 0, 0, 4901, 4903, 5, 376, 0, 0, 4902, 4904, 3, 422, 211, 0, 4903, 4902, 1, 0, 0, 0, 4903, 4904, 1, 0, 0, 0, 4904, 4905, 1, 0, 0, 0, 4905, 4906, 3, 778, 389, 0, 4906, 4907, 5, 309, 0, 0, 4907, 4908, 5, 94, 0, 0, 4908, 4909, 3, 776, 388, 0, 4909, 5040, 1, 0, 0, 0, 4910, 4912, 5, 138, 0, 0, 4911, 4913, 5, 63, 0, 0, 4912, 4911, 1, 0, 0, 0, 4912, 4913, 1, 0, 0, 0, 4913, 4914, 1, 0, 0, 0, 4914, 4916, 5, 92, 0, 0, 4915, 4917, 3, 422, 211, 0, 4916, 4915, 1, 0, 0, 0, 4916, 4917, 1, 0, 0, 0, 4917, 4918, 1, 0, 0, 0, 4918, 4919, 3, 624, 312, 0, 4919, 4920, 5, 309, 0, 0, 4920, 4921, 5, 94, 0, 0, 4921, 4922, 3, 772, 386, 0, 4922, 5040, 1, 0, 0, 0, 4923, 4948, 5, 138, 0, 0, 4924, 4926, 5, 63, 0, 0, 4925, 4924, 1, 0, 0, 0, 4925, 4926, 1, 0, 0, 0, 4926, 4927, 1, 0, 0, 0, 4927, 4929, 5, 92, 0, 0, 4928, 4930, 3, 422, 211, 0, 4929, 4928, 1, 0, 0, 0, 4929, 4930, 1, 0, 0, 0, 4930, 4931, 1, 0, 0, 0, 4931, 4932, 3, 624, 312, 0, 4932, 4934, 5, 309, 0, 0, 4933, 4935, 5, 44, 0, 0, 4934, 4933, 1, 0, 0, 0, 4934, 4935, 1, 0, 0, 0, 4935, 4949, 1, 0, 0, 0, 4936, 4938, 5, 259, 0, 0, 4937, 4936, 1, 0, 0, 0, 4937, 4938, 1, 0, 0, 0, 4938, 4939, 1, 0, 0, 0, 4939, 4941, 5, 376, 0, 0, 4940, 4942, 3, 422, 211, 0, 4941, 4940, 1, 0, 0, 0, 4941, 4942, 1, 0, 0, 0, 4942, 4943, 1, 0, 0, 0, 4943, 4944, 3, 778, 389, 0, 4944, 4946, 5, 309, 0, 0, 4945, 4947, 5, 44, 0, 0, 4946, 4945, 1, 0, 0, 0, 4946, 4947, 1, 0, 0, 0, 4947, 4949, 1, 0, 0, 0, 4948, 4925, 1, 0, 0, 0, 4948, 4937, 1, 0, 0, 0, 4949, 4950, 1, 0, 0, 0, 4950, 4951, 3, 800, 400, 0, 4951, 4952, 5, 94, 0, 0, 4952, 4953, 3, 802, 401, 0, 4953, 5040, 1, 0, 0, 0, 4954, 4962, 5, 138, 0, 0, 4955, 4957, 5, 92, 0, 0, 4956, 4958, 3, 422, 211, 0, 4957, 4956, 1, 0, 0, 0, 4957, 4958, 1, 0, 0, 0, 4958, 4959, 1, 0, 0, 0, 4959, 4963, 3, 624, 312, 0, 4960, 4961, 5, 189, 0, 0, 4961, 4963, 3, 316, 158, 0, 4962, 4955, 1, 0, 0, 0, 4962, 4960, 1, 0, 0, 0, 4963, 4964, 1, 0, 0, 0, 4964, 4965, 5, 309, 0, 0, 4965, 4966, 5, 45, 0, 0, 4966, 4967, 3, 818, 409, 0, 4967, 4968, 5, 94, 0, 0, 4968, 4969, 3, 818, 409, 0, 4969, 5040, 1, 0, 0, 0, 4970, 4977, 5, 138, 0, 0, 4971, 4973, 5, 445, 0, 0, 4972, 4974, 3, 422, 211, 0, 4973, 4972, 1, 0, 0, 0, 4973, 4974, 1, 0, 0, 0, 4974, 4978, 1, 0, 0, 0, 4975, 4978, 5, 321, 0, 0, 4976, 4978, 5, 357, 0, 0, 4977, 4971, 1, 0, 0, 0, 4977, 4975, 1, 0, 0, 0, 4977, 4976, 1, 0, 0, 0, 4978, 4979, 1, 0, 0, 0, 4979, 4980, 3, 818, 409, 0, 4980, 4981, 5, 80, 0, 0, 4981, 4982, 3, 780, 390, 0, 4982, 4983, 5, 309, 0, 0, 4983, 4984, 5, 94, 0, 0, 4984, 4985, 3, 818, 409, 0, 4985, 5040, 1, 0, 0, 0, 4986, 4999, 5, 138, 0, 0, 4987, 4988, 5, 63, 0, 0, 4988, 4989, 5, 174, 0, 0, 4989, 5000, 5, 381, 0, 0, 4990, 4992, 5, 295, 0, 0, 4991, 4990, 1, 0, 0, 0, 4991, 4992, 1, 0, 0, 0, 4992, 4993, 1, 0, 0, 0, 4993, 5000, 5, 247, 0, 0, 4994, 5000, 5, 452, 0, 0, 4995, 5000, 5, 331, 0, 0, 4996, 5000, 5, 451, 0, 0, 4997, 4998, 5, 198, 0, 0, 4998, 5000, 5, 357, 0, 0, 4999, 4987, 1, 0, 0, 0, 4999, 4991, 1, 0, 0, 0, 4999, 4994, 1, 0, 0, 0, 4999, 4995, 1, 0, 0, 0, 4999, 4996, 1, 0, 0, 0, 4999, 4997, 1, 0, 0, 0, 5000, 5001, 1, 0, 0, 0, 5001, 5002, 3, 818, 409, 0, 5002, 5003, 5, 309, 0, 0, 5003, 5004, 5, 94, 0, 0, 5004, 5005, 3, 818, 409, 0, 5005, 5040, 1, 0, 0, 0, 5006, 5007, 5, 138, 0, 0, 5007, 5008, 7, 45, 0, 0, 5008, 5009, 3, 814, 407, 0, 5009, 5010, 5, 309, 0, 0, 5010, 5011, 5, 94, 0, 0, 5011, 5012, 3, 814, 407, 0, 5012, 5040, 1, 0, 0, 0, 5013, 5014, 5, 138, 0, 0, 5014, 5015, 3, 176, 88, 0, 5015, 5016, 5, 309, 0, 0, 5016, 5017, 5, 94, 0, 0, 5017, 5018, 3, 768, 384, 0, 5018, 5040, 1, 0, 0, 0, 5019, 5020, 5, 138, 0, 0, 5020, 5021, 5, 355, 0, 0, 5021, 5022, 5, 325, 0, 0, 5022, 5023, 7, 41, 0, 0, 5023, 5024, 3, 316, 158, 0, 5024, 5025, 5, 309, 0, 0, 5025, 5026, 5, 94, 0, 0, 5026, 5027, 3, 818, 409, 0, 5027, 5040, 1, 0, 0, 0, 5028, 5029, 5, 138, 0, 0, 5029, 5030, 5, 360, 0, 0, 5030, 5031, 3, 316, 158, 0, 5031, 5032, 5, 309, 0, 0, 5032, 5033, 5, 143, 0, 0, 5033, 5034, 3, 818, 409, 0, 5034, 5035, 5, 94, 0, 0, 5035, 5037, 3, 818, 409, 0, 5036, 5038, 3, 96, 48, 0, 5037, 5036, 1, 0, 0, 0, 5037, 5038, 1, 0, 0, 0, 5038, 5040, 1, 0, 0, 0, 5039, 4832, 1, 0, 0, 0, 5039, 4843, 1, 0, 0, 0, 5039, 4850, 1, 0, 0, 0, 5039, 4857, 1, 0, 0, 0, 5039, 4864, 1, 0, 0, 0, 5039, 4873, 1, 0, 0, 0, 5039, 4880, 1, 0, 0, 0, 5039, 4887, 1, 0, 0, 0, 5039, 4897, 1, 0, 0, 0, 5039, 4910, 1, 0, 0, 0, 5039, 4923, 1, 0, 0, 0, 5039, 4954, 1, 0, 0, 0, 5039, 4970, 1, 0, 0, 0, 5039, 4986, 1, 0, 0, 0, 5039, 5006, 1, 0, 0, 0, 5039, 5013, 1, 0, 0, 0, 5039, 5019, 1, 0, 0, 0, 5039, 5028, 1, 0, 0, 0, 5040, 433, 1, 0, 0, 0, 5041, 5058, 5, 138, 0, 0, 5042, 5043, 5, 211, 0, 0, 5043, 5059, 3, 382, 191, 0, 5044, 5045, 5, 296, 0, 0, 5045, 5059, 3, 378, 189, 0, 5046, 5047, 5, 442, 0, 0, 5047, 5059, 3, 374, 187, 0, 5048, 5049, 5, 357, 0, 0, 5049, 5050, 3, 818, 409, 0, 5050, 5051, 5, 80, 0, 0, 5051, 5052, 3, 780, 390, 0, 5052, 5059, 1, 0, 0, 0, 5053, 5054, 5, 259, 0, 0, 5054, 5055, 5, 376, 0, 0, 5055, 5059, 3, 778, 389, 0, 5056, 5057, 5, 226, 0, 0, 5057, 5059, 3, 780, 390, 0, 5058, 5042, 1, 0, 0, 0, 5058, 5044, 1, 0, 0, 0, 5058, 5046, 1, 0, 0, 0, 5058, 5048, 1, 0, 0, 0, 5058, 5053, 1, 0, 0, 0, 5058, 5056, 1, 0, 0, 0, 5059, 5061, 1, 0, 0, 0, 5060, 5062, 5, 269, 0, 0, 5061, 5060, 1, 0, 0, 0, 5061, 5062, 1, 0, 0, 0, 5062, 5063, 1, 0, 0, 0, 5063, 5064, 5, 462, 0, 0, 5064, 5065, 5, 80, 0, 0, 5065, 5066, 5, 204, 0, 0, 5066, 5067, 3, 818, 409, 0, 5067, 435, 1, 0, 0, 0, 5068, 5107, 5, 138, 0, 0, 5069, 5070, 5, 136, 0, 0, 5070, 5108, 3, 394, 197, 0, 5071, 5072, 5, 204, 0, 0, 5072, 5108, 3, 818, 409, 0, 5073, 5074, 5, 211, 0, 0, 5074, 5108, 3, 382, 191, 0, 5075, 5076, 5, 278, 0, 0, 5076, 5108, 3, 416, 208, 0, 5077, 5078, 5, 278, 0, 0, 5078, 5079, 7, 31, 0, 0, 5079, 5080, 3, 316, 158, 0, 5080, 5081, 3, 170, 85, 0, 5081, 5108, 1, 0, 0, 0, 5082, 5083, 5, 296, 0, 0, 5083, 5108, 3, 378, 189, 0, 5084, 5085, 5, 442, 0, 0, 5085, 5108, 3, 374, 187, 0, 5086, 5088, 5, 328, 0, 0, 5087, 5089, 3, 422, 211, 0, 5088, 5087, 1, 0, 0, 0, 5088, 5089, 1, 0, 0, 0, 5089, 5090, 1, 0, 0, 0, 5090, 5108, 3, 780, 390, 0, 5091, 5093, 5, 259, 0, 0, 5092, 5091, 1, 0, 0, 0, 5092, 5093, 1, 0, 0, 0, 5093, 5094, 1, 0, 0, 0, 5094, 5096, 5, 376, 0, 0, 5095, 5097, 3, 422, 211, 0, 5096, 5095, 1, 0, 0, 0, 5096, 5097, 1, 0, 0, 0, 5097, 5098, 1, 0, 0, 0, 5098, 5108, 3, 778, 389, 0, 5099, 5101, 5, 63, 0, 0, 5100, 5099, 1, 0, 0, 0, 5100, 5101, 1, 0, 0, 0, 5101, 5102, 1, 0, 0, 0, 5102, 5104, 5, 92, 0, 0, 5103, 5105, 3, 422, 211, 0, 5104, 5103, 1, 0, 0, 0, 5104, 5105, 1, 0, 0, 0, 5105, 5106, 1, 0, 0, 0, 5106, 5108, 3, 624, 312, 0, 5107, 5069, 1, 0, 0, 0, 5107, 5071, 1, 0, 0, 0, 5107, 5073, 1, 0, 0, 0, 5107, 5075, 1, 0, 0, 0, 5107, 5077, 1, 0, 0, 0, 5107, 5082, 1, 0, 0, 0, 5107, 5084, 1, 0, 0, 0, 5107, 5086, 1, 0, 0, 0, 5107, 5092, 1, 0, 0, 0, 5107, 5100, 1, 0, 0, 0, 5108, 5109, 1, 0, 0, 0, 5109, 5110, 5, 333, 0, 0, 5110, 5111, 5, 323, 0, 0, 5111, 5112, 3, 790, 395, 0, 5112, 5130, 1, 0, 0, 0, 5113, 5122, 5, 138, 0, 0, 5114, 5115, 5, 355, 0, 0, 5115, 5116, 5, 325, 0, 0, 5116, 5123, 7, 41, 0, 0, 5117, 5123, 5, 108, 0, 0, 5118, 5123, 5, 168, 0, 0, 5119, 5123, 5, 189, 0, 0, 5120, 5123, 5, 342, 0, 0, 5121, 5123, 5, 360, 0, 0, 5122, 5114, 1, 0, 0, 0, 5122, 5117, 1, 0, 0, 0, 5122, 5118, 1, 0, 0, 0, 5122, 5119, 1, 0, 0, 0, 5122, 5120, 1, 0, 0, 0, 5122, 5121, 1, 0, 0, 0, 5123, 5124, 1, 0, 0, 0, 5124, 5125, 3, 316, 158, 0, 5125, 5126, 5, 333, 0, 0, 5126, 5127, 5, 323, 0, 0, 5127, 5128, 3, 790, 395, 0, 5128, 5130, 1, 0, 0, 0, 5129, 5068, 1, 0, 0, 0, 5129, 5113, 1, 0, 0, 0, 5130, 437, 1, 0, 0, 0, 5131, 5132, 5, 138, 0, 0, 5132, 5133, 5, 278, 0, 0, 5133, 5134, 3, 416, 208, 0, 5134, 5135, 5, 333, 0, 0, 5135, 5136, 3, 440, 220, 0, 5136, 439, 1, 0, 0, 0, 5137, 5138, 5, 2, 0, 0, 5138, 5143, 3, 442, 221, 0, 5139, 5140, 5, 6, 0, 0, 5140, 5142, 3, 442, 221, 0, 5141, 5139, 1, 0, 0, 0, 5142, 5145, 1, 0, 0, 0, 5143, 5141, 1, 0, 0, 0, 5143, 5144, 1, 0, 0, 0, 5144, 5146, 1, 0, 0, 0, 5145, 5143, 1, 0, 0, 0, 5146, 5147, 5, 3, 0, 0, 5147, 441, 1, 0, 0, 0, 5148, 5149, 3, 824, 412, 0, 5149, 5156, 5, 10, 0, 0, 5150, 5157, 5, 407, 0, 0, 5151, 5157, 3, 388, 194, 0, 5152, 5157, 3, 834, 417, 0, 5153, 5157, 3, 726, 363, 0, 5154, 5157, 3, 202, 101, 0, 5155, 5157, 3, 808, 404, 0, 5156, 5150, 1, 0, 0, 0, 5156, 5151, 1, 0, 0, 0, 5156, 5152, 1, 0, 0, 0, 5156, 5153, 1, 0, 0, 0, 5156, 5154, 1, 0, 0, 0, 5156, 5155, 1, 0, 0, 0, 5157, 443, 1, 0, 0, 0, 5158, 5159, 5, 138, 0, 0, 5159, 5160, 5, 360, 0, 0, 5160, 5161, 3, 316, 158, 0, 5161, 5162, 5, 333, 0, 0, 5162, 5163, 3, 440, 220, 0, 5163, 445, 1, 0, 0, 0, 5164, 5165, 5, 138, 0, 0, 5165, 5166, 5, 278, 0, 0, 5166, 5167, 7, 31, 0, 0, 5167, 5168, 3, 316, 158, 0, 5168, 5169, 3, 170, 85, 0, 5169, 5170, 5, 282, 0, 0, 5170, 5171, 5, 94, 0, 0, 5171, 5172, 3, 814, 407, 0, 5172, 5239, 1, 0, 0, 0, 5173, 5200, 5, 138, 0, 0, 5174, 5175, 5, 136, 0, 0, 5175, 5201, 3, 394, 197, 0, 5176, 5177, 5, 175, 0, 0, 5177, 5201, 3, 788, 394, 0, 5178, 5179, 5, 211, 0, 0, 5179, 5201, 3, 382, 191, 0, 5180, 5182, 5, 295, 0, 0, 5181, 5180, 1, 0, 0, 0, 5181, 5182, 1, 0, 0, 0, 5182, 5183, 1, 0, 0, 0, 5183, 5184, 5, 247, 0, 0, 5184, 5201, 3, 818, 409, 0, 5185, 5186, 5, 248, 0, 0, 5186, 5187, 5, 274, 0, 0, 5187, 5201, 3, 202, 101, 0, 5188, 5189, 5, 248, 0, 0, 5189, 5190, 5, 274, 0, 0, 5190, 5201, 3, 202, 101, 0, 5191, 5192, 5, 278, 0, 0, 5192, 5201, 3, 416, 208, 0, 5193, 5194, 5, 296, 0, 0, 5194, 5201, 3, 378, 189, 0, 5195, 5196, 5, 442, 0, 0, 5196, 5201, 3, 374, 187, 0, 5197, 5198, 5, 323, 0, 0, 5198, 5201, 3, 790, 395, 0, 5199, 5201, 3, 176, 88, 0, 5200, 5174, 1, 0, 0, 0, 5200, 5176, 1, 0, 0, 0, 5200, 5178, 1, 0, 0, 0, 5200, 5181, 1, 0, 0, 0, 5200, 5185, 1, 0, 0, 0, 5200, 5188, 1, 0, 0, 0, 5200, 5191, 1, 0, 0, 0, 5200, 5193, 1, 0, 0, 0, 5200, 5195, 1, 0, 0, 0, 5200, 5197, 1, 0, 0, 0, 5200, 5199, 1, 0, 0, 0, 5201, 5202, 1, 0, 0, 0, 5202, 5203, 5, 282, 0, 0, 5203, 5204, 5, 94, 0, 0, 5204, 5205, 3, 814, 407, 0, 5205, 5239, 1, 0, 0, 0, 5206, 5215, 5, 138, 0, 0, 5207, 5208, 5, 355, 0, 0, 5208, 5209, 5, 325, 0, 0, 5209, 5216, 7, 63, 0, 0, 5210, 5216, 5, 108, 0, 0, 5211, 5216, 5, 168, 0, 0, 5212, 5216, 5, 189, 0, 0, 5213, 5216, 5, 360, 0, 0, 5214, 5216, 5, 342, 0, 0, 5215, 5207, 1, 0, 0, 0, 5215, 5210, 1, 0, 0, 0, 5215, 5211, 1, 0, 0, 0, 5215, 5212, 1, 0, 0, 0, 5215, 5213, 1, 0, 0, 0, 5215, 5214, 1, 0, 0, 0, 5216, 5217, 1, 0, 0, 0, 5217, 5218, 3, 316, 158, 0, 5218, 5219, 5, 282, 0, 0, 5219, 5220, 5, 94, 0, 0, 5220, 5221, 3, 814, 407, 0, 5221, 5239, 1, 0, 0, 0, 5222, 5231, 5, 138, 0, 0, 5223, 5232, 5, 331, 0, 0, 5224, 5225, 5, 63, 0, 0, 5225, 5226, 5, 174, 0, 0, 5226, 5232, 5, 381, 0, 0, 5227, 5228, 5, 198, 0, 0, 5228, 5232, 5, 357, 0, 0, 5229, 5232, 5, 452, 0, 0, 5230, 5232, 5, 451, 0, 0, 5231, 5223, 1, 0, 0, 0, 5231, 5224, 1, 0, 0, 0, 5231, 5227, 1, 0, 0, 0, 5231, 5229, 1, 0, 0, 0, 5231, 5230, 1, 0, 0, 0, 5232, 5233, 1, 0, 0, 0, 5233, 5234, 3, 818, 409, 0, 5234, 5235, 5, 282, 0, 0, 5235, 5236, 5, 94, 0, 0, 5236, 5237, 3, 814, 407, 0, 5237, 5239, 1, 0, 0, 0, 5238, 5164, 1, 0, 0, 0, 5238, 5173, 1, 0, 0, 0, 5238, 5206, 1, 0, 0, 0, 5238, 5222, 1, 0, 0, 0, 5239, 447, 1, 0, 0, 0, 5240, 5241, 5, 46, 0, 0, 5241, 5242, 5, 452, 0, 0, 5242, 5249, 3, 818, 409, 0, 5243, 5244, 5, 62, 0, 0, 5244, 5245, 5, 92, 0, 0, 5245, 5250, 3, 628, 314, 0, 5246, 5247, 5, 62, 0, 0, 5247, 5248, 5, 30, 0, 0, 5248, 5250, 5, 350, 0, 0, 5249, 5243, 1, 0, 0, 0, 5249, 5246, 1, 0, 0, 0, 5249, 5250, 1, 0, 0, 0, 5250, 5252, 1, 0, 0, 0, 5251, 5253, 3, 400, 200, 0, 5252, 5251, 1, 0, 0, 0, 5252, 5253, 1, 0, 0, 0, 5253, 449, 1, 0, 0, 0, 5254, 5255, 5, 138, 0, 0, 5255, 5256, 5, 452, 0, 0, 5256, 5274, 3, 818, 409, 0, 5257, 5258, 5, 282, 0, 0, 5258, 5259, 5, 94, 0, 0, 5259, 5275, 3, 814, 407, 0, 5260, 5261, 5, 333, 0, 0, 5261, 5275, 3, 284, 142, 0, 5262, 5263, 5, 309, 0, 0, 5263, 5264, 5, 94, 0, 0, 5264, 5275, 3, 818, 409, 0, 5265, 5266, 7, 34, 0, 0, 5266, 5271, 3, 626, 313, 0, 5267, 5268, 5, 6, 0, 0, 5268, 5270, 3, 626, 313, 0, 5269, 5267, 1, 0, 0, 0, 5270, 5273, 1, 0, 0, 0, 5271, 5269, 1, 0, 0, 0, 5271, 5272, 1, 0, 0, 0, 5272, 5275, 1, 0, 0, 0, 5273, 5271, 1, 0, 0, 0, 5274, 5257, 1, 0, 0, 0, 5274, 5260, 1, 0, 0, 0, 5274, 5262, 1, 0, 0, 0, 5274, 5265, 1, 0, 0, 0, 5275, 451, 1, 0, 0, 0, 5276, 5277, 5, 46, 0, 0, 5277, 5278, 5, 451, 0, 0, 5278, 5279, 3, 818, 409, 0, 5279, 5280, 5, 164, 0, 0, 5280, 5281, 3, 808, 404, 0, 5281, 5282, 5, 452, 0, 0, 5282, 5287, 3, 824, 412, 0, 5283, 5284, 5, 6, 0, 0, 5284, 5286, 3, 824, 412, 0, 5285, 5283, 1, 0, 0, 0, 5286, 5289, 1, 0, 0, 0, 5287, 5285, 1, 0, 0, 0, 5287, 5288, 1, 0, 0, 0, 5288, 5291, 1, 0, 0, 0, 5289, 5287, 1, 0, 0, 0, 5290, 5292, 3, 400, 200, 0, 5291, 5290, 1, 0, 0, 0, 5291, 5292, 1, 0, 0, 0, 5292, 453, 1, 0, 0, 0, 5293, 5294, 5, 138, 0, 0, 5294, 5295, 5, 451, 0, 0, 5295, 5296, 3, 818, 409, 0, 5296, 5297, 5, 333, 0, 0, 5297, 5298, 3, 284, 142, 0, 5298, 5350, 1, 0, 0, 0, 5299, 5300, 5, 138, 0, 0, 5300, 5301, 5, 451, 0, 0, 5301, 5302, 3, 818, 409, 0, 5302, 5303, 5, 164, 0, 0, 5303, 5304, 3, 808, 404, 0, 5304, 5350, 1, 0, 0, 0, 5305, 5306, 5, 138, 0, 0, 5306, 5307, 5, 451, 0, 0, 5307, 5308, 3, 818, 409, 0, 5308, 5309, 5, 305, 0, 0, 5309, 5311, 5, 452, 0, 0, 5310, 5312, 3, 400, 200, 0, 5311, 5310, 1, 0, 0, 0, 5311, 5312, 1, 0, 0, 0, 5312, 5350, 1, 0, 0, 0, 5313, 5314, 5, 138, 0, 0, 5314, 5315, 5, 451, 0, 0, 5315, 5316, 3, 818, 409, 0, 5316, 5317, 7, 34, 0, 0, 5317, 5318, 5, 452, 0, 0, 5318, 5323, 3, 824, 412, 0, 5319, 5320, 5, 6, 0, 0, 5320, 5322, 3, 824, 412, 0, 5321, 5319, 1, 0, 0, 0, 5322, 5325, 1, 0, 0, 0, 5323, 5321, 1, 0, 0, 0, 5323, 5324, 1, 0, 0, 0, 5324, 5327, 1, 0, 0, 0, 5325, 5323, 1, 0, 0, 0, 5326, 5328, 3, 400, 200, 0, 5327, 5326, 1, 0, 0, 0, 5327, 5328, 1, 0, 0, 0, 5328, 5350, 1, 0, 0, 0, 5329, 5330, 5, 138, 0, 0, 5330, 5331, 5, 451, 0, 0, 5331, 5332, 3, 818, 409, 0, 5332, 5333, 7, 64, 0, 0, 5333, 5350, 1, 0, 0, 0, 5334, 5335, 5, 138, 0, 0, 5335, 5336, 5, 451, 0, 0, 5336, 5337, 3, 818, 409, 0, 5337, 5338, 5, 465, 0, 0, 5338, 5339, 5, 2, 0, 0, 5339, 5340, 3, 290, 145, 0, 5340, 5341, 5, 3, 0, 0, 5341, 5350, 1, 0, 0, 0, 5342, 5343, 5, 138, 0, 0, 5343, 5344, 5, 451, 0, 0, 5344, 5345, 3, 818, 409, 0, 5345, 5346, 5, 282, 0, 0, 5346, 5347, 5, 94, 0, 0, 5347, 5348, 3, 814, 407, 0, 5348, 5350, 1, 0, 0, 0, 5349, 5293, 1, 0, 0, 0, 5349, 5299, 1, 0, 0, 0, 5349, 5305, 1, 0, 0, 0, 5349, 5313, 1, 0, 0, 0, 5349, 5329, 1, 0, 0, 0, 5349, 5334, 1, 0, 0, 0, 5349, 5342, 1, 0, 0, 0, 5350, 455, 1, 0, 0, 0, 5351, 5353, 5, 46, 0, 0, 5352, 5354, 3, 366, 183, 0, 5353, 5352, 1, 0, 0, 0, 5353, 5354, 1, 0, 0, 0, 5354, 5355, 1, 0, 0, 0, 5355, 5356, 5, 321, 0, 0, 5356, 5357, 3, 818, 409, 0, 5357, 5358, 5, 36, 0, 0, 5358, 5359, 5, 80, 0, 0, 5359, 5360, 7, 65, 0, 0, 5360, 5361, 5, 94, 0, 0, 5361, 5363, 3, 780, 390, 0, 5362, 5364, 3, 638, 319, 0, 5363, 5362, 1, 0, 0, 0, 5363, 5364, 1, 0, 0, 0, 5364, 5365, 1, 0, 0, 0, 5365, 5367, 5, 57, 0, 0, 5366, 5368, 7, 66, 0, 0, 5367, 5366, 1, 0, 0, 0, 5367, 5368, 1, 0, 0, 0, 5368, 5385, 1, 0, 0, 0, 5369, 5386, 5, 270, 0, 0, 5370, 5386, 3, 458, 229, 0, 5371, 5373, 5, 2, 0, 0, 5372, 5374, 3, 458, 229, 0, 5373, 5372, 1, 0, 0, 0, 5373, 5374, 1, 0, 0, 0, 5374, 5381, 1, 0, 0, 0, 5375, 5377, 5, 7, 0, 0, 5376, 5378, 3, 458, 229, 0, 5377, 5376, 1, 0, 0, 0, 5377, 5378, 1, 0, 0, 0, 5378, 5380, 1, 0, 0, 0, 5379, 5375, 1, 0, 0, 0, 5380, 5383, 1, 0, 0, 0, 5381, 5379, 1, 0, 0, 0, 5381, 5382, 1, 0, 0, 0, 5382, 5384, 1, 0, 0, 0, 5383, 5381, 1, 0, 0, 0, 5384, 5386, 5, 3, 0, 0, 5385, 5369, 1, 0, 0, 0, 5385, 5370, 1, 0, 0, 0, 5385, 5371, 1, 0, 0, 0, 5386, 457, 1, 0, 0, 0, 5387, 5393, 3, 560, 280, 0, 5388, 5393, 3, 538, 269, 0, 5389, 5393, 3, 552, 276, 0, 5390, 5393, 3, 548, 274, 0, 5391, 5393, 3, 460, 230, 0, 5392, 5387, 1, 0, 0, 0, 5392, 5388, 1, 0, 0, 0, 5392, 5389, 1, 0, 0, 0, 5392, 5390, 1, 0, 0, 0, 5392, 5391, 1, 0, 0, 0, 5393, 459, 1, 0, 0, 0, 5394, 5395, 5, 271, 0, 0, 5395, 5397, 3, 818, 409, 0, 5396, 5398, 3, 462, 231, 0, 5397, 5396, 1, 0, 0, 0, 5397, 5398, 1, 0, 0, 0, 5398, 461, 1, 0, 0, 0, 5399, 5400, 5, 6, 0, 0, 5400, 5401, 3, 808, 404, 0, 5401, 463, 1, 0, 0, 0, 5402, 5403, 5, 252, 0, 0, 5403, 5404, 3, 818, 409, 0, 5404, 465, 1, 0, 0, 0, 5405, 5408, 5, 366, 0, 0, 5406, 5409, 3, 818, 409, 0, 5407, 5409, 5, 9, 0, 0, 5408, 5406, 1, 0, 0, 0, 5408, 5407, 1, 0, 0, 0, 5409, 467, 1, 0, 0, 0, 5410, 5412, 5, 146, 0, 0, 5411, 5413, 3, 470, 235, 0, 5412, 5411, 1, 0, 0, 0, 5412, 5413, 1, 0, 0, 0, 5413, 5415, 1, 0, 0, 0, 5414, 5416, 3, 474, 237, 0, 5415, 5414, 1, 0, 0, 0, 5415, 5416, 1, 0, 0, 0, 5416, 5456, 1, 0, 0, 0, 5417, 5418, 5, 340, 0, 0, 5418, 5420, 5, 356, 0, 0, 5419, 5421, 3, 474, 237, 0, 5420, 5419, 1, 0, 0, 0, 5420, 5421, 1, 0, 0, 0, 5421, 5456, 1, 0, 0, 0, 5422, 5423, 5, 322, 0, 0, 5423, 5456, 3, 818, 409, 0, 5424, 5426, 5, 308, 0, 0, 5425, 5427, 5, 322, 0, 0, 5426, 5425, 1, 0, 0, 0, 5426, 5427, 1, 0, 0, 0, 5427, 5428, 1, 0, 0, 0, 5428, 5456, 3, 818, 409, 0, 5429, 5430, 5, 290, 0, 0, 5430, 5431, 5, 356, 0, 0, 5431, 5456, 3, 808, 404, 0, 5432, 5433, 7, 67, 0, 0, 5433, 5434, 5, 291, 0, 0, 5434, 5456, 3, 808, 404, 0, 5435, 5437, 7, 68, 0, 0, 5436, 5438, 3, 470, 235, 0, 5437, 5436, 1, 0, 0, 0, 5437, 5438, 1, 0, 0, 0, 5438, 5444, 1, 0, 0, 0, 5439, 5441, 5, 33, 0, 0, 5440, 5442, 5, 269, 0, 0, 5441, 5440, 1, 0, 0, 0, 5441, 5442, 1, 0, 0, 0, 5442, 5443, 1, 0, 0, 0, 5443, 5445, 5, 153, 0, 0, 5444, 5439, 1, 0, 0, 0, 5444, 5445, 1, 0, 0, 0, 5445, 5456, 1, 0, 0, 0, 5446, 5448, 5, 319, 0, 0, 5447, 5449, 3, 470, 235, 0, 5448, 5447, 1, 0, 0, 0, 5448, 5449, 1, 0, 0, 0, 5449, 5450, 1, 0, 0, 0, 5450, 5452, 5, 94, 0, 0, 5451, 5453, 5, 322, 0, 0, 5452, 5451, 1, 0, 0, 0, 5452, 5453, 1, 0, 0, 0, 5453, 5454, 1, 0, 0, 0, 5454, 5456, 3, 818, 409, 0, 5455, 5410, 1, 0, 0, 0, 5455, 5417, 1, 0, 0, 0, 5455, 5422, 1, 0, 0, 0, 5455, 5424, 1, 0, 0, 0, 5455, 5429, 1, 0, 0, 0, 5455, 5432, 1, 0, 0, 0, 5455, 5435, 1, 0, 0, 0, 5455, 5446, 1, 0, 0, 0, 5456, 469, 1, 0, 0, 0, 5457, 5458, 7, 69, 0, 0, 5458, 471, 1, 0, 0, 0, 5459, 5460, 5, 244, 0, 0, 5460, 5461, 5, 251, 0, 0, 5461, 5469, 3, 50, 25, 0, 5462, 5463, 5, 300, 0, 0, 5463, 5469, 7, 70, 0, 0, 5464, 5466, 5, 77, 0, 0, 5465, 5464, 1, 0, 0, 0, 5465, 5466, 1, 0, 0, 0, 5466, 5467, 1, 0, 0, 0, 5467, 5469, 5, 54, 0, 0, 5468, 5459, 1, 0, 0, 0, 5468, 5462, 1, 0, 0, 0, 5468, 5465, 1, 0, 0, 0, 5469, 473, 1, 0, 0, 0, 5470, 5477, 3, 472, 236, 0, 5471, 5473, 5, 6, 0, 0, 5472, 5471, 1, 0, 0, 0, 5472, 5473, 1, 0, 0, 0, 5473, 5474, 1, 0, 0, 0, 5474, 5476, 3, 472, 236, 0, 5475, 5472, 1, 0, 0, 0, 5476, 5479, 1, 0, 0, 0, 5477, 5475, 1, 0, 0, 0, 5477, 5478, 1, 0, 0, 0, 5478, 475, 1, 0, 0, 0, 5479, 5477, 1, 0, 0, 0, 5480, 5483, 5, 46, 0, 0, 5481, 5482, 5, 82, 0, 0, 5482, 5484, 5, 311, 0, 0, 5483, 5481, 1, 0, 0, 0, 5483, 5484, 1, 0, 0, 0, 5484, 5486, 1, 0, 0, 0, 5485, 5487, 3, 122, 61, 0, 5486, 5485, 1, 0, 0, 0, 5486, 5487, 1, 0, 0, 0, 5487, 5503, 1, 0, 0, 0, 5488, 5489, 5, 376, 0, 0, 5489, 5491, 3, 776, 388, 0, 5490, 5492, 3, 146, 73, 0, 5491, 5490, 1, 0, 0, 0, 5491, 5492, 1, 0, 0, 0, 5492, 5494, 1, 0, 0, 0, 5493, 5495, 3, 102, 51, 0, 5494, 5493, 1, 0, 0, 0, 5494, 5495, 1, 0, 0, 0, 5495, 5504, 1, 0, 0, 0, 5496, 5497, 5, 303, 0, 0, 5497, 5498, 5, 376, 0, 0, 5498, 5499, 3, 776, 388, 0, 5499, 5501, 3, 144, 72, 0, 5500, 5502, 3, 102, 51, 0, 5501, 5500, 1, 0, 0, 0, 5501, 5502, 1, 0, 0, 0, 5502, 5504, 1, 0, 0, 0, 5503, 5488, 1, 0, 0, 0, 5503, 5496, 1, 0, 0, 0, 5504, 5505, 1, 0, 0, 0, 5505, 5506, 5, 36, 0, 0, 5506, 5513, 3, 560, 280, 0, 5507, 5509, 5, 105, 0, 0, 5508, 5510, 7, 71, 0, 0, 5509, 5508, 1, 0, 0, 0, 5509, 5510, 1, 0, 0, 0, 5510, 5511, 1, 0, 0, 0, 5511, 5512, 5, 42, 0, 0, 5512, 5514, 5, 279, 0, 0, 5513, 5507, 1, 0, 0, 0, 5513, 5514, 1, 0, 0, 0, 5514, 477, 1, 0, 0, 0, 5515, 5516, 5, 253, 0, 0, 5516, 5517, 3, 808, 404, 0, 5517, 479, 1, 0, 0, 0, 5518, 5519, 5, 46, 0, 0, 5519, 5520, 5, 175, 0, 0, 5520, 5522, 3, 786, 393, 0, 5521, 5523, 5, 105, 0, 0, 5522, 5521, 1, 0, 0, 0, 5522, 5523, 1, 0, 0, 0, 5523, 5529, 1, 0, 0, 0, 5524, 5526, 3, 482, 241, 0, 5525, 5524, 1, 0, 0, 0, 5526, 5527, 1, 0, 0, 0, 5527, 5525, 1, 0, 0, 0, 5527, 5528, 1, 0, 0, 0, 5528, 5530, 1, 0, 0, 0, 5529, 5525, 1, 0, 0, 0, 5529, 5530, 1, 0, 0, 0, 5530, 481, 1, 0, 0, 0, 5531, 5532, 5, 164, 0, 0, 5532, 5540, 5, 74, 0, 0, 5533, 5540, 5, 194, 0, 0, 5534, 5540, 5, 255, 0, 0, 5535, 5540, 5, 282, 0, 0, 5536, 5540, 5, 351, 0, 0, 5537, 5540, 5, 353, 0, 0, 5538, 5540, 3, 826, 413, 0, 5539, 5531, 1, 0, 0, 0, 5539, 5533, 1, 0, 0, 0, 5539, 5534, 1, 0, 0, 0, 5539, 5535, 1, 0, 0, 0, 5539, 5536, 1, 0, 0, 0, 5539, 5537, 1, 0, 0, 0, 5539, 5538, 1, 0, 0, 0, 5540, 5542, 1, 0, 0, 0, 5541, 5543, 5, 10, 0, 0, 5542, 5541, 1, 0, 0, 0, 5542, 5543, 1, 0, 0, 0, 5543, 5547, 1, 0, 0, 0, 5544, 5548, 3, 812, 406, 0, 5545, 5548, 3, 54, 27, 0, 5546, 5548, 5, 53, 0, 0, 5547, 5544, 1, 0, 0, 0, 5547, 5545, 1, 0, 0, 0, 5547, 5546, 1, 0, 0, 0, 5548, 483, 1, 0, 0, 0, 5549, 5550, 5, 138, 0, 0, 5550, 5551, 5, 175, 0, 0, 5551, 5567, 3, 788, 394, 0, 5552, 5553, 5, 333, 0, 0, 5553, 5554, 5, 351, 0, 0, 5554, 5556, 3, 768, 384, 0, 5555, 5552, 1, 0, 0, 0, 5555, 5556, 1, 0, 0, 0, 5556, 5568, 1, 0, 0, 0, 5557, 5559, 5, 105, 0, 0, 5558, 5557, 1, 0, 0, 0, 5558, 5559, 1, 0, 0, 0, 5559, 5561, 1, 0, 0, 0, 5560, 5562, 3, 482, 241, 0, 5561, 5560, 1, 0, 0, 0, 5562, 5563, 1, 0, 0, 0, 5563, 5561, 1, 0, 0, 0, 5563, 5564, 1, 0, 0, 0, 5564, 5566, 1, 0, 0, 0, 5565, 5558, 1, 0, 0, 0, 5565, 5566, 1, 0, 0, 0, 5566, 5568, 1, 0, 0, 0, 5567, 5555, 1, 0, 0, 0, 5567, 5565, 1, 0, 0, 0, 5568, 485, 1, 0, 0, 0, 5569, 5570, 5, 138, 0, 0, 5570, 5571, 5, 175, 0, 0, 5571, 5573, 3, 788, 394, 0, 5572, 5574, 3, 64, 32, 0, 5573, 5572, 1, 0, 0, 0, 5573, 5574, 1, 0, 0, 0, 5574, 487, 1, 0, 0, 0, 5575, 5576, 5, 138, 0, 0, 5576, 5577, 5, 108, 0, 0, 5577, 5578, 3, 316, 158, 0, 5578, 5579, 5, 305, 0, 0, 5579, 5580, 5, 375, 0, 0, 5580, 489, 1, 0, 0, 0, 5581, 5582, 5, 138, 0, 0, 5582, 5583, 5, 349, 0, 0, 5583, 5584, 7, 16, 0, 0, 5584, 5585, 3, 40, 20, 0, 5585, 491, 1, 0, 0, 0, 5586, 5587, 5, 46, 0, 0, 5587, 5588, 5, 189, 0, 0, 5588, 5590, 3, 316, 158, 0, 5589, 5591, 5, 36, 0, 0, 5590, 5589, 1, 0, 0, 0, 5590, 5591, 1, 0, 0, 0, 5591, 5592, 1, 0, 0, 0, 5592, 5596, 3, 652, 326, 0, 5593, 5595, 3, 134, 67, 0, 5594, 5593, 1, 0, 0, 0, 5595, 5598, 1, 0, 0, 0, 5596, 5594, 1, 0, 0, 0, 5596, 5597, 1, 0, 0, 0, 5597, 493, 1, 0, 0, 0, 5598, 5596, 1, 0, 0, 0, 5599, 5600, 5, 138, 0, 0, 5600, 5601, 5, 189, 0, 0, 5601, 5624, 3, 316, 158, 0, 5602, 5625, 3, 94, 47, 0, 5603, 5604, 7, 15, 0, 0, 5604, 5605, 5, 77, 0, 0, 5605, 5625, 5, 78, 0, 0, 5606, 5609, 5, 133, 0, 0, 5607, 5608, 5, 45, 0, 0, 5608, 5610, 3, 818, 409, 0, 5609, 5607, 1, 0, 0, 0, 5609, 5610, 1, 0, 0, 0, 5610, 5611, 1, 0, 0, 0, 5611, 5625, 3, 142, 71, 0, 5612, 5613, 5, 191, 0, 0, 5613, 5615, 5, 45, 0, 0, 5614, 5616, 3, 422, 211, 0, 5615, 5614, 1, 0, 0, 0, 5615, 5616, 1, 0, 0, 0, 5616, 5617, 1, 0, 0, 0, 5617, 5619, 3, 818, 409, 0, 5618, 5620, 3, 96, 48, 0, 5619, 5618, 1, 0, 0, 0, 5619, 5620, 1, 0, 0, 0, 5620, 5625, 1, 0, 0, 0, 5621, 5622, 5, 372, 0, 0, 5622, 5623, 5, 45, 0, 0, 5623, 5625, 3, 818, 409, 0, 5624, 5602, 1, 0, 0, 0, 5624, 5603, 1, 0, 0, 0, 5624, 5606, 1, 0, 0, 0, 5624, 5612, 1, 0, 0, 0, 5624, 5621, 1, 0, 0, 0, 5625, 495, 1, 0, 0, 0, 5626, 5627, 5, 138, 0, 0, 5627, 5628, 5, 355, 0, 0, 5628, 5629, 5, 325, 0, 0, 5629, 5630, 5, 185, 0, 0, 5630, 5631, 3, 316, 158, 0, 5631, 5632, 3, 284, 142, 0, 5632, 497, 1, 0, 0, 0, 5633, 5634, 5, 138, 0, 0, 5634, 5635, 5, 355, 0, 0, 5635, 5636, 5, 325, 0, 0, 5636, 5637, 5, 163, 0, 0, 5637, 5638, 3, 316, 158, 0, 5638, 5639, 7, 72, 0, 0, 5639, 5640, 5, 257, 0, 0, 5640, 5641, 5, 62, 0, 0, 5641, 5642, 3, 784, 392, 0, 5642, 5643, 5, 105, 0, 0, 5643, 5644, 3, 314, 157, 0, 5644, 5675, 1, 0, 0, 0, 5645, 5646, 5, 138, 0, 0, 5646, 5647, 5, 355, 0, 0, 5647, 5648, 5, 325, 0, 0, 5648, 5649, 5, 163, 0, 0, 5649, 5650, 3, 316, 158, 0, 5650, 5651, 5, 138, 0, 0, 5651, 5654, 5, 257, 0, 0, 5652, 5653, 5, 62, 0, 0, 5653, 5655, 3, 784, 392, 0, 5654, 5652, 1, 0, 0, 0, 5654, 5655, 1, 0, 0, 0, 5655, 5656, 1, 0, 0, 0, 5656, 5657, 5, 311, 0, 0, 5657, 5658, 3, 316, 158, 0, 5658, 5659, 5, 105, 0, 0, 5659, 5660, 3, 316, 158, 0, 5660, 5675, 1, 0, 0, 0, 5661, 5662, 5, 138, 0, 0, 5662, 5663, 5, 355, 0, 0, 5663, 5664, 5, 325, 0, 0, 5664, 5665, 5, 163, 0, 0, 5665, 5666, 3, 316, 158, 0, 5666, 5667, 5, 191, 0, 0, 5667, 5669, 5, 257, 0, 0, 5668, 5670, 3, 422, 211, 0, 5669, 5668, 1, 0, 0, 0, 5669, 5670, 1, 0, 0, 0, 5670, 5671, 1, 0, 0, 0, 5671, 5672, 5, 62, 0, 0, 5672, 5673, 3, 784, 392, 0, 5673, 5675, 1, 0, 0, 0, 5674, 5633, 1, 0, 0, 0, 5674, 5645, 1, 0, 0, 0, 5674, 5661, 1, 0, 0, 0, 5675, 499, 1, 0, 0, 0, 5676, 5678, 5, 46, 0, 0, 5677, 5679, 5, 53, 0, 0, 5678, 5677, 1, 0, 0, 0, 5678, 5679, 1, 0, 0, 0, 5679, 5680, 1, 0, 0, 0, 5680, 5681, 5, 168, 0, 0, 5681, 5682, 3, 316, 158, 0, 5682, 5683, 5, 62, 0, 0, 5683, 5684, 3, 808, 404, 0, 5684, 5685, 5, 94, 0, 0, 5685, 5686, 3, 808, 404, 0, 5686, 5687, 5, 64, 0, 0, 5687, 5688, 3, 316, 158, 0, 5688, 501, 1, 0, 0, 0, 5689, 5691, 5, 158, 0, 0, 5690, 5692, 3, 514, 257, 0, 5691, 5690, 1, 0, 0, 0, 5691, 5692, 1, 0, 0, 0, 5692, 5697, 1, 0, 0, 0, 5693, 5695, 3, 774, 387, 0, 5694, 5696, 3, 170, 85, 0, 5695, 5694, 1, 0, 0, 0, 5695, 5696, 1, 0, 0, 0, 5696, 5698, 1, 0, 0, 0, 5697, 5693, 1, 0, 0, 0, 5697, 5698, 1, 0, 0, 0, 5698, 5715, 1, 0, 0, 0, 5699, 5700, 5, 158, 0, 0, 5700, 5701, 5, 2, 0, 0, 5701, 5706, 3, 514, 257, 0, 5702, 5703, 5, 6, 0, 0, 5703, 5705, 3, 514, 257, 0, 5704, 5702, 1, 0, 0, 0, 5705, 5708, 1, 0, 0, 0, 5706, 5704, 1, 0, 0, 0, 5706, 5707, 1, 0, 0, 0, 5707, 5709, 1, 0, 0, 0, 5708, 5706, 1, 0, 0, 0, 5709, 5710, 5, 3, 0, 0, 5710, 5712, 3, 774, 387, 0, 5711, 5713, 3, 170, 85, 0, 5712, 5711, 1, 0, 0, 0, 5712, 5713, 1, 0, 0, 0, 5713, 5715, 1, 0, 0, 0, 5714, 5689, 1, 0, 0, 0, 5714, 5699, 1, 0, 0, 0, 5715, 503, 1, 0, 0, 0, 5716, 5732, 5, 370, 0, 0, 5717, 5719, 5, 113, 0, 0, 5718, 5717, 1, 0, 0, 0, 5718, 5719, 1, 0, 0, 0, 5719, 5721, 1, 0, 0, 0, 5720, 5722, 5, 112, 0, 0, 5721, 5720, 1, 0, 0, 0, 5721, 5722, 1, 0, 0, 0, 5722, 5724, 1, 0, 0, 0, 5723, 5725, 3, 514, 257, 0, 5724, 5723, 1, 0, 0, 0, 5724, 5725, 1, 0, 0, 0, 5725, 5727, 1, 0, 0, 0, 5726, 5728, 3, 508, 254, 0, 5727, 5726, 1, 0, 0, 0, 5727, 5728, 1, 0, 0, 0, 5728, 5733, 1, 0, 0, 0, 5729, 5731, 3, 524, 262, 0, 5730, 5729, 1, 0, 0, 0, 5730, 5731, 1, 0, 0, 0, 5731, 5733, 1, 0, 0, 0, 5732, 5718, 1, 0, 0, 0, 5732, 5730, 1, 0, 0, 0, 5733, 5735, 1, 0, 0, 0, 5734, 5736, 3, 518, 259, 0, 5735, 5734, 1, 0, 0, 0, 5735, 5736, 1, 0, 0, 0, 5736, 505, 1, 0, 0, 0, 5737, 5752, 3, 508, 254, 0, 5738, 5740, 3, 514, 257, 0, 5739, 5738, 1, 0, 0, 0, 5739, 5740, 1, 0, 0, 0, 5740, 5753, 1, 0, 0, 0, 5741, 5742, 5, 2, 0, 0, 5742, 5747, 3, 512, 256, 0, 5743, 5744, 5, 6, 0, 0, 5744, 5746, 3, 512, 256, 0, 5745, 5743, 1, 0, 0, 0, 5746, 5749, 1, 0, 0, 0, 5747, 5745, 1, 0, 0, 0, 5747, 5748, 1, 0, 0, 0, 5748, 5750, 1, 0, 0, 0, 5749, 5747, 1, 0, 0, 0, 5750, 5751, 5, 3, 0, 0, 5751, 5753, 1, 0, 0, 0, 5752, 5739, 1, 0, 0, 0, 5752, 5741, 1, 0, 0, 0, 5753, 5755, 1, 0, 0, 0, 5754, 5756, 3, 518, 259, 0, 5755, 5754, 1, 0, 0, 0, 5755, 5756, 1, 0, 0, 0, 5756, 507, 1, 0, 0, 0, 5757, 5758, 7, 73, 0, 0, 5758, 509, 1, 0, 0, 0, 5759, 5762, 3, 822, 411, 0, 5760, 5762, 3, 508, 254, 0, 5761, 5759, 1, 0, 0, 0, 5761, 5760, 1, 0, 0, 0, 5762, 5765, 1, 0, 0, 0, 5763, 5766, 3, 54, 27, 0, 5764, 5766, 3, 202, 101, 0, 5765, 5763, 1, 0, 0, 0, 5765, 5764, 1, 0, 0, 0, 5765, 5766, 1, 0, 0, 0, 5766, 511, 1, 0, 0, 0, 5767, 5769, 7, 74, 0, 0, 5768, 5770, 7, 75, 0, 0, 5769, 5768, 1, 0, 0, 0, 5769, 5770, 1, 0, 0, 0, 5770, 5777, 1, 0, 0, 0, 5771, 5774, 5, 548, 0, 0, 5772, 5775, 3, 202, 101, 0, 5773, 5775, 3, 808, 404, 0, 5774, 5772, 1, 0, 0, 0, 5774, 5773, 1, 0, 0, 0, 5775, 5777, 1, 0, 0, 0, 5776, 5767, 1, 0, 0, 0, 5776, 5771, 1, 0, 0, 0, 5777, 513, 1, 0, 0, 0, 5778, 5780, 5, 128, 0, 0, 5779, 5781, 7, 75, 0, 0, 5780, 5779, 1, 0, 0, 0, 5780, 5781, 1, 0, 0, 0, 5781, 515, 1, 0, 0, 0, 5782, 5784, 3, 774, 387, 0, 5783, 5785, 3, 144, 72, 0, 5784, 5783, 1, 0, 0, 0, 5784, 5785, 1, 0, 0, 0, 5785, 517, 1, 0, 0, 0, 5786, 5791, 3, 516, 258, 0, 5787, 5788, 5, 6, 0, 0, 5788, 5790, 3, 516, 258, 0, 5789, 5787, 1, 0, 0, 0, 5790, 5793, 1, 0, 0, 0, 5791, 5789, 1, 0, 0, 0, 5791, 5792, 1, 0, 0, 0, 5792, 519, 1, 0, 0, 0, 5793, 5791, 1, 0, 0, 0, 5794, 5805, 5, 203, 0, 0, 5795, 5806, 3, 524, 262, 0, 5796, 5798, 5, 128, 0, 0, 5797, 5796, 1, 0, 0, 0, 5797, 5798, 1, 0, 0, 0, 5798, 5806, 1, 0, 0, 0, 5799, 5801, 3, 508, 254, 0, 5800, 5802, 3, 514, 257, 0, 5801, 5800, 1, 0, 0, 0, 5801, 5802, 1, 0, 0, 0, 5802, 5804, 1, 0, 0, 0, 5803, 5799, 1, 0, 0, 0, 5803, 5804, 1, 0, 0, 0, 5804, 5806, 1, 0, 0, 0, 5805, 5795, 1, 0, 0, 0, 5805, 5797, 1, 0, 0, 0, 5805, 5803, 1, 0, 0, 0, 5806, 5807, 1, 0, 0, 0, 5807, 5808, 3, 522, 261, 0, 5808, 521, 1, 0, 0, 0, 5809, 5819, 3, 560, 280, 0, 5810, 5819, 3, 538, 269, 0, 5811, 5819, 3, 552, 276, 0, 5812, 5819, 3, 548, 274, 0, 5813, 5819, 3, 558, 279, 0, 5814, 5819, 3, 186, 93, 0, 5815, 5819, 3, 192, 96, 0, 5816, 5819, 3, 194, 97, 0, 5817, 5819, 3, 532, 266, 0, 5818, 5809, 1, 0, 0, 0, 5818, 5810, 1, 0, 0, 0, 5818, 5811, 1, 0, 0, 0, 5818, 5812, 1, 0, 0, 0, 5818, 5813, 1, 0, 0, 0, 5818, 5814, 1, 0, 0, 0, 5818, 5815, 1, 0, 0, 0, 5818, 5816, 1, 0, 0, 0, 5818, 5817, 1, 0, 0, 0, 5819, 523, 1, 0, 0, 0, 5820, 5821, 5, 2, 0, 0, 5821, 5826, 3, 510, 255, 0, 5822, 5823, 5, 6, 0, 0, 5823, 5825, 3, 510, 255, 0, 5824, 5822, 1, 0, 0, 0, 5825, 5828, 1, 0, 0, 0, 5826, 5824, 1, 0, 0, 0, 5826, 5827, 1, 0, 0, 0, 5827, 5829, 1, 0, 0, 0, 5828, 5826, 1, 0, 0, 0, 5829, 5830, 5, 3, 0, 0, 5830, 525, 1, 0, 0, 0, 5831, 5832, 5, 290, 0, 0, 5832, 5834, 3, 818, 409, 0, 5833, 5835, 3, 528, 264, 0, 5834, 5833, 1, 0, 0, 0, 5834, 5835, 1, 0, 0, 0, 5835, 5836, 1, 0, 0, 0, 5836, 5837, 5, 36, 0, 0, 5837, 5838, 3, 530, 265, 0, 5838, 527, 1, 0, 0, 0, 5839, 5840, 5, 2, 0, 0, 5840, 5845, 3, 652, 326, 0, 5841, 5842, 5, 6, 0, 0, 5842, 5844, 3, 652, 326, 0, 5843, 5841, 1, 0, 0, 0, 5844, 5847, 1, 0, 0, 0, 5845, 5843, 1, 0, 0, 0, 5845, 5846, 1, 0, 0, 0, 5846, 5848, 1, 0, 0, 0, 5847, 5845, 1, 0, 0, 0, 5848, 5849, 5, 3, 0, 0, 5849, 529, 1, 0, 0, 0, 5850, 5855, 3, 560, 280, 0, 5851, 5855, 3, 538, 269, 0, 5852, 5855, 3, 552, 276, 0, 5853, 5855, 3, 548, 274, 0, 5854, 5850, 1, 0, 0, 0, 5854, 5851, 1, 0, 0, 0, 5854, 5852, 1, 0, 0, 0, 5854, 5853, 1, 0, 0, 0, 5855, 531, 1, 0, 0, 0, 5856, 5857, 5, 202, 0, 0, 5857, 5859, 3, 818, 409, 0, 5858, 5860, 3, 534, 267, 0, 5859, 5858, 1, 0, 0, 0, 5859, 5860, 1, 0, 0, 0, 5860, 5880, 1, 0, 0, 0, 5861, 5863, 5, 46, 0, 0, 5862, 5864, 3, 122, 61, 0, 5863, 5862, 1, 0, 0, 0, 5863, 5864, 1, 0, 0, 0, 5864, 5865, 1, 0, 0, 0, 5865, 5867, 5, 92, 0, 0, 5866, 5868, 3, 294, 147, 0, 5867, 5866, 1, 0, 0, 0, 5867, 5868, 1, 0, 0, 0, 5868, 5869, 1, 0, 0, 0, 5869, 5870, 3, 188, 94, 0, 5870, 5871, 5, 36, 0, 0, 5871, 5872, 5, 202, 0, 0, 5872, 5874, 3, 818, 409, 0, 5873, 5875, 3, 534, 267, 0, 5874, 5873, 1, 0, 0, 0, 5874, 5875, 1, 0, 0, 0, 5875, 5877, 1, 0, 0, 0, 5876, 5878, 3, 190, 95, 0, 5877, 5876, 1, 0, 0, 0, 5877, 5878, 1, 0, 0, 0, 5878, 5880, 1, 0, 0, 0, 5879, 5856, 1, 0, 0, 0, 5879, 5861, 1, 0, 0, 0, 5880, 533, 1, 0, 0, 0, 5881, 5882, 5, 2, 0, 0, 5882, 5883, 3, 730, 365, 0, 5883, 5884, 5, 3, 0, 0, 5884, 535, 1, 0, 0, 0, 5885, 5887, 5, 177, 0, 0, 5886, 5888, 5, 290, 0, 0, 5887, 5886, 1, 0, 0, 0, 5887, 5888, 1, 0, 0, 0, 5888, 5891, 1, 0, 0, 0, 5889, 5892, 3, 818, 409, 0, 5890, 5892, 5, 30, 0, 0, 5891, 5889, 1, 0, 0, 0, 5891, 5890, 1, 0, 0, 0, 5892, 537, 1, 0, 0, 0, 5893, 5895, 3, 572, 286, 0, 5894, 5893, 1, 0, 0, 0, 5894, 5895, 1, 0, 0, 0, 5895, 5896, 1, 0, 0, 0, 5896, 5897, 5, 241, 0, 0, 5897, 5898, 5, 71, 0, 0, 5898, 5901, 3, 774, 387, 0, 5899, 5900, 5, 36, 0, 0, 5900, 5902, 3, 818, 409, 0, 5901, 5899, 1, 0, 0, 0, 5901, 5902, 1, 0, 0, 0, 5902, 5903, 1, 0, 0, 0, 5903, 5925, 3, 540, 270, 0, 5904, 5905, 5, 80, 0, 0, 5905, 5913, 5, 464, 0, 0, 5906, 5908, 3, 360, 180, 0, 5907, 5909, 3, 638, 319, 0, 5908, 5907, 1, 0, 0, 0, 5908, 5909, 1, 0, 0, 0, 5909, 5914, 1, 0, 0, 0, 5910, 5911, 5, 80, 0, 0, 5911, 5912, 5, 45, 0, 0, 5912, 5914, 3, 818, 409, 0, 5913, 5906, 1, 0, 0, 0, 5913, 5910, 1, 0, 0, 0, 5913, 5914, 1, 0, 0, 0, 5914, 5915, 1, 0, 0, 0, 5915, 5923, 5, 57, 0, 0, 5916, 5917, 5, 369, 0, 0, 5917, 5918, 5, 333, 0, 0, 5918, 5920, 3, 554, 277, 0, 5919, 5921, 3, 638, 319, 0, 5920, 5919, 1, 0, 0, 0, 5920, 5921, 1, 0, 0, 0, 5921, 5924, 1, 0, 0, 0, 5922, 5924, 5, 270, 0, 0, 5923, 5916, 1, 0, 0, 0, 5923, 5922, 1, 0, 0, 0, 5924, 5926, 1, 0, 0, 0, 5925, 5904, 1, 0, 0, 0, 5925, 5926, 1, 0, 0, 0, 5926, 5928, 1, 0, 0, 0, 5927, 5929, 3, 546, 273, 0, 5928, 5927, 1, 0, 0, 0, 5928, 5929, 1, 0, 0, 0, 5929, 539, 1, 0, 0, 0, 5930, 5931, 5, 2, 0, 0, 5931, 5932, 3, 542, 271, 0, 5932, 5933, 5, 3, 0, 0, 5933, 5935, 1, 0, 0, 0, 5934, 5930, 1, 0, 0, 0, 5934, 5935, 1, 0, 0, 0, 5935, 5939, 1, 0, 0, 0, 5936, 5937, 5, 463, 0, 0, 5937, 5938, 7, 76, 0, 0, 5938, 5940, 5, 450, 0, 0, 5939, 5936, 1, 0, 0, 0, 5939, 5940, 1, 0, 0, 0, 5940, 5943, 1, 0, 0, 0, 5941, 5944, 3, 910, 455, 0, 5942, 5944, 3, 560, 280, 0, 5943, 5941, 1, 0, 0, 0, 5943, 5942, 1, 0, 0, 0, 5944, 541, 1, 0, 0, 0, 5945, 5950, 3, 544, 272, 0, 5946, 5947, 5, 6, 0, 0, 5947, 5949, 3, 544, 272, 0, 5948, 5946, 1, 0, 0, 0, 5949, 5952, 1, 0, 0, 0, 5950, 5948, 1, 0, 0, 0, 5950, 5951, 1, 0, 0, 0, 5951, 543, 1, 0, 0, 0, 5952, 5950, 1, 0, 0, 0, 5953, 5954, 3, 800, 400, 0, 5954, 5955, 3, 754, 377, 0, 5955, 545, 1, 0, 0, 0, 5956, 5957, 5, 87, 0, 0, 5957, 5958, 3, 756, 378, 0, 5958, 547, 1, 0, 0, 0, 5959, 5961, 3, 572, 286, 0, 5960, 5959, 1, 0, 0, 0, 5960, 5961, 1, 0, 0, 0, 5961, 5962, 1, 0, 0, 0, 5962, 5963, 5, 182, 0, 0, 5963, 5964, 5, 64, 0, 0, 5964, 5967, 3, 630, 315, 0, 5965, 5966, 5, 100, 0, 0, 5966, 5968, 3, 612, 306, 0, 5967, 5965, 1, 0, 0, 0, 5967, 5968, 1, 0, 0, 0, 5968, 5970, 1, 0, 0, 0, 5969, 5971, 3, 640, 320, 0, 5970, 5969, 1, 0, 0, 0, 5970, 5971, 1, 0, 0, 0, 5971, 5973, 1, 0, 0, 0, 5972, 5974, 3, 546, 273, 0, 5973, 5972, 1, 0, 0, 0, 5973, 5974, 1, 0, 0, 0, 5974, 549, 1, 0, 0, 0, 5975, 5977, 5, 256, 0, 0, 5976, 5978, 5, 92, 0, 0, 5977, 5976, 1, 0, 0, 0, 5977, 5978, 1, 0, 0, 0, 5978, 5979, 1, 0, 0, 0, 5979, 5994, 3, 628, 314, 0, 5980, 5991, 5, 68, 0, 0, 5981, 5982, 7, 77, 0, 0, 5982, 5992, 7, 78, 0, 0, 5983, 5988, 5, 334, 0, 0, 5984, 5985, 5, 369, 0, 0, 5985, 5989, 5, 201, 0, 0, 5986, 5987, 5, 414, 0, 0, 5987, 5989, 5, 201, 0, 0, 5988, 5984, 1, 0, 0, 0, 5988, 5986, 1, 0, 0, 0, 5988, 5989, 1, 0, 0, 0, 5989, 5992, 1, 0, 0, 0, 5990, 5992, 5, 201, 0, 0, 5991, 5981, 1, 0, 0, 0, 5991, 5983, 1, 0, 0, 0, 5991, 5990, 1, 0, 0, 0, 5992, 5993, 1, 0, 0, 0, 5993, 5995, 5, 263, 0, 0, 5994, 5980, 1, 0, 0, 0, 5994, 5995, 1, 0, 0, 0, 5995, 5997, 1, 0, 0, 0, 5996, 5998, 5, 272, 0, 0, 5997, 5996, 1, 0, 0, 0, 5997, 5998, 1, 0, 0, 0, 5998, 551, 1, 0, 0, 0, 5999, 6001, 3, 572, 286, 0, 6000, 5999, 1, 0, 0, 0, 6000, 6001, 1, 0, 0, 0, 6001, 6002, 1, 0, 0, 0, 6002, 6003, 5, 369, 0, 0, 6003, 6004, 3, 630, 315, 0, 6004, 6005, 5, 333, 0, 0, 6005, 6007, 3, 554, 277, 0, 6006, 6008, 3, 610, 305, 0, 6007, 6006, 1, 0, 0, 0, 6007, 6008, 1, 0, 0, 0, 6008, 6010, 1, 0, 0, 0, 6009, 6011, 3, 640, 320, 0, 6010, 6009, 1, 0, 0, 0, 6010, 6011, 1, 0, 0, 0, 6011, 6013, 1, 0, 0, 0, 6012, 6014, 3, 546, 273, 0, 6013, 6012, 1, 0, 0, 0, 6013, 6014, 1, 0, 0, 0, 6014, 553, 1, 0, 0, 0, 6015, 6020, 3, 556, 278, 0, 6016, 6017, 5, 6, 0, 0, 6017, 6019, 3, 556, 278, 0, 6018, 6016, 1, 0, 0, 0, 6019, 6022, 1, 0, 0, 0, 6020, 6018, 1, 0, 0, 0, 6020, 6021, 1, 0, 0, 0, 6021, 555, 1, 0, 0, 0, 6022, 6020, 1, 0, 0, 0, 6023, 6024, 3, 544, 272, 0, 6024, 6025, 5, 10, 0, 0, 6025, 6026, 3, 674, 337, 0, 6026, 6042, 1, 0, 0, 0, 6027, 6028, 5, 2, 0, 0, 6028, 6029, 3, 542, 271, 0, 6029, 6030, 5, 3, 0, 0, 6030, 6039, 5, 10, 0, 0, 6031, 6033, 5, 414, 0, 0, 6032, 6031, 1, 0, 0, 0, 6032, 6033, 1, 0, 0, 0, 6033, 6034, 1, 0, 0, 0, 6034, 6040, 3, 674, 337, 0, 6035, 6036, 5, 2, 0, 0, 6036, 6037, 3, 566, 283, 0, 6037, 6038, 5, 3, 0, 0, 6038, 6040, 1, 0, 0, 0, 6039, 6032, 1, 0, 0, 0, 6039, 6035, 1, 0, 0, 0, 6040, 6042, 1, 0, 0, 0, 6041, 6023, 1, 0, 0, 0, 6041, 6027, 1, 0, 0, 0, 6042, 557, 1, 0, 0, 0, 6043, 6044, 5, 178, 0, 0, 6044, 6053, 3, 818, 409, 0, 6045, 6047, 5, 269, 0, 0, 6046, 6045, 1, 0, 0, 0, 6046, 6047, 1, 0, 0, 0, 6047, 6048, 1, 0, 0, 0, 6048, 6052, 5, 324, 0, 0, 6049, 6052, 5, 107, 0, 0, 6050, 6052, 5, 240, 0, 0, 6051, 6046, 1, 0, 0, 0, 6051, 6049, 1, 0, 0, 0, 6051, 6050, 1, 0, 0, 0, 6052, 6055, 1, 0, 0, 0, 6053, 6051, 1, 0, 0, 0, 6053, 6054, 1, 0, 0, 0, 6054, 6056, 1, 0, 0, 0, 6055, 6053, 1, 0, 0, 0, 6056, 6059, 5, 172, 0, 0, 6057, 6058, 7, 26, 0, 0, 6058, 6060, 5, 217, 0, 0, 6059, 6057, 1, 0, 0, 0, 6059, 6060, 1, 0, 0, 0, 6060, 6061, 1, 0, 0, 0, 6061, 6062, 5, 62, 0, 0, 6062, 6063, 3, 560, 280, 0, 6063, 559, 1, 0, 0, 0, 6064, 6067, 3, 564, 282, 0, 6065, 6067, 3, 562, 281, 0, 6066, 6064, 1, 0, 0, 0, 6066, 6065, 1, 0, 0, 0, 6067, 561, 1, 0, 0, 0, 6068, 6071, 5, 2, 0, 0, 6069, 6072, 3, 564, 282, 0, 6070, 6072, 3, 562, 281, 0, 6071, 6069, 1, 0, 0, 0, 6071, 6070, 1, 0, 0, 0, 6072, 6073, 1, 0, 0, 0, 6073, 6074, 5, 3, 0, 0, 6074, 563, 1, 0, 0, 0, 6075, 6077, 3, 572, 286, 0, 6076, 6075, 1, 0, 0, 0, 6076, 6077, 1, 0, 0, 0, 6077, 6078, 1, 0, 0, 0, 6078, 6080, 3, 566, 283, 0, 6079, 6081, 3, 586, 293, 0, 6080, 6079, 1, 0, 0, 0, 6080, 6081, 1, 0, 0, 0, 6081, 6090, 1, 0, 0, 0, 6082, 6084, 3, 606, 303, 0, 6083, 6085, 3, 590, 295, 0, 6084, 6083, 1, 0, 0, 0, 6084, 6085, 1, 0, 0, 0, 6085, 6091, 1, 0, 0, 0, 6086, 6088, 3, 590, 295, 0, 6087, 6089, 3, 606, 303, 0, 6088, 6087, 1, 0, 0, 0, 6088, 6089, 1, 0, 0, 0, 6089, 6091, 1, 0, 0, 0, 6090, 6082, 1, 0, 0, 0, 6090, 6086, 1, 0, 0, 0, 6090, 6091, 1, 0, 0, 0, 6091, 565, 1, 0, 0, 0, 6092, 6095, 3, 568, 284, 0, 6093, 6095, 3, 562, 281, 0, 6094, 6092, 1, 0, 0, 0, 6094, 6093, 1, 0, 0, 0, 6095, 567, 1, 0, 0, 0, 6096, 6106, 5, 88, 0, 0, 6097, 6099, 5, 30, 0, 0, 6098, 6097, 1, 0, 0, 0, 6098, 6099, 1, 0, 0, 0, 6099, 6101, 1, 0, 0, 0, 6100, 6102, 3, 580, 290, 0, 6101, 6100, 1, 0, 0, 0, 6101, 6102, 1, 0, 0, 0, 6102, 6107, 1, 0, 0, 0, 6103, 6105, 3, 584, 292, 0, 6104, 6103, 1, 0, 0, 0, 6104, 6105, 1, 0, 0, 0, 6105, 6107, 1, 0, 0, 0, 6106, 6098, 1, 0, 0, 0, 6106, 6104, 1, 0, 0, 0, 6107, 6108, 1, 0, 0, 0, 6108, 6119, 3, 932, 466, 0, 6109, 6119, 3, 608, 304, 0, 6110, 6111, 5, 92, 0, 0, 6111, 6119, 3, 624, 312, 0, 6112, 6113, 3, 562, 281, 0, 6113, 6116, 3, 570, 285, 0, 6114, 6117, 3, 568, 284, 0, 6115, 6117, 3, 562, 281, 0, 6116, 6114, 1, 0, 0, 0, 6116, 6115, 1, 0, 0, 0, 6117, 6119, 1, 0, 0, 0, 6118, 6096, 1, 0, 0, 0, 6118, 6109, 1, 0, 0, 0, 6118, 6110, 1, 0, 0, 0, 6118, 6112, 1, 0, 0, 0, 6119, 6127, 1, 0, 0, 0, 6120, 6123, 3, 570, 285, 0, 6121, 6124, 3, 568, 284, 0, 6122, 6124, 3, 562, 281, 0, 6123, 6121, 1, 0, 0, 0, 6123, 6122, 1, 0, 0, 0, 6124, 6126, 1, 0, 0, 0, 6125, 6120, 1, 0, 0, 0, 6126, 6129, 1, 0, 0, 0, 6127, 6125, 1, 0, 0, 0, 6127, 6128, 1, 0, 0, 0, 6128, 569, 1, 0, 0, 0, 6129, 6127, 1, 0, 0, 0, 6130, 6132, 7, 79, 0, 0, 6131, 6133, 7, 80, 0, 0, 6132, 6131, 1, 0, 0, 0, 6132, 6133, 1, 0, 0, 0, 6133, 571, 1, 0, 0, 0, 6134, 6136, 5, 105, 0, 0, 6135, 6137, 5, 303, 0, 0, 6136, 6135, 1, 0, 0, 0, 6136, 6137, 1, 0, 0, 0, 6137, 6138, 1, 0, 0, 0, 6138, 6143, 3, 574, 287, 0, 6139, 6140, 5, 6, 0, 0, 6140, 6142, 3, 574, 287, 0, 6141, 6139, 1, 0, 0, 0, 6142, 6145, 1, 0, 0, 0, 6143, 6141, 1, 0, 0, 0, 6143, 6144, 1, 0, 0, 0, 6144, 573, 1, 0, 0, 0, 6145, 6143, 1, 0, 0, 0, 6146, 6148, 3, 818, 409, 0, 6147, 6149, 3, 144, 72, 0, 6148, 6147, 1, 0, 0, 0, 6148, 6149, 1, 0, 0, 0, 6149, 6150, 1, 0, 0, 0, 6150, 6155, 5, 36, 0, 0, 6151, 6153, 5, 77, 0, 0, 6152, 6151, 1, 0, 0, 0, 6152, 6153, 1, 0, 0, 0, 6153, 6154, 1, 0, 0, 0, 6154, 6156, 5, 259, 0, 0, 6155, 6152, 1, 0, 0, 0, 6155, 6156, 1, 0, 0, 0, 6156, 6157, 1, 0, 0, 0, 6157, 6158, 5, 2, 0, 0, 6158, 6159, 3, 530, 265, 0, 6159, 6161, 5, 3, 0, 0, 6160, 6162, 3, 576, 288, 0, 6161, 6160, 1, 0, 0, 0, 6161, 6162, 1, 0, 0, 0, 6162, 6164, 1, 0, 0, 0, 6163, 6165, 3, 578, 289, 0, 6164, 6163, 1, 0, 0, 0, 6164, 6165, 1, 0, 0, 0, 6165, 575, 1, 0, 0, 0, 6166, 6167, 5, 325, 0, 0, 6167, 6168, 7, 81, 0, 0, 6168, 6169, 5, 207, 0, 0, 6169, 6170, 5, 147, 0, 0, 6170, 6171, 3, 148, 74, 0, 6171, 6172, 5, 333, 0, 0, 6172, 6173, 3, 800, 400, 0, 6173, 577, 1, 0, 0, 0, 6174, 6175, 5, 173, 0, 0, 6175, 6176, 3, 148, 74, 0, 6176, 6177, 5, 333, 0, 0, 6177, 6183, 3, 800, 400, 0, 6178, 6179, 5, 94, 0, 0, 6179, 6180, 3, 818, 409, 0, 6180, 6181, 5, 53, 0, 0, 6181, 6182, 3, 818, 409, 0, 6182, 6184, 1, 0, 0, 0, 6183, 6178, 1, 0, 0, 0, 6183, 6184, 1, 0, 0, 0, 6184, 6185, 1, 0, 0, 0, 6185, 6186, 5, 100, 0, 0, 6186, 6187, 3, 800, 400, 0, 6187, 579, 1, 0, 0, 0, 6188, 6194, 5, 71, 0, 0, 6189, 6191, 5, 346, 0, 0, 6190, 6189, 1, 0, 0, 0, 6190, 6191, 1, 0, 0, 0, 6191, 6192, 1, 0, 0, 0, 6192, 6195, 3, 582, 291, 0, 6193, 6195, 3, 730, 365, 0, 6194, 6190, 1, 0, 0, 0, 6194, 6193, 1, 0, 0, 0, 6195, 581, 1, 0, 0, 0, 6196, 6198, 7, 20, 0, 0, 6197, 6196, 1, 0, 0, 0, 6197, 6198, 1, 0, 0, 0, 6198, 6199, 1, 0, 0, 0, 6199, 6201, 7, 21, 0, 0, 6200, 6202, 5, 92, 0, 0, 6201, 6200, 1, 0, 0, 0, 6201, 6202, 1, 0, 0, 0, 6202, 6203, 1, 0, 0, 0, 6203, 6212, 3, 772, 386, 0, 6204, 6206, 5, 367, 0, 0, 6205, 6204, 1, 0, 0, 0, 6205, 6206, 1, 0, 0, 0, 6206, 6208, 1, 0, 0, 0, 6207, 6209, 5, 92, 0, 0, 6208, 6207, 1, 0, 0, 0, 6208, 6209, 1, 0, 0, 0, 6209, 6210, 1, 0, 0, 0, 6210, 6212, 3, 772, 386, 0, 6211, 6197, 1, 0, 0, 0, 6211, 6205, 1, 0, 0, 0, 6212, 583, 1, 0, 0, 0, 6213, 6216, 5, 56, 0, 0, 6214, 6215, 5, 80, 0, 0, 6215, 6217, 3, 534, 267, 0, 6216, 6214, 1, 0, 0, 0, 6216, 6217, 1, 0, 0, 0, 6217, 585, 1, 0, 0, 0, 6218, 6219, 5, 83, 0, 0, 6219, 6220, 5, 147, 0, 0, 6220, 6225, 3, 588, 294, 0, 6221, 6222, 5, 6, 0, 0, 6222, 6224, 3, 588, 294, 0, 6223, 6221, 1, 0, 0, 0, 6224, 6227, 1, 0, 0, 0, 6225, 6223, 1, 0, 0, 0, 6225, 6226, 1, 0, 0, 0, 6226, 587, 1, 0, 0, 0, 6227, 6225, 1, 0, 0, 0, 6228, 6232, 3, 734, 367, 0, 6229, 6230, 5, 100, 0, 0, 6230, 6233, 3, 726, 363, 0, 6231, 6233, 7, 55, 0, 0, 6232, 6229, 1, 0, 0, 0, 6232, 6231, 1, 0, 0, 0, 6232, 6233, 1, 0, 0, 0, 6233, 6236, 1, 0, 0, 0, 6234, 6235, 5, 273, 0, 0, 6235, 6237, 7, 56, 0, 0, 6236, 6234, 1, 0, 0, 0, 6236, 6237, 1, 0, 0, 0, 6237, 589, 1, 0, 0, 0, 6238, 6240, 3, 596, 298, 0, 6239, 6241, 3, 594, 297, 0, 6240, 6239, 1, 0, 0, 0, 6240, 6241, 1, 0, 0, 0, 6241, 6250, 1, 0, 0, 0, 6242, 6245, 3, 592, 296, 0, 6243, 6245, 3, 594, 297, 0, 6244, 6242, 1, 0, 0, 0, 6244, 6243, 1, 0, 0, 0, 6245, 6247, 1, 0, 0, 0, 6246, 6248, 3, 596, 298, 0, 6247, 6246, 1, 0, 0, 0, 6247, 6248, 1, 0, 0, 0, 6248, 6250, 1, 0, 0, 0, 6249, 6238, 1, 0, 0, 0, 6249, 6244, 1, 0, 0, 0, 6250, 591, 1, 0, 0, 0, 6251, 6254, 5, 74, 0, 0, 6252, 6255, 3, 674, 337, 0, 6253, 6255, 5, 30, 0, 0, 6254, 6252, 1, 0, 0, 0, 6254, 6253, 1, 0, 0, 0, 6255, 6258, 1, 0, 0, 0, 6256, 6257, 5, 6, 0, 0, 6257, 6259, 3, 674, 337, 0, 6258, 6256, 1, 0, 0, 0, 6258, 6259, 1, 0, 0, 0, 6259, 593, 1, 0, 0, 0, 6260, 6261, 5, 61, 0, 0, 6261, 6263, 7, 82, 0, 0, 6262, 6264, 3, 598, 299, 0, 6263, 6262, 1, 0, 0, 0, 6263, 6264, 1, 0, 0, 0, 6264, 6265, 1, 0, 0, 0, 6265, 6269, 7, 83, 0, 0, 6266, 6270, 5, 81, 0, 0, 6267, 6268, 5, 105, 0, 0, 6268, 6270, 5, 467, 0, 0, 6269, 6266, 1, 0, 0, 0, 6269, 6267, 1, 0, 0, 0, 6270, 595, 1, 0, 0, 0, 6271, 6276, 5, 79, 0, 0, 6272, 6273, 3, 598, 299, 0, 6273, 6274, 7, 83, 0, 0, 6274, 6277, 1, 0, 0, 0, 6275, 6277, 3, 674, 337, 0, 6276, 6272, 1, 0, 0, 0, 6276, 6275, 1, 0, 0, 0, 6277, 597, 1, 0, 0, 0, 6278, 6279, 7, 29, 0, 0, 6279, 6282, 7, 84, 0, 0, 6280, 6282, 3, 682, 341, 0, 6281, 6278, 1, 0, 0, 0, 6281, 6280, 1, 0, 0, 0, 6282, 599, 1, 0, 0, 0, 6283, 6284, 5, 66, 0, 0, 6284, 6286, 5, 147, 0, 0, 6285, 6287, 7, 80, 0, 0, 6286, 6285, 1, 0, 0, 0, 6286, 6287, 1, 0, 0, 0, 6287, 6288, 1, 0, 0, 0, 6288, 6289, 3, 602, 301, 0, 6289, 601, 1, 0, 0, 0, 6290, 6295, 3, 604, 302, 0, 6291, 6292, 5, 6, 0, 0, 6292, 6294, 3, 604, 302, 0, 6293, 6291, 1, 0, 0, 0, 6294, 6297, 1, 0, 0, 0, 6295, 6293, 1, 0, 0, 0, 6295, 6296, 1, 0, 0, 0, 6296, 603, 1, 0, 0, 0, 6297, 6295, 1, 0, 0, 0, 6298, 6322, 3, 734, 367, 0, 6299, 6300, 5, 2, 0, 0, 6300, 6322, 5, 3, 0, 0, 6301, 6303, 7, 85, 0, 0, 6302, 6301, 1, 0, 0, 0, 6302, 6303, 1, 0, 0, 0, 6303, 6304, 1, 0, 0, 0, 6304, 6305, 5, 2, 0, 0, 6305, 6310, 3, 734, 367, 0, 6306, 6307, 5, 6, 0, 0, 6307, 6309, 3, 734, 367, 0, 6308, 6306, 1, 0, 0, 0, 6309, 6312, 1, 0, 0, 0, 6310, 6308, 1, 0, 0, 0, 6310, 6311, 1, 0, 0, 0, 6311, 6313, 1, 0, 0, 0, 6312, 6310, 1, 0, 0, 0, 6313, 6314, 5, 3, 0, 0, 6314, 6322, 1, 0, 0, 0, 6315, 6316, 5, 470, 0, 0, 6316, 6317, 5, 471, 0, 0, 6317, 6318, 5, 2, 0, 0, 6318, 6319, 3, 602, 301, 0, 6319, 6320, 5, 3, 0, 0, 6320, 6322, 1, 0, 0, 0, 6321, 6298, 1, 0, 0, 0, 6321, 6299, 1, 0, 0, 0, 6321, 6302, 1, 0, 0, 0, 6321, 6315, 1, 0, 0, 0, 6322, 605, 1, 0, 0, 0, 6323, 6333, 5, 62, 0, 0, 6324, 6325, 5, 269, 0, 0, 6325, 6327, 5, 245, 0, 0, 6326, 6324, 1, 0, 0, 0, 6326, 6327, 1, 0, 0, 0, 6327, 6328, 1, 0, 0, 0, 6328, 6334, 5, 369, 0, 0, 6329, 6331, 5, 245, 0, 0, 6330, 6329, 1, 0, 0, 0, 6330, 6331, 1, 0, 0, 0, 6331, 6332, 1, 0, 0, 0, 6332, 6334, 5, 334, 0, 0, 6333, 6326, 1, 0, 0, 0, 6333, 6330, 1, 0, 0, 0, 6334, 6337, 1, 0, 0, 0, 6335, 6336, 5, 275, 0, 0, 6336, 6338, 3, 760, 380, 0, 6337, 6335, 1, 0, 0, 0, 6337, 6338, 1, 0, 0, 0, 6338, 6342, 1, 0, 0, 0, 6339, 6343, 5, 272, 0, 0, 6340, 6341, 5, 465, 0, 0, 6341, 6343, 5, 466, 0, 0, 6342, 6339, 1, 0, 0, 0, 6342, 6340, 1, 0, 0, 0, 6342, 6343, 1, 0, 0, 0, 6343, 6345, 1, 0, 0, 0, 6344, 6323, 1, 0, 0, 0, 6345, 6346, 1, 0, 0, 0, 6346, 6344, 1, 0, 0, 0, 6346, 6347, 1, 0, 0, 0, 6347, 6352, 1, 0, 0, 0, 6348, 6349, 5, 62, 0, 0, 6349, 6350, 5, 300, 0, 0, 6350, 6352, 5, 81, 0, 0, 6351, 6344, 1, 0, 0, 0, 6351, 6348, 1, 0, 0, 0, 6352, 607, 1, 0, 0, 0, 6353, 6354, 5, 422, 0, 0, 6354, 6359, 3, 534, 267, 0, 6355, 6356, 5, 6, 0, 0, 6356, 6358, 3, 534, 267, 0, 6357, 6355, 1, 0, 0, 0, 6358, 6361, 1, 0, 0, 0, 6359, 6357, 1, 0, 0, 0, 6359, 6360, 1, 0, 0, 0, 6360, 609, 1, 0, 0, 0, 6361, 6359, 1, 0, 0, 0, 6362, 6363, 5, 64, 0, 0, 6363, 6364, 3, 612, 306, 0, 6364, 611, 1, 0, 0, 0, 6365, 6370, 3, 614, 307, 0, 6366, 6367, 5, 6, 0, 0, 6367, 6369, 3, 614, 307, 0, 6368, 6366, 1, 0, 0, 0, 6369, 6372, 1, 0, 0, 0, 6370, 6368, 1, 0, 0, 0, 6370, 6371, 1, 0, 0, 0, 6371, 613, 1, 0, 0, 0, 6372, 6370, 1, 0, 0, 0, 6373, 6388, 3, 624, 312, 0, 6374, 6376, 5, 81, 0, 0, 6375, 6374, 1, 0, 0, 0, 6375, 6376, 1, 0, 0, 0, 6376, 6377, 1, 0, 0, 0, 6377, 6379, 3, 778, 389, 0, 6378, 6380, 5, 9, 0, 0, 6379, 6378, 1, 0, 0, 0, 6379, 6380, 1, 0, 0, 0, 6380, 6382, 1, 0, 0, 0, 6381, 6383, 3, 148, 74, 0, 6382, 6381, 1, 0, 0, 0, 6382, 6383, 1, 0, 0, 0, 6383, 6385, 1, 0, 0, 0, 6384, 6386, 3, 638, 319, 0, 6385, 6384, 1, 0, 0, 0, 6385, 6386, 1, 0, 0, 0, 6386, 6388, 1, 0, 0, 0, 6387, 6373, 1, 0, 0, 0, 6387, 6375, 1, 0, 0, 0, 6388, 6390, 1, 0, 0, 0, 6389, 6391, 3, 616, 308, 0, 6390, 6389, 1, 0, 0, 0, 6390, 6391, 1, 0, 0, 0, 6391, 6393, 1, 0, 0, 0, 6392, 6394, 3, 632, 316, 0, 6393, 6392, 1, 0, 0, 0, 6393, 6394, 1, 0, 0, 0, 6394, 6437, 1, 0, 0, 0, 6395, 6397, 5, 72, 0, 0, 6396, 6395, 1, 0, 0, 0, 6396, 6397, 1, 0, 0, 0, 6397, 6410, 1, 0, 0, 0, 6398, 6400, 3, 646, 323, 0, 6399, 6401, 3, 616, 308, 0, 6400, 6399, 1, 0, 0, 0, 6400, 6401, 1, 0, 0, 0, 6401, 6411, 1, 0, 0, 0, 6402, 6404, 3, 634, 317, 0, 6403, 6405, 3, 618, 309, 0, 6404, 6403, 1, 0, 0, 0, 6404, 6405, 1, 0, 0, 0, 6405, 6411, 1, 0, 0, 0, 6406, 6408, 3, 562, 281, 0, 6407, 6409, 3, 616, 308, 0, 6408, 6407, 1, 0, 0, 0, 6408, 6409, 1, 0, 0, 0, 6409, 6411, 1, 0, 0, 0, 6410, 6398, 1, 0, 0, 0, 6410, 6402, 1, 0, 0, 0, 6410, 6406, 1, 0, 0, 0, 6411, 6437, 1, 0, 0, 0, 6412, 6413, 5, 2, 0, 0, 6413, 6430, 3, 614, 307, 0, 6414, 6415, 5, 110, 0, 0, 6415, 6416, 5, 118, 0, 0, 6416, 6431, 3, 614, 307, 0, 6417, 6419, 5, 121, 0, 0, 6418, 6420, 3, 620, 310, 0, 6419, 6418, 1, 0, 0, 0, 6419, 6420, 1, 0, 0, 0, 6420, 6421, 1, 0, 0, 0, 6421, 6422, 5, 118, 0, 0, 6422, 6431, 3, 614, 307, 0, 6423, 6425, 3, 620, 310, 0, 6424, 6423, 1, 0, 0, 0, 6424, 6425, 1, 0, 0, 0, 6425, 6426, 1, 0, 0, 0, 6426, 6427, 5, 118, 0, 0, 6427, 6428, 3, 614, 307, 0, 6428, 6429, 3, 622, 311, 0, 6429, 6431, 1, 0, 0, 0, 6430, 6414, 1, 0, 0, 0, 6430, 6417, 1, 0, 0, 0, 6430, 6424, 1, 0, 0, 0, 6430, 6431, 1, 0, 0, 0, 6431, 6432, 1, 0, 0, 0, 6432, 6434, 5, 3, 0, 0, 6433, 6435, 3, 616, 308, 0, 6434, 6433, 1, 0, 0, 0, 6434, 6435, 1, 0, 0, 0, 6435, 6437, 1, 0, 0, 0, 6436, 6387, 1, 0, 0, 0, 6436, 6396, 1, 0, 0, 0, 6436, 6412, 1, 0, 0, 0, 6437, 6456, 1, 0, 0, 0, 6438, 6439, 5, 110, 0, 0, 6439, 6440, 5, 118, 0, 0, 6440, 6455, 3, 614, 307, 0, 6441, 6443, 5, 121, 0, 0, 6442, 6444, 3, 620, 310, 0, 6443, 6442, 1, 0, 0, 0, 6443, 6444, 1, 0, 0, 0, 6444, 6445, 1, 0, 0, 0, 6445, 6446, 5, 118, 0, 0, 6446, 6455, 3, 614, 307, 0, 6447, 6449, 3, 620, 310, 0, 6448, 6447, 1, 0, 0, 0, 6448, 6449, 1, 0, 0, 0, 6449, 6450, 1, 0, 0, 0, 6450, 6451, 5, 118, 0, 0, 6451, 6452, 3, 614, 307, 0, 6452, 6453, 3, 622, 311, 0, 6453, 6455, 1, 0, 0, 0, 6454, 6438, 1, 0, 0, 0, 6454, 6441, 1, 0, 0, 0, 6454, 6448, 1, 0, 0, 0, 6455, 6458, 1, 0, 0, 0, 6456, 6454, 1, 0, 0, 0, 6456, 6457, 1, 0, 0, 0, 6457, 615, 1, 0, 0, 0, 6458, 6456, 1, 0, 0, 0, 6459, 6461, 5, 36, 0, 0, 6460, 6459, 1, 0, 0, 0, 6460, 6461, 1, 0, 0, 0, 6461, 6462, 1, 0, 0, 0, 6462, 6467, 3, 818, 409, 0, 6463, 6464, 5, 2, 0, 0, 6464, 6465, 3, 784, 392, 0, 6465, 6466, 5, 3, 0, 0, 6466, 6468, 1, 0, 0, 0, 6467, 6463, 1, 0, 0, 0, 6467, 6468, 1, 0, 0, 0, 6468, 617, 1, 0, 0, 0, 6469, 6482, 3, 616, 308, 0, 6470, 6472, 5, 36, 0, 0, 6471, 6473, 3, 818, 409, 0, 6472, 6471, 1, 0, 0, 0, 6472, 6473, 1, 0, 0, 0, 6473, 6476, 1, 0, 0, 0, 6474, 6476, 3, 818, 409, 0, 6475, 6470, 1, 0, 0, 0, 6475, 6474, 1, 0, 0, 0, 6476, 6477, 1, 0, 0, 0, 6477, 6478, 5, 2, 0, 0, 6478, 6479, 3, 642, 321, 0, 6479, 6480, 5, 3, 0, 0, 6480, 6482, 1, 0, 0, 0, 6481, 6469, 1, 0, 0, 0, 6481, 6475, 1, 0, 0, 0, 6482, 619, 1, 0, 0, 0, 6483, 6485, 7, 86, 0, 0, 6484, 6486, 5, 123, 0, 0, 6485, 6484, 1, 0, 0, 0, 6485, 6486, 1, 0, 0, 0, 6486, 621, 1, 0, 0, 0, 6487, 6488, 5, 100, 0, 0, 6488, 6492, 3, 144, 72, 0, 6489, 6490, 5, 80, 0, 0, 6490, 6492, 3, 674, 337, 0, 6491, 6487, 1, 0, 0, 0, 6491, 6489, 1, 0, 0, 0, 6492, 623, 1, 0, 0, 0, 6493, 6509, 3, 322, 161, 0, 6494, 6500, 5, 81, 0, 0, 6495, 6501, 3, 774, 387, 0, 6496, 6497, 5, 2, 0, 0, 6497, 6498, 3, 774, 387, 0, 6498, 6499, 5, 3, 0, 0, 6499, 6501, 1, 0, 0, 0, 6500, 6495, 1, 0, 0, 0, 6500, 6496, 1, 0, 0, 0, 6501, 6509, 1, 0, 0, 0, 6502, 6503, 5, 68, 0, 0, 6503, 6506, 5, 323, 0, 0, 6504, 6507, 3, 790, 395, 0, 6505, 6507, 5, 111, 0, 0, 6506, 6504, 1, 0, 0, 0, 6506, 6505, 1, 0, 0, 0, 6507, 6509, 1, 0, 0, 0, 6508, 6493, 1, 0, 0, 0, 6508, 6494, 1, 0, 0, 0, 6508, 6502, 1, 0, 0, 0, 6509, 625, 1, 0, 0, 0, 6510, 6511, 5, 92, 0, 0, 6511, 6513, 3, 322, 161, 0, 6512, 6514, 3, 144, 72, 0, 6513, 6512, 1, 0, 0, 0, 6513, 6514, 1, 0, 0, 0, 6514, 6516, 1, 0, 0, 0, 6515, 6517, 3, 638, 319, 0, 6516, 6515, 1, 0, 0, 0, 6516, 6517, 1, 0, 0, 0, 6517, 6535, 1, 0, 0, 0, 6518, 6519, 5, 92, 0, 0, 6519, 6525, 5, 81, 0, 0, 6520, 6526, 3, 774, 387, 0, 6521, 6522, 5, 2, 0, 0, 6522, 6523, 3, 774, 387, 0, 6523, 6524, 5, 3, 0, 0, 6524, 6526, 1, 0, 0, 0, 6525, 6520, 1, 0, 0, 0, 6525, 6521, 1, 0, 0, 0, 6526, 6535, 1, 0, 0, 0, 6527, 6528, 5, 350, 0, 0, 6528, 6529, 5, 68, 0, 0, 6529, 6532, 5, 323, 0, 0, 6530, 6533, 3, 790, 395, 0, 6531, 6533, 5, 111, 0, 0, 6532, 6530, 1, 0, 0, 0, 6532, 6531, 1, 0, 0, 0, 6533, 6535, 1, 0, 0, 0, 6534, 6510, 1, 0, 0, 0, 6534, 6518, 1, 0, 0, 0, 6534, 6527, 1, 0, 0, 0, 6535, 627, 1, 0, 0, 0, 6536, 6541, 3, 624, 312, 0, 6537, 6538, 5, 6, 0, 0, 6538, 6540, 3, 624, 312, 0, 6539, 6537, 1, 0, 0, 0, 6540, 6543, 1, 0, 0, 0, 6541, 6539, 1, 0, 0, 0, 6541, 6542, 1, 0, 0, 0, 6542, 629, 1, 0, 0, 0, 6543, 6541, 1, 0, 0, 0, 6544, 6549, 3, 624, 312, 0, 6545, 6547, 5, 36, 0, 0, 6546, 6545, 1, 0, 0, 0, 6546, 6547, 1, 0, 0, 0, 6547, 6548, 1, 0, 0, 0, 6548, 6550, 3, 818, 409, 0, 6549, 6546, 1, 0, 0, 0, 6549, 6550, 1, 0, 0, 0, 6550, 631, 1, 0, 0, 0, 6551, 6552, 5, 472, 0, 0, 6552, 6553, 3, 806, 403, 0, 6553, 6559, 3, 534, 267, 0, 6554, 6555, 5, 310, 0, 0, 6555, 6556, 5, 2, 0, 0, 6556, 6557, 3, 674, 337, 0, 6557, 6558, 5, 3, 0, 0, 6558, 6560, 1, 0, 0, 0, 6559, 6554, 1, 0, 0, 0, 6559, 6560, 1, 0, 0, 0, 6560, 633, 1, 0, 0, 0, 6561, 6576, 3, 688, 344, 0, 6562, 6563, 5, 320, 0, 0, 6563, 6564, 5, 64, 0, 0, 6564, 6565, 5, 2, 0, 0, 6565, 6570, 3, 636, 318, 0, 6566, 6567, 5, 6, 0, 0, 6567, 6569, 3, 636, 318, 0, 6568, 6566, 1, 0, 0, 0, 6569, 6572, 1, 0, 0, 0, 6570, 6568, 1, 0, 0, 0, 6570, 6571, 1, 0, 0, 0, 6571, 6573, 1, 0, 0, 0, 6572, 6570, 1, 0, 0, 0, 6573, 6574, 5, 3, 0, 0, 6574, 6576, 1, 0, 0, 0, 6575, 6561, 1, 0, 0, 0, 6575, 6562, 1, 0, 0, 0, 6576, 6579, 1, 0, 0, 0, 6577, 6578, 5, 105, 0, 0, 6578, 6580, 5, 473, 0, 0, 6579, 6577, 1, 0, 0, 0, 6579, 6580, 1, 0, 0, 0, 6580, 635, 1, 0, 0, 0, 6581, 6587, 3, 688, 344, 0, 6582, 6583, 5, 36, 0, 0, 6583, 6584, 5, 2, 0, 0, 6584, 6585, 3, 642, 321, 0, 6585, 6586, 5, 3, 0, 0, 6586, 6588, 1, 0, 0, 0, 6587, 6582, 1, 0, 0, 0, 6587, 6588, 1, 0, 0, 0, 6588, 637, 1, 0, 0, 0, 6589, 6590, 5, 103, 0, 0, 6590, 6591, 3, 734, 367, 0, 6591, 639, 1, 0, 0, 0, 6592, 6597, 5, 103, 0, 0, 6593, 6594, 5, 434, 0, 0, 6594, 6595, 5, 275, 0, 0, 6595, 6598, 3, 818, 409, 0, 6596, 6598, 3, 674, 337, 0, 6597, 6593, 1, 0, 0, 0, 6597, 6596, 1, 0, 0, 0, 6598, 641, 1, 0, 0, 0, 6599, 6604, 3, 644, 322, 0, 6600, 6601, 5, 6, 0, 0, 6601, 6603, 3, 644, 322, 0, 6602, 6600, 1, 0, 0, 0, 6603, 6606, 1, 0, 0, 0, 6604, 6602, 1, 0, 0, 0, 6604, 6605, 1, 0, 0, 0, 6605, 643, 1, 0, 0, 0, 6606, 6604, 1, 0, 0, 0, 6607, 6608, 3, 818, 409, 0, 6608, 6610, 3, 652, 326, 0, 6609, 6611, 3, 98, 49, 0, 6610, 6609, 1, 0, 0, 0, 6610, 6611, 1, 0, 0, 0, 6611, 645, 1, 0, 0, 0, 6612, 6613, 5, 474, 0, 0, 6613, 6627, 5, 2, 0, 0, 6614, 6615, 5, 476, 0, 0, 6615, 6616, 5, 2, 0, 0, 6616, 6621, 3, 650, 325, 0, 6617, 6618, 5, 6, 0, 0, 6618, 6620, 3, 650, 325, 0, 6619, 6617, 1, 0, 0, 0, 6620, 6623, 1, 0, 0, 0, 6621, 6619, 1, 0, 0, 0, 6621, 6622, 1, 0, 0, 0, 6622, 6624, 1, 0, 0, 0, 6623, 6621, 1, 0, 0, 0, 6624, 6625, 5, 3, 0, 0, 6625, 6626, 5, 6, 0, 0, 6626, 6628, 1, 0, 0, 0, 6627, 6614, 1, 0, 0, 0, 6627, 6628, 1, 0, 0, 0, 6628, 6629, 1, 0, 0, 0, 6629, 6630, 3, 682, 341, 0, 6630, 6631, 3, 698, 349, 0, 6631, 6632, 5, 475, 0, 0, 6632, 6637, 3, 648, 324, 0, 6633, 6634, 5, 6, 0, 0, 6634, 6636, 3, 648, 324, 0, 6635, 6633, 1, 0, 0, 0, 6636, 6639, 1, 0, 0, 0, 6637, 6635, 1, 0, 0, 0, 6637, 6638, 1, 0, 0, 0, 6638, 6640, 1, 0, 0, 0, 6639, 6637, 1, 0, 0, 0, 6640, 6641, 5, 3, 0, 0, 6641, 647, 1, 0, 0, 0, 6642, 6661, 3, 818, 409, 0, 6643, 6657, 3, 652, 326, 0, 6644, 6647, 5, 53, 0, 0, 6645, 6647, 3, 826, 413, 0, 6646, 6644, 1, 0, 0, 0, 6646, 6645, 1, 0, 0, 0, 6647, 6648, 1, 0, 0, 0, 6648, 6654, 3, 674, 337, 0, 6649, 6651, 5, 77, 0, 0, 6650, 6649, 1, 0, 0, 0, 6650, 6651, 1, 0, 0, 0, 6651, 6652, 1, 0, 0, 0, 6652, 6654, 5, 78, 0, 0, 6653, 6646, 1, 0, 0, 0, 6653, 6650, 1, 0, 0, 0, 6654, 6655, 1, 0, 0, 0, 6655, 6653, 1, 0, 0, 0, 6655, 6656, 1, 0, 0, 0, 6656, 6658, 1, 0, 0, 0, 6657, 6653, 1, 0, 0, 0, 6657, 6658, 1, 0, 0, 0, 6658, 6662, 1, 0, 0, 0, 6659, 6660, 5, 62, 0, 0, 6660, 6662, 5, 473, 0, 0, 6661, 6643, 1, 0, 0, 0, 6661, 6659, 1, 0, 0, 0, 6662, 649, 1, 0, 0, 0, 6663, 6664, 3, 682, 341, 0, 6664, 6665, 5, 36, 0, 0, 6665, 6666, 3, 824, 412, 0, 6666, 6670, 1, 0, 0, 0, 6667, 6668, 5, 53, 0, 0, 6668, 6670, 3, 682, 341, 0, 6669, 6663, 1, 0, 0, 0, 6669, 6667, 1, 0, 0, 0, 6670, 651, 1, 0, 0, 0, 6671, 6673, 5, 415, 0, 0, 6672, 6671, 1, 0, 0, 0, 6672, 6673, 1, 0, 0, 0, 6673, 6674, 1, 0, 0, 0, 6674, 6691, 3, 654, 327, 0, 6675, 6677, 5, 4, 0, 0, 6676, 6678, 5, 571, 0, 0, 6677, 6676, 1, 0, 0, 0, 6677, 6678, 1, 0, 0, 0, 6678, 6679, 1, 0, 0, 0, 6679, 6681, 5, 5, 0, 0, 6680, 6675, 1, 0, 0, 0, 6681, 6684, 1, 0, 0, 0, 6682, 6680, 1, 0, 0, 0, 6682, 6683, 1, 0, 0, 0, 6683, 6692, 1, 0, 0, 0, 6684, 6682, 1, 0, 0, 0, 6685, 6689, 5, 35, 0, 0, 6686, 6687, 5, 4, 0, 0, 6687, 6688, 5, 571, 0, 0, 6688, 6690, 5, 5, 0, 0, 6689, 6686, 1, 0, 0, 0, 6689, 6690, 1, 0, 0, 0, 6690, 6692, 1, 0, 0, 0, 6691, 6682, 1, 0, 0, 0, 6691, 6685, 1, 0, 0, 0, 6692, 6698, 1, 0, 0, 0, 6693, 6694, 3, 780, 390, 0, 6694, 6695, 5, 27, 0, 0, 6695, 6696, 7, 87, 0, 0, 6696, 6698, 1, 0, 0, 0, 6697, 6672, 1, 0, 0, 0, 6697, 6693, 1, 0, 0, 0, 6698, 653, 1, 0, 0, 0, 6699, 6701, 3, 820, 410, 0, 6700, 6702, 3, 318, 159, 0, 6701, 6700, 1, 0, 0, 0, 6701, 6702, 1, 0, 0, 0, 6702, 6704, 1, 0, 0, 0, 6703, 6705, 3, 534, 267, 0, 6704, 6703, 1, 0, 0, 0, 6704, 6705, 1, 0, 0, 0, 6705, 6715, 1, 0, 0, 0, 6706, 6715, 3, 656, 328, 0, 6707, 6712, 5, 403, 0, 0, 6708, 6710, 3, 668, 334, 0, 6709, 6708, 1, 0, 0, 0, 6709, 6710, 1, 0, 0, 0, 6710, 6713, 1, 0, 0, 0, 6711, 6713, 3, 660, 330, 0, 6712, 6709, 1, 0, 0, 0, 6712, 6711, 1, 0, 0, 0, 6713, 6715, 1, 0, 0, 0, 6714, 6699, 1, 0, 0, 0, 6714, 6706, 1, 0, 0, 0, 6714, 6707, 1, 0, 0, 0, 6715, 655, 1, 0, 0, 0, 6716, 6721, 3, 658, 329, 0, 6717, 6721, 3, 662, 331, 0, 6718, 6721, 3, 664, 332, 0, 6719, 6721, 3, 666, 333, 0, 6720, 6716, 1, 0, 0, 0, 6720, 6717, 1, 0, 0, 0, 6720, 6718, 1, 0, 0, 0, 6720, 6719, 1, 0, 0, 0, 6721, 657, 1, 0, 0, 0, 6722, 6739, 5, 401, 0, 0, 6723, 6739, 5, 402, 0, 0, 6724, 6739, 5, 416, 0, 0, 6725, 6739, 5, 388, 0, 0, 6726, 6739, 5, 413, 0, 0, 6727, 6729, 5, 398, 0, 0, 6728, 6730, 3, 660, 330, 0, 6729, 6728, 1, 0, 0, 0, 6729, 6730, 1, 0, 0, 0, 6730, 6739, 1, 0, 0, 0, 6731, 6732, 5, 190, 0, 0, 6732, 6739, 5, 412, 0, 0, 6733, 6735, 7, 88, 0, 0, 6734, 6736, 3, 534, 267, 0, 6735, 6734, 1, 0, 0, 0, 6735, 6736, 1, 0, 0, 0, 6736, 6739, 1, 0, 0, 0, 6737, 6739, 5, 390, 0, 0, 6738, 6722, 1, 0, 0, 0, 6738, 6723, 1, 0, 0, 0, 6738, 6724, 1, 0, 0, 0, 6738, 6725, 1, 0, 0, 0, 6738, 6726, 1, 0, 0, 0, 6738, 6727, 1, 0, 0, 0, 6738, 6731, 1, 0, 0, 0, 6738, 6733, 1, 0, 0, 0, 6738, 6737, 1, 0, 0, 0, 6739, 659, 1, 0, 0, 0, 6740, 6741, 5, 2, 0, 0, 6741, 6742, 5, 571, 0, 0, 6742, 6743, 5, 3, 0, 0, 6743, 661, 1, 0, 0, 0, 6744, 6746, 5, 389, 0, 0, 6745, 6747, 5, 374, 0, 0, 6746, 6745, 1, 0, 0, 0, 6746, 6747, 1, 0, 0, 0, 6747, 6749, 1, 0, 0, 0, 6748, 6750, 3, 534, 267, 0, 6749, 6748, 1, 0, 0, 0, 6749, 6750, 1, 0, 0, 0, 6750, 663, 1, 0, 0, 0, 6751, 6753, 7, 89, 0, 0, 6752, 6754, 5, 374, 0, 0, 6753, 6752, 1, 0, 0, 0, 6753, 6754, 1, 0, 0, 0, 6754, 6762, 1, 0, 0, 0, 6755, 6762, 5, 423, 0, 0, 6756, 6757, 5, 405, 0, 0, 6757, 6759, 7, 90, 0, 0, 6758, 6760, 5, 374, 0, 0, 6759, 6758, 1, 0, 0, 0, 6759, 6760, 1, 0, 0, 0, 6760, 6762, 1, 0, 0, 0, 6761, 6751, 1, 0, 0, 0, 6761, 6755, 1, 0, 0, 0, 6761, 6756, 1, 0, 0, 0, 6762, 6764, 1, 0, 0, 0, 6763, 6765, 3, 660, 330, 0, 6764, 6763, 1, 0, 0, 0, 6764, 6765, 1, 0, 0, 0, 6765, 665, 1, 0, 0, 0, 6766, 6768, 7, 91, 0, 0, 6767, 6769, 3, 660, 330, 0, 6768, 6767, 1, 0, 0, 0, 6768, 6769, 1, 0, 0, 0, 6769, 6773, 1, 0, 0, 0, 6770, 6771, 7, 26, 0, 0, 6771, 6772, 5, 418, 0, 0, 6772, 6774, 5, 386, 0, 0, 6773, 6770, 1, 0, 0, 0, 6773, 6774, 1, 0, 0, 0, 6774, 667, 1, 0, 0, 0, 6775, 6805, 5, 264, 0, 0, 6776, 6805, 3, 670, 335, 0, 6777, 6780, 5, 384, 0, 0, 6778, 6779, 5, 94, 0, 0, 6779, 6781, 5, 264, 0, 0, 6780, 6778, 1, 0, 0, 0, 6780, 6781, 1, 0, 0, 0, 6781, 6805, 1, 0, 0, 0, 6782, 6789, 5, 176, 0, 0, 6783, 6787, 5, 94, 0, 0, 6784, 6788, 5, 218, 0, 0, 6785, 6788, 5, 261, 0, 0, 6786, 6788, 3, 670, 335, 0, 6787, 6784, 1, 0, 0, 0, 6787, 6785, 1, 0, 0, 0, 6787, 6786, 1, 0, 0, 0, 6788, 6790, 1, 0, 0, 0, 6789, 6783, 1, 0, 0, 0, 6789, 6790, 1, 0, 0, 0, 6790, 6805, 1, 0, 0, 0, 6791, 6797, 5, 218, 0, 0, 6792, 6795, 5, 94, 0, 0, 6793, 6796, 5, 261, 0, 0, 6794, 6796, 3, 670, 335, 0, 6795, 6793, 1, 0, 0, 0, 6795, 6794, 1, 0, 0, 0, 6796, 6798, 1, 0, 0, 0, 6797, 6792, 1, 0, 0, 0, 6797, 6798, 1, 0, 0, 0, 6798, 6805, 1, 0, 0, 0, 6799, 6802, 5, 261, 0, 0, 6800, 6801, 5, 94, 0, 0, 6801, 6803, 3, 670, 335, 0, 6802, 6800, 1, 0, 0, 0, 6802, 6803, 1, 0, 0, 0, 6803, 6805, 1, 0, 0, 0, 6804, 6775, 1, 0, 0, 0, 6804, 6776, 1, 0, 0, 0, 6804, 6777, 1, 0, 0, 0, 6804, 6782, 1, 0, 0, 0, 6804, 6791, 1, 0, 0, 0, 6804, 6799, 1, 0, 0, 0, 6805, 669, 1, 0, 0, 0, 6806, 6808, 5, 326, 0, 0, 6807, 6809, 3, 660, 330, 0, 6808, 6807, 1, 0, 0, 0, 6808, 6809, 1, 0, 0, 0, 6809, 671, 1, 0, 0, 0, 6810, 6811, 7, 92, 0, 0, 6811, 673, 1, 0, 0, 0, 6812, 6813, 3, 676, 338, 0, 6813, 675, 1, 0, 0, 0, 6814, 6815, 6, 338, -1, 0, 6815, 6817, 3, 680, 340, 0, 6816, 6818, 3, 678, 339, 0, 6817, 6816, 1, 0, 0, 0, 6817, 6818, 1, 0, 0, 0, 6818, 6822, 1, 0, 0, 0, 6819, 6820, 5, 77, 0, 0, 6820, 6822, 3, 676, 338, 3, 6821, 6814, 1, 0, 0, 0, 6821, 6819, 1, 0, 0, 0, 6822, 6831, 1, 0, 0, 0, 6823, 6824, 10, 2, 0, 0, 6824, 6825, 5, 33, 0, 0, 6825, 6830, 3, 676, 338, 3, 6826, 6827, 10, 1, 0, 0, 6827, 6828, 5, 82, 0, 0, 6828, 6830, 3, 676, 338, 2, 6829, 6823, 1, 0, 0, 0, 6829, 6826, 1, 0, 0, 0, 6830, 6833, 1, 0, 0, 0, 6831, 6829, 1, 0, 0, 0, 6831, 6832, 1, 0, 0, 0, 6832, 677, 1, 0, 0, 0, 6833, 6831, 1, 0, 0, 0, 6834, 6835, 3, 672, 336, 0, 6835, 6836, 3, 680, 340, 0, 6836, 6906, 1, 0, 0, 0, 6837, 6838, 3, 672, 336, 0, 6838, 6839, 3, 728, 364, 0, 6839, 6845, 3, 718, 359, 0, 6840, 6846, 3, 562, 281, 0, 6841, 6842, 5, 2, 0, 0, 6842, 6843, 3, 674, 337, 0, 6843, 6844, 5, 3, 0, 0, 6844, 6846, 1, 0, 0, 0, 6845, 6840, 1, 0, 0, 0, 6845, 6841, 1, 0, 0, 0, 6846, 6906, 1, 0, 0, 0, 6847, 6849, 5, 77, 0, 0, 6848, 6847, 1, 0, 0, 0, 6848, 6849, 1, 0, 0, 0, 6849, 6850, 1, 0, 0, 0, 6850, 6851, 5, 387, 0, 0, 6851, 6852, 3, 680, 340, 0, 6852, 6853, 5, 33, 0, 0, 6853, 6854, 3, 680, 340, 0, 6854, 6906, 1, 0, 0, 0, 6855, 6857, 5, 77, 0, 0, 6856, 6855, 1, 0, 0, 0, 6856, 6857, 1, 0, 0, 0, 6857, 6858, 1, 0, 0, 0, 6858, 6859, 5, 68, 0, 0, 6859, 6860, 5, 2, 0, 0, 6860, 6865, 3, 674, 337, 0, 6861, 6862, 5, 6, 0, 0, 6862, 6864, 3, 674, 337, 0, 6863, 6861, 1, 0, 0, 0, 6864, 6867, 1, 0, 0, 0, 6865, 6863, 1, 0, 0, 0, 6865, 6866, 1, 0, 0, 0, 6866, 6868, 1, 0, 0, 0, 6867, 6865, 1, 0, 0, 0, 6868, 6869, 5, 3, 0, 0, 6869, 6906, 1, 0, 0, 0, 6870, 6872, 5, 77, 0, 0, 6871, 6870, 1, 0, 0, 0, 6871, 6872, 1, 0, 0, 0, 6872, 6873, 1, 0, 0, 0, 6873, 6874, 5, 68, 0, 0, 6874, 6906, 3, 562, 281, 0, 6875, 6877, 5, 77, 0, 0, 6876, 6875, 1, 0, 0, 0, 6876, 6877, 1, 0, 0, 0, 6877, 6886, 1, 0, 0, 0, 6878, 6887, 5, 120, 0, 0, 6879, 6887, 5, 114, 0, 0, 6880, 6881, 5, 127, 0, 0, 6881, 6887, 5, 94, 0, 0, 6882, 6884, 5, 387, 0, 0, 6883, 6885, 5, 91, 0, 0, 6884, 6883, 1, 0, 0, 0, 6884, 6885, 1, 0, 0, 0, 6885, 6887, 1, 0, 0, 0, 6886, 6878, 1, 0, 0, 0, 6886, 6879, 1, 0, 0, 0, 6886, 6880, 1, 0, 0, 0, 6886, 6882, 1, 0, 0, 0, 6887, 6888, 1, 0, 0, 0, 6888, 6891, 3, 680, 340, 0, 6889, 6890, 5, 197, 0, 0, 6890, 6892, 3, 680, 340, 0, 6891, 6889, 1, 0, 0, 0, 6891, 6892, 1, 0, 0, 0, 6892, 6906, 1, 0, 0, 0, 6893, 6895, 5, 116, 0, 0, 6894, 6896, 5, 77, 0, 0, 6895, 6894, 1, 0, 0, 0, 6895, 6896, 1, 0, 0, 0, 6896, 6897, 1, 0, 0, 0, 6897, 6906, 5, 78, 0, 0, 6898, 6900, 5, 116, 0, 0, 6899, 6901, 5, 77, 0, 0, 6900, 6899, 1, 0, 0, 0, 6900, 6901, 1, 0, 0, 0, 6901, 6902, 1, 0, 0, 0, 6902, 6903, 5, 56, 0, 0, 6903, 6904, 5, 64, 0, 0, 6904, 6906, 3, 680, 340, 0, 6905, 6834, 1, 0, 0, 0, 6905, 6837, 1, 0, 0, 0, 6905, 6848, 1, 0, 0, 0, 6905, 6856, 1, 0, 0, 0, 6905, 6871, 1, 0, 0, 0, 6905, 6876, 1, 0, 0, 0, 6905, 6893, 1, 0, 0, 0, 6905, 6898, 1, 0, 0, 0, 6906, 679, 1, 0, 0, 0, 6907, 6908, 6, 340, -1, 0, 6908, 6912, 3, 682, 341, 0, 6909, 6910, 7, 29, 0, 0, 6910, 6912, 3, 680, 340, 4, 6911, 6907, 1, 0, 0, 0, 6911, 6909, 1, 0, 0, 0, 6912, 6929, 1, 0, 0, 0, 6913, 6914, 10, 3, 0, 0, 6914, 6915, 7, 93, 0, 0, 6915, 6928, 3, 680, 340, 4, 6916, 6917, 10, 2, 0, 0, 6917, 6918, 7, 29, 0, 0, 6918, 6928, 3, 680, 340, 3, 6919, 6920, 10, 1, 0, 0, 6920, 6921, 5, 15, 0, 0, 6921, 6928, 3, 680, 340, 2, 6922, 6923, 10, 5, 0, 0, 6923, 6924, 5, 142, 0, 0, 6924, 6925, 5, 418, 0, 0, 6925, 6926, 5, 386, 0, 0, 6926, 6928, 3, 674, 337, 0, 6927, 6913, 1, 0, 0, 0, 6927, 6916, 1, 0, 0, 0, 6927, 6919, 1, 0, 0, 0, 6927, 6922, 1, 0, 0, 0, 6928, 6931, 1, 0, 0, 0, 6929, 6927, 1, 0, 0, 0, 6929, 6930, 1, 0, 0, 0, 6930, 681, 1, 0, 0, 0, 6931, 6929, 1, 0, 0, 0, 6932, 6933, 6, 341, -1, 0, 6933, 6934, 7, 94, 0, 0, 6934, 7021, 3, 562, 281, 0, 6935, 6938, 5, 35, 0, 0, 6936, 6939, 3, 562, 281, 0, 6937, 6939, 3, 740, 370, 0, 6938, 6936, 1, 0, 0, 0, 6938, 6937, 1, 0, 0, 0, 6939, 7021, 1, 0, 0, 0, 6940, 6941, 5, 28, 0, 0, 6941, 7021, 3, 754, 377, 0, 6942, 6943, 5, 470, 0, 0, 6943, 7021, 3, 534, 267, 0, 6944, 7021, 5, 571, 0, 0, 6945, 7021, 5, 573, 0, 0, 6946, 7021, 5, 563, 0, 0, 6947, 7021, 5, 567, 0, 0, 6948, 6958, 3, 806, 403, 0, 6949, 6959, 3, 808, 404, 0, 6950, 6951, 5, 2, 0, 0, 6951, 6953, 3, 736, 368, 0, 6952, 6954, 3, 586, 293, 0, 6953, 6952, 1, 0, 0, 0, 6953, 6954, 1, 0, 0, 0, 6954, 6955, 1, 0, 0, 0, 6955, 6956, 5, 3, 0, 0, 6956, 6957, 3, 808, 404, 0, 6957, 6959, 1, 0, 0, 0, 6958, 6949, 1, 0, 0, 0, 6958, 6950, 1, 0, 0, 0, 6959, 7021, 1, 0, 0, 0, 6960, 6962, 3, 656, 328, 0, 6961, 6960, 1, 0, 0, 0, 6961, 6962, 1, 0, 0, 0, 6962, 6963, 1, 0, 0, 0, 6963, 7021, 3, 808, 404, 0, 6964, 6972, 5, 403, 0, 0, 6965, 6967, 3, 808, 404, 0, 6966, 6968, 3, 668, 334, 0, 6967, 6966, 1, 0, 0, 0, 6967, 6968, 1, 0, 0, 0, 6968, 6973, 1, 0, 0, 0, 6969, 6970, 3, 660, 330, 0, 6970, 6971, 3, 808, 404, 0, 6971, 6973, 1, 0, 0, 0, 6972, 6965, 1, 0, 0, 0, 6972, 6969, 1, 0, 0, 0, 6973, 7021, 1, 0, 0, 0, 6974, 7021, 5, 96, 0, 0, 6975, 7021, 5, 60, 0, 0, 6976, 7021, 5, 78, 0, 0, 6977, 7021, 5, 574, 0, 0, 6978, 6979, 5, 2, 0, 0, 6979, 6980, 3, 674, 337, 0, 6980, 6981, 5, 3, 0, 0, 6981, 6982, 3, 754, 377, 0, 6982, 7021, 1, 0, 0, 0, 6983, 6985, 5, 40, 0, 0, 6984, 6986, 3, 674, 337, 0, 6985, 6984, 1, 0, 0, 0, 6985, 6986, 1, 0, 0, 0, 6986, 6988, 1, 0, 0, 0, 6987, 6989, 3, 748, 374, 0, 6988, 6987, 1, 0, 0, 0, 6989, 6990, 1, 0, 0, 0, 6990, 6988, 1, 0, 0, 0, 6990, 6991, 1, 0, 0, 0, 6991, 6994, 1, 0, 0, 0, 6992, 6993, 5, 58, 0, 0, 6993, 6995, 3, 674, 337, 0, 6994, 6992, 1, 0, 0, 0, 6994, 6995, 1, 0, 0, 0, 6995, 6996, 1, 0, 0, 0, 6996, 6997, 5, 454, 0, 0, 6997, 7021, 1, 0, 0, 0, 6998, 7021, 3, 686, 343, 0, 6999, 7001, 3, 562, 281, 0, 7000, 7002, 3, 752, 376, 0, 7001, 7000, 1, 0, 0, 0, 7001, 7002, 1, 0, 0, 0, 7002, 7021, 1, 0, 0, 0, 7003, 7021, 3, 716, 358, 0, 7004, 7005, 5, 2, 0, 0, 7005, 7006, 3, 674, 337, 0, 7006, 7007, 5, 6, 0, 0, 7007, 7008, 3, 730, 365, 0, 7008, 7009, 5, 3, 0, 0, 7009, 7021, 1, 0, 0, 0, 7010, 7011, 3, 714, 357, 0, 7011, 7012, 5, 125, 0, 0, 7012, 7013, 3, 714, 357, 0, 7013, 7021, 1, 0, 0, 0, 7014, 7021, 3, 780, 390, 0, 7015, 7016, 7, 29, 0, 0, 7016, 7021, 3, 682, 341, 5, 7017, 7018, 3, 724, 362, 0, 7018, 7019, 3, 682, 341, 2, 7019, 7021, 1, 0, 0, 0, 7020, 6932, 1, 0, 0, 0, 7020, 6935, 1, 0, 0, 0, 7020, 6940, 1, 0, 0, 0, 7020, 6942, 1, 0, 0, 0, 7020, 6944, 1, 0, 0, 0, 7020, 6945, 1, 0, 0, 0, 7020, 6946, 1, 0, 0, 0, 7020, 6947, 1, 0, 0, 0, 7020, 6948, 1, 0, 0, 0, 7020, 6961, 1, 0, 0, 0, 7020, 6964, 1, 0, 0, 0, 7020, 6974, 1, 0, 0, 0, 7020, 6975, 1, 0, 0, 0, 7020, 6976, 1, 0, 0, 0, 7020, 6977, 1, 0, 0, 0, 7020, 6978, 1, 0, 0, 0, 7020, 6983, 1, 0, 0, 0, 7020, 6998, 1, 0, 0, 0, 7020, 6999, 1, 0, 0, 0, 7020, 7003, 1, 0, 0, 0, 7020, 7004, 1, 0, 0, 0, 7020, 7010, 1, 0, 0, 0, 7020, 7014, 1, 0, 0, 0, 7020, 7015, 1, 0, 0, 0, 7020, 7017, 1, 0, 0, 0, 7021, 7049, 1, 0, 0, 0, 7022, 7023, 10, 3, 0, 0, 7023, 7024, 3, 722, 361, 0, 7024, 7025, 3, 682, 341, 4, 7025, 7048, 1, 0, 0, 0, 7026, 7027, 10, 6, 0, 0, 7027, 7028, 5, 26, 0, 0, 7028, 7048, 3, 652, 326, 0, 7029, 7030, 10, 4, 0, 0, 7030, 7032, 3, 724, 362, 0, 7031, 7033, 3, 682, 341, 0, 7032, 7031, 1, 0, 0, 0, 7032, 7033, 1, 0, 0, 0, 7033, 7048, 1, 0, 0, 0, 7034, 7035, 10, 1, 0, 0, 7035, 7037, 5, 116, 0, 0, 7036, 7038, 5, 77, 0, 0, 7037, 7036, 1, 0, 0, 0, 7037, 7038, 1, 0, 0, 0, 7038, 7045, 1, 0, 0, 0, 7039, 7040, 5, 56, 0, 0, 7040, 7041, 5, 64, 0, 0, 7041, 7046, 3, 682, 341, 0, 7042, 7043, 5, 275, 0, 0, 7043, 7046, 3, 528, 264, 0, 7044, 7046, 5, 188, 0, 0, 7045, 7039, 1, 0, 0, 0, 7045, 7042, 1, 0, 0, 0, 7045, 7044, 1, 0, 0, 0, 7046, 7048, 1, 0, 0, 0, 7047, 7022, 1, 0, 0, 0, 7047, 7026, 1, 0, 0, 0, 7047, 7029, 1, 0, 0, 0, 7047, 7034, 1, 0, 0, 0, 7048, 7051, 1, 0, 0, 0, 7049, 7047, 1, 0, 0, 0, 7049, 7050, 1, 0, 0, 0, 7050, 683, 1, 0, 0, 0, 7051, 7049, 1, 0, 0, 0, 7052, 7078, 3, 806, 403, 0, 7053, 7075, 5, 2, 0, 0, 7054, 7058, 3, 736, 368, 0, 7055, 7056, 5, 6, 0, 0, 7056, 7057, 5, 101, 0, 0, 7057, 7059, 3, 738, 369, 0, 7058, 7055, 1, 0, 0, 0, 7058, 7059, 1, 0, 0, 0, 7059, 7061, 1, 0, 0, 0, 7060, 7062, 3, 586, 293, 0, 7061, 7060, 1, 0, 0, 0, 7061, 7062, 1, 0, 0, 0, 7062, 7076, 1, 0, 0, 0, 7063, 7064, 5, 101, 0, 0, 7064, 7066, 3, 738, 369, 0, 7065, 7067, 3, 586, 293, 0, 7066, 7065, 1, 0, 0, 0, 7066, 7067, 1, 0, 0, 0, 7067, 7076, 1, 0, 0, 0, 7068, 7069, 7, 80, 0, 0, 7069, 7071, 3, 736, 368, 0, 7070, 7072, 3, 586, 293, 0, 7071, 7070, 1, 0, 0, 0, 7071, 7072, 1, 0, 0, 0, 7072, 7076, 1, 0, 0, 0, 7073, 7076, 5, 9, 0, 0, 7074, 7076, 1, 0, 0, 0, 7075, 7054, 1, 0, 0, 0, 7075, 7063, 1, 0, 0, 0, 7075, 7068, 1, 0, 0, 0, 7075, 7073, 1, 0, 0, 0, 7075, 7074, 1, 0, 0, 0, 7076, 7077, 1, 0, 0, 0, 7077, 7079, 5, 3, 0, 0, 7078, 7053, 1, 0, 0, 0, 7078, 7079, 1, 0, 0, 0, 7079, 685, 1, 0, 0, 0, 7080, 7087, 3, 684, 342, 0, 7081, 7082, 5, 479, 0, 0, 7082, 7083, 5, 66, 0, 0, 7083, 7084, 5, 2, 0, 0, 7084, 7085, 3, 586, 293, 0, 7085, 7086, 5, 3, 0, 0, 7086, 7088, 1, 0, 0, 0, 7087, 7081, 1, 0, 0, 0, 7087, 7088, 1, 0, 0, 0, 7088, 7095, 1, 0, 0, 0, 7089, 7090, 5, 480, 0, 0, 7090, 7091, 5, 2, 0, 0, 7091, 7092, 5, 103, 0, 0, 7092, 7093, 3, 674, 337, 0, 7093, 7094, 5, 3, 0, 0, 7094, 7096, 1, 0, 0, 0, 7095, 7089, 1, 0, 0, 0, 7095, 7096, 1, 0, 0, 0, 7096, 7102, 1, 0, 0, 0, 7097, 7100, 5, 124, 0, 0, 7098, 7101, 3, 708, 354, 0, 7099, 7101, 3, 818, 409, 0, 7100, 7098, 1, 0, 0, 0, 7100, 7099, 1, 0, 0, 0, 7101, 7103, 1, 0, 0, 0, 7102, 7097, 1, 0, 0, 0, 7102, 7103, 1, 0, 0, 0, 7103, 7106, 1, 0, 0, 0, 7104, 7106, 3, 690, 345, 0, 7105, 7080, 1, 0, 0, 0, 7105, 7104, 1, 0, 0, 0, 7106, 687, 1, 0, 0, 0, 7107, 7110, 3, 684, 342, 0, 7108, 7110, 3, 690, 345, 0, 7109, 7107, 1, 0, 0, 0, 7109, 7108, 1, 0, 0, 0, 7110, 689, 1, 0, 0, 0, 7111, 7112, 5, 108, 0, 0, 7112, 7113, 5, 62, 0, 0, 7113, 7114, 5, 2, 0, 0, 7114, 7115, 3, 674, 337, 0, 7115, 7116, 5, 3, 0, 0, 7116, 7286, 1, 0, 0, 0, 7117, 7286, 5, 48, 0, 0, 7118, 7120, 7, 95, 0, 0, 7119, 7121, 3, 660, 330, 0, 7120, 7119, 1, 0, 0, 0, 7120, 7121, 1, 0, 0, 0, 7121, 7286, 1, 0, 0, 0, 7122, 7286, 5, 49, 0, 0, 7123, 7286, 5, 52, 0, 0, 7124, 7286, 5, 89, 0, 0, 7125, 7286, 5, 99, 0, 0, 7126, 7286, 5, 47, 0, 0, 7127, 7286, 5, 111, 0, 0, 7128, 7129, 7, 96, 0, 0, 7129, 7130, 5, 2, 0, 0, 7130, 7131, 3, 674, 337, 0, 7131, 7132, 5, 36, 0, 0, 7132, 7133, 3, 652, 326, 0, 7133, 7134, 5, 3, 0, 0, 7134, 7286, 1, 0, 0, 0, 7135, 7136, 5, 397, 0, 0, 7136, 7141, 5, 2, 0, 0, 7137, 7138, 3, 742, 371, 0, 7138, 7139, 5, 64, 0, 0, 7139, 7140, 3, 674, 337, 0, 7140, 7142, 1, 0, 0, 0, 7141, 7137, 1, 0, 0, 0, 7141, 7142, 1, 0, 0, 0, 7142, 7143, 1, 0, 0, 0, 7143, 7286, 5, 3, 0, 0, 7144, 7145, 5, 489, 0, 0, 7145, 7146, 5, 2, 0, 0, 7146, 7149, 3, 674, 337, 0, 7147, 7148, 5, 6, 0, 0, 7148, 7150, 3, 744, 372, 0, 7149, 7147, 1, 0, 0, 0, 7149, 7150, 1, 0, 0, 0, 7150, 7151, 1, 0, 0, 0, 7151, 7152, 5, 3, 0, 0, 7152, 7286, 1, 0, 0, 0, 7153, 7154, 5, 410, 0, 0, 7154, 7155, 5, 2, 0, 0, 7155, 7156, 3, 674, 337, 0, 7156, 7157, 5, 84, 0, 0, 7157, 7158, 3, 674, 337, 0, 7158, 7159, 5, 64, 0, 0, 7159, 7162, 3, 674, 337, 0, 7160, 7161, 5, 62, 0, 0, 7161, 7163, 3, 674, 337, 0, 7162, 7160, 1, 0, 0, 0, 7162, 7163, 1, 0, 0, 0, 7163, 7164, 1, 0, 0, 0, 7164, 7165, 5, 3, 0, 0, 7165, 7286, 1, 0, 0, 0, 7166, 7167, 5, 411, 0, 0, 7167, 7172, 5, 2, 0, 0, 7168, 7169, 3, 682, 341, 0, 7169, 7170, 5, 68, 0, 0, 7170, 7171, 3, 682, 341, 0, 7171, 7173, 1, 0, 0, 0, 7172, 7168, 1, 0, 0, 0, 7172, 7173, 1, 0, 0, 0, 7173, 7174, 1, 0, 0, 0, 7174, 7286, 5, 3, 0, 0, 7175, 7176, 5, 417, 0, 0, 7176, 7178, 5, 2, 0, 0, 7177, 7179, 3, 746, 373, 0, 7178, 7177, 1, 0, 0, 0, 7178, 7179, 1, 0, 0, 0, 7179, 7180, 1, 0, 0, 0, 7180, 7286, 5, 3, 0, 0, 7181, 7182, 5, 421, 0, 0, 7182, 7184, 5, 2, 0, 0, 7183, 7185, 7, 97, 0, 0, 7184, 7183, 1, 0, 0, 0, 7184, 7185, 1, 0, 0, 0, 7185, 7190, 1, 0, 0, 0, 7186, 7188, 3, 674, 337, 0, 7187, 7186, 1, 0, 0, 0, 7187, 7188, 1, 0, 0, 0, 7188, 7189, 1, 0, 0, 0, 7189, 7191, 5, 64, 0, 0, 7190, 7187, 1, 0, 0, 0, 7190, 7191, 1, 0, 0, 0, 7191, 7192, 1, 0, 0, 0, 7192, 7193, 3, 730, 365, 0, 7193, 7194, 1, 0, 0, 0, 7194, 7195, 5, 3, 0, 0, 7195, 7286, 1, 0, 0, 0, 7196, 7197, 5, 408, 0, 0, 7197, 7198, 5, 2, 0, 0, 7198, 7199, 3, 674, 337, 0, 7199, 7200, 5, 6, 0, 0, 7200, 7201, 3, 674, 337, 0, 7201, 7202, 5, 3, 0, 0, 7202, 7286, 1, 0, 0, 0, 7203, 7204, 7, 98, 0, 0, 7204, 7286, 3, 534, 267, 0, 7205, 7206, 5, 426, 0, 0, 7206, 7207, 5, 2, 0, 0, 7207, 7208, 5, 266, 0, 0, 7208, 7218, 3, 824, 412, 0, 7209, 7216, 5, 6, 0, 0, 7210, 7211, 5, 424, 0, 0, 7211, 7212, 5, 2, 0, 0, 7212, 7213, 3, 692, 346, 0, 7213, 7214, 5, 3, 0, 0, 7214, 7217, 1, 0, 0, 0, 7215, 7217, 3, 730, 365, 0, 7216, 7210, 1, 0, 0, 0, 7216, 7215, 1, 0, 0, 0, 7217, 7219, 1, 0, 0, 0, 7218, 7209, 1, 0, 0, 0, 7218, 7219, 1, 0, 0, 0, 7219, 7220, 1, 0, 0, 0, 7220, 7221, 5, 3, 0, 0, 7221, 7286, 1, 0, 0, 0, 7222, 7223, 5, 427, 0, 0, 7223, 7224, 5, 2, 0, 0, 7224, 7225, 3, 682, 341, 0, 7225, 7226, 3, 698, 349, 0, 7226, 7227, 5, 3, 0, 0, 7227, 7286, 1, 0, 0, 0, 7228, 7229, 5, 428, 0, 0, 7229, 7230, 5, 2, 0, 0, 7230, 7231, 3, 692, 346, 0, 7231, 7232, 5, 3, 0, 0, 7232, 7286, 1, 0, 0, 0, 7233, 7234, 5, 429, 0, 0, 7234, 7235, 5, 2, 0, 0, 7235, 7236, 3, 696, 348, 0, 7236, 7239, 3, 674, 337, 0, 7237, 7238, 7, 99, 0, 0, 7238, 7240, 5, 378, 0, 0, 7239, 7237, 1, 0, 0, 0, 7239, 7240, 1, 0, 0, 0, 7240, 7241, 1, 0, 0, 0, 7241, 7242, 5, 3, 0, 0, 7242, 7286, 1, 0, 0, 0, 7243, 7244, 5, 430, 0, 0, 7244, 7245, 5, 2, 0, 0, 7245, 7246, 5, 266, 0, 0, 7246, 7249, 3, 824, 412, 0, 7247, 7248, 5, 6, 0, 0, 7248, 7250, 3, 674, 337, 0, 7249, 7247, 1, 0, 0, 0, 7249, 7250, 1, 0, 0, 0, 7250, 7251, 1, 0, 0, 0, 7251, 7252, 5, 3, 0, 0, 7252, 7286, 1, 0, 0, 0, 7253, 7254, 5, 431, 0, 0, 7254, 7255, 5, 2, 0, 0, 7255, 7256, 5, 383, 0, 0, 7256, 7257, 3, 674, 337, 0, 7257, 7258, 5, 6, 0, 0, 7258, 7262, 5, 375, 0, 0, 7259, 7260, 5, 269, 0, 0, 7260, 7263, 5, 450, 0, 0, 7261, 7263, 3, 674, 337, 0, 7262, 7259, 1, 0, 0, 0, 7262, 7261, 1, 0, 0, 0, 7263, 7273, 1, 0, 0, 0, 7264, 7265, 5, 6, 0, 0, 7265, 7271, 5, 339, 0, 0, 7266, 7268, 5, 269, 0, 0, 7267, 7266, 1, 0, 0, 0, 7267, 7268, 1, 0, 0, 0, 7268, 7269, 1, 0, 0, 0, 7269, 7272, 5, 450, 0, 0, 7270, 7272, 5, 385, 0, 0, 7271, 7267, 1, 0, 0, 0, 7271, 7270, 1, 0, 0, 0, 7272, 7274, 1, 0, 0, 0, 7273, 7264, 1, 0, 0, 0, 7273, 7274, 1, 0, 0, 0, 7274, 7275, 1, 0, 0, 0, 7275, 7276, 5, 3, 0, 0, 7276, 7286, 1, 0, 0, 0, 7277, 7278, 5, 432, 0, 0, 7278, 7279, 5, 2, 0, 0, 7279, 7280, 3, 696, 348, 0, 7280, 7281, 3, 674, 337, 0, 7281, 7282, 5, 36, 0, 0, 7282, 7283, 3, 654, 327, 0, 7283, 7284, 5, 3, 0, 0, 7284, 7286, 1, 0, 0, 0, 7285, 7111, 1, 0, 0, 0, 7285, 7117, 1, 0, 0, 0, 7285, 7118, 1, 0, 0, 0, 7285, 7122, 1, 0, 0, 0, 7285, 7123, 1, 0, 0, 0, 7285, 7124, 1, 0, 0, 0, 7285, 7125, 1, 0, 0, 0, 7285, 7126, 1, 0, 0, 0, 7285, 7127, 1, 0, 0, 0, 7285, 7128, 1, 0, 0, 0, 7285, 7135, 1, 0, 0, 0, 7285, 7144, 1, 0, 0, 0, 7285, 7153, 1, 0, 0, 0, 7285, 7166, 1, 0, 0, 0, 7285, 7175, 1, 0, 0, 0, 7285, 7181, 1, 0, 0, 0, 7285, 7196, 1, 0, 0, 0, 7285, 7203, 1, 0, 0, 0, 7285, 7205, 1, 0, 0, 0, 7285, 7222, 1, 0, 0, 0, 7285, 7228, 1, 0, 0, 0, 7285, 7233, 1, 0, 0, 0, 7285, 7243, 1, 0, 0, 0, 7285, 7253, 1, 0, 0, 0, 7285, 7277, 1, 0, 0, 0, 7286, 691, 1, 0, 0, 0, 7287, 7292, 3, 694, 347, 0, 7288, 7289, 5, 6, 0, 0, 7289, 7291, 3, 694, 347, 0, 7290, 7288, 1, 0, 0, 0, 7291, 7294, 1, 0, 0, 0, 7292, 7290, 1, 0, 0, 0, 7292, 7293, 1, 0, 0, 0, 7293, 693, 1, 0, 0, 0, 7294, 7292, 1, 0, 0, 0, 7295, 7298, 3, 674, 337, 0, 7296, 7297, 5, 36, 0, 0, 7297, 7299, 3, 824, 412, 0, 7298, 7296, 1, 0, 0, 0, 7298, 7299, 1, 0, 0, 0, 7299, 695, 1, 0, 0, 0, 7300, 7301, 7, 100, 0, 0, 7301, 697, 1, 0, 0, 0, 7302, 7304, 5, 286, 0, 0, 7303, 7305, 3, 700, 350, 0, 7304, 7303, 1, 0, 0, 0, 7304, 7305, 1, 0, 0, 0, 7305, 7306, 1, 0, 0, 0, 7306, 7308, 3, 682, 341, 0, 7307, 7309, 3, 700, 350, 0, 7308, 7307, 1, 0, 0, 0, 7308, 7309, 1, 0, 0, 0, 7309, 699, 1, 0, 0, 0, 7310, 7311, 5, 147, 0, 0, 7311, 7312, 7, 101, 0, 0, 7312, 701, 1, 0, 0, 0, 7313, 7314, 5, 104, 0, 0, 7314, 7319, 3, 704, 352, 0, 7315, 7316, 5, 6, 0, 0, 7316, 7318, 3, 704, 352, 0, 7317, 7315, 1, 0, 0, 0, 7318, 7321, 1, 0, 0, 0, 7319, 7317, 1, 0, 0, 0, 7319, 7320, 1, 0, 0, 0, 7320, 703, 1, 0, 0, 0, 7321, 7319, 1, 0, 0, 0, 7322, 7323, 3, 818, 409, 0, 7323, 7324, 5, 36, 0, 0, 7324, 7325, 3, 708, 354, 0, 7325, 705, 1, 0, 0, 0, 7326, 7329, 5, 124, 0, 0, 7327, 7330, 3, 708, 354, 0, 7328, 7330, 3, 818, 409, 0, 7329, 7327, 1, 0, 0, 0, 7329, 7328, 1, 0, 0, 0, 7330, 707, 1, 0, 0, 0, 7331, 7333, 5, 2, 0, 0, 7332, 7334, 3, 818, 409, 0, 7333, 7332, 1, 0, 0, 0, 7333, 7334, 1, 0, 0, 0, 7334, 7338, 1, 0, 0, 0, 7335, 7336, 5, 285, 0, 0, 7336, 7337, 5, 147, 0, 0, 7337, 7339, 3, 730, 365, 0, 7338, 7335, 1, 0, 0, 0, 7338, 7339, 1, 0, 0, 0, 7339, 7341, 1, 0, 0, 0, 7340, 7342, 3, 586, 293, 0, 7341, 7340, 1, 0, 0, 0, 7341, 7342, 1, 0, 0, 0, 7342, 7344, 1, 0, 0, 0, 7343, 7345, 3, 710, 355, 0, 7344, 7343, 1, 0, 0, 0, 7344, 7345, 1, 0, 0, 0, 7345, 7346, 1, 0, 0, 0, 7346, 7347, 5, 3, 0, 0, 7347, 709, 1, 0, 0, 0, 7348, 7353, 7, 102, 0, 0, 7349, 7350, 5, 387, 0, 0, 7350, 7351, 3, 712, 356, 0, 7351, 7352, 5, 33, 0, 0, 7352, 7354, 1, 0, 0, 0, 7353, 7349, 1, 0, 0, 0, 7353, 7354, 1, 0, 0, 0, 7354, 7355, 1, 0, 0, 0, 7355, 7356, 3, 712, 356, 0, 7356, 7366, 1, 0, 0, 0, 7357, 7364, 5, 199, 0, 0, 7358, 7359, 5, 434, 0, 0, 7359, 7365, 5, 414, 0, 0, 7360, 7365, 5, 66, 0, 0, 7361, 7365, 5, 467, 0, 0, 7362, 7363, 5, 269, 0, 0, 7363, 7365, 5, 482, 0, 0, 7364, 7358, 1, 0, 0, 0, 7364, 7360, 1, 0, 0, 0, 7364, 7361, 1, 0, 0, 0, 7364, 7362, 1, 0, 0, 0, 7365, 7367, 1, 0, 0, 0, 7366, 7357, 1, 0, 0, 0, 7366, 7367, 1, 0, 0, 0, 7367, 711, 1, 0, 0, 0, 7368, 7371, 5, 362, 0, 0, 7369, 7371, 3, 674, 337, 0, 7370, 7368, 1, 0, 0, 0, 7370, 7369, 1, 0, 0, 0, 7371, 7372, 1, 0, 0, 0, 7372, 7376, 7, 103, 0, 0, 7373, 7374, 5, 434, 0, 0, 7374, 7376, 5, 414, 0, 0, 7375, 7370, 1, 0, 0, 0, 7375, 7373, 1, 0, 0, 0, 7376, 713, 1, 0, 0, 0, 7377, 7385, 3, 716, 358, 0, 7378, 7379, 5, 2, 0, 0, 7379, 7380, 3, 730, 365, 0, 7380, 7381, 5, 6, 0, 0, 7381, 7382, 3, 674, 337, 0, 7382, 7383, 5, 3, 0, 0, 7383, 7385, 1, 0, 0, 0, 7384, 7377, 1, 0, 0, 0, 7384, 7378, 1, 0, 0, 0, 7385, 715, 1, 0, 0, 0, 7386, 7387, 5, 414, 0, 0, 7387, 7389, 5, 2, 0, 0, 7388, 7390, 3, 730, 365, 0, 7389, 7388, 1, 0, 0, 0, 7389, 7390, 1, 0, 0, 0, 7390, 7391, 1, 0, 0, 0, 7391, 7392, 5, 3, 0, 0, 7392, 717, 1, 0, 0, 0, 7393, 7394, 7, 104, 0, 0, 7394, 719, 1, 0, 0, 0, 7395, 7398, 5, 29, 0, 0, 7396, 7398, 3, 722, 361, 0, 7397, 7395, 1, 0, 0, 0, 7397, 7396, 1, 0, 0, 0, 7398, 721, 1, 0, 0, 0, 7399, 7400, 7, 105, 0, 0, 7400, 723, 1, 0, 0, 0, 7401, 7408, 5, 29, 0, 0, 7402, 7403, 5, 278, 0, 0, 7403, 7404, 5, 2, 0, 0, 7404, 7405, 3, 414, 207, 0, 7405, 7406, 5, 3, 0, 0, 7406, 7408, 1, 0, 0, 0, 7407, 7401, 1, 0, 0, 0, 7407, 7402, 1, 0, 0, 0, 7408, 725, 1, 0, 0, 0, 7409, 7416, 3, 720, 360, 0, 7410, 7411, 5, 278, 0, 0, 7411, 7412, 5, 2, 0, 0, 7412, 7413, 3, 414, 207, 0, 7413, 7414, 5, 3, 0, 0, 7414, 7416, 1, 0, 0, 0, 7415, 7409, 1, 0, 0, 0, 7415, 7410, 1, 0, 0, 0, 7416, 727, 1, 0, 0, 0, 7417, 7423, 3, 726, 363, 0, 7418, 7420, 5, 77, 0, 0, 7419, 7418, 1, 0, 0, 0, 7419, 7420, 1, 0, 0, 0, 7420, 7421, 1, 0, 0, 0, 7421, 7423, 7, 106, 0, 0, 7422, 7417, 1, 0, 0, 0, 7422, 7419, 1, 0, 0, 0, 7423, 729, 1, 0, 0, 0, 7424, 7429, 3, 674, 337, 0, 7425, 7426, 5, 6, 0, 0, 7426, 7428, 3, 674, 337, 0, 7427, 7425, 1, 0, 0, 0, 7428, 7431, 1, 0, 0, 0, 7429, 7427, 1, 0, 0, 0, 7429, 7430, 1, 0, 0, 0, 7430, 731, 1, 0, 0, 0, 7431, 7429, 1, 0, 0, 0, 7432, 7433, 5, 2, 0, 0, 7433, 7434, 3, 674, 337, 0, 7434, 7435, 5, 3, 0, 0, 7435, 7438, 1, 0, 0, 0, 7436, 7438, 3, 800, 400, 0, 7437, 7432, 1, 0, 0, 0, 7437, 7436, 1, 0, 0, 0, 7438, 733, 1, 0, 0, 0, 7439, 7442, 3, 674, 337, 0, 7440, 7442, 3, 800, 400, 0, 7441, 7439, 1, 0, 0, 0, 7441, 7440, 1, 0, 0, 0, 7442, 735, 1, 0, 0, 0, 7443, 7448, 3, 738, 369, 0, 7444, 7445, 5, 6, 0, 0, 7445, 7447, 3, 738, 369, 0, 7446, 7444, 1, 0, 0, 0, 7447, 7450, 1, 0, 0, 0, 7448, 7446, 1, 0, 0, 0, 7448, 7449, 1, 0, 0, 0, 7449, 737, 1, 0, 0, 0, 7450, 7448, 1, 0, 0, 0, 7451, 7457, 3, 674, 337, 0, 7452, 7453, 3, 820, 410, 0, 7453, 7454, 7, 107, 0, 0, 7454, 7455, 3, 674, 337, 0, 7455, 7457, 1, 0, 0, 0, 7456, 7451, 1, 0, 0, 0, 7456, 7452, 1, 0, 0, 0, 7457, 739, 1, 0, 0, 0, 7458, 7468, 5, 4, 0, 0, 7459, 7469, 3, 730, 365, 0, 7460, 7465, 3, 740, 370, 0, 7461, 7462, 5, 6, 0, 0, 7462, 7464, 3, 740, 370, 0, 7463, 7461, 1, 0, 0, 0, 7464, 7467, 1, 0, 0, 0, 7465, 7463, 1, 0, 0, 0, 7465, 7466, 1, 0, 0, 0, 7466, 7469, 1, 0, 0, 0, 7467, 7465, 1, 0, 0, 0, 7468, 7459, 1, 0, 0, 0, 7468, 7460, 1, 0, 0, 0, 7468, 7469, 1, 0, 0, 0, 7469, 7470, 1, 0, 0, 0, 7470, 7471, 5, 5, 0, 0, 7471, 741, 1, 0, 0, 0, 7472, 7481, 3, 826, 413, 0, 7473, 7481, 5, 384, 0, 0, 7474, 7481, 5, 264, 0, 0, 7475, 7481, 5, 176, 0, 0, 7476, 7481, 5, 218, 0, 0, 7477, 7481, 5, 261, 0, 0, 7478, 7481, 5, 326, 0, 0, 7479, 7481, 3, 808, 404, 0, 7480, 7472, 1, 0, 0, 0, 7480, 7473, 1, 0, 0, 0, 7480, 7474, 1, 0, 0, 0, 7480, 7475, 1, 0, 0, 0, 7480, 7476, 1, 0, 0, 0, 7480, 7477, 1, 0, 0, 0, 7480, 7478, 1, 0, 0, 0, 7480, 7479, 1, 0, 0, 0, 7481, 743, 1, 0, 0, 0, 7482, 7483, 7, 108, 0, 0, 7483, 745, 1, 0, 0, 0, 7484, 7485, 3, 674, 337, 0, 7485, 7486, 5, 64, 0, 0, 7486, 7489, 3, 674, 337, 0, 7487, 7488, 5, 62, 0, 0, 7488, 7490, 3, 674, 337, 0, 7489, 7487, 1, 0, 0, 0, 7489, 7490, 1, 0, 0, 0, 7490, 7506, 1, 0, 0, 0, 7491, 7492, 3, 674, 337, 0, 7492, 7493, 5, 62, 0, 0, 7493, 7496, 3, 674, 337, 0, 7494, 7495, 5, 64, 0, 0, 7495, 7497, 3, 674, 337, 0, 7496, 7494, 1, 0, 0, 0, 7496, 7497, 1, 0, 0, 0, 7497, 7506, 1, 0, 0, 0, 7498, 7499, 3, 674, 337, 0, 7499, 7500, 5, 127, 0, 0, 7500, 7501, 3, 674, 337, 0, 7501, 7502, 5, 197, 0, 0, 7502, 7503, 3, 674, 337, 0, 7503, 7506, 1, 0, 0, 0, 7504, 7506, 3, 730, 365, 0, 7505, 7484, 1, 0, 0, 0, 7505, 7491, 1, 0, 0, 0, 7505, 7498, 1, 0, 0, 0, 7505, 7504, 1, 0, 0, 0, 7506, 747, 1, 0, 0, 0, 7507, 7508, 5, 102, 0, 0, 7508, 7509, 3, 674, 337, 0, 7509, 7510, 5, 93, 0, 0, 7510, 7511, 3, 674, 337, 0, 7511, 749, 1, 0, 0, 0, 7512, 7515, 5, 11, 0, 0, 7513, 7516, 3, 824, 412, 0, 7514, 7516, 5, 9, 0, 0, 7515, 7513, 1, 0, 0, 0, 7515, 7514, 1, 0, 0, 0, 7516, 7530, 1, 0, 0, 0, 7517, 7526, 5, 4, 0, 0, 7518, 7527, 3, 674, 337, 0, 7519, 7521, 3, 674, 337, 0, 7520, 7519, 1, 0, 0, 0, 7520, 7521, 1, 0, 0, 0, 7521, 7522, 1, 0, 0, 0, 7522, 7524, 5, 8, 0, 0, 7523, 7525, 3, 674, 337, 0, 7524, 7523, 1, 0, 0, 0, 7524, 7525, 1, 0, 0, 0, 7525, 7527, 1, 0, 0, 0, 7526, 7518, 1, 0, 0, 0, 7526, 7520, 1, 0, 0, 0, 7527, 7528, 1, 0, 0, 0, 7528, 7530, 5, 5, 0, 0, 7529, 7512, 1, 0, 0, 0, 7529, 7517, 1, 0, 0, 0, 7530, 751, 1, 0, 0, 0, 7531, 7533, 3, 750, 375, 0, 7532, 7531, 1, 0, 0, 0, 7533, 7534, 1, 0, 0, 0, 7534, 7532, 1, 0, 0, 0, 7534, 7535, 1, 0, 0, 0, 7535, 753, 1, 0, 0, 0, 7536, 7538, 3, 750, 375, 0, 7537, 7536, 1, 0, 0, 0, 7538, 7541, 1, 0, 0, 0, 7539, 7537, 1, 0, 0, 0, 7539, 7540, 1, 0, 0, 0, 7540, 755, 1, 0, 0, 0, 7541, 7539, 1, 0, 0, 0, 7542, 7547, 3, 758, 379, 0, 7543, 7544, 5, 6, 0, 0, 7544, 7546, 3, 758, 379, 0, 7545, 7543, 1, 0, 0, 0, 7546, 7549, 1, 0, 0, 0, 7547, 7545, 1, 0, 0, 0, 7547, 7548, 1, 0, 0, 0, 7548, 757, 1, 0, 0, 0, 7549, 7547, 1, 0, 0, 0, 7550, 7555, 3, 734, 367, 0, 7551, 7552, 5, 36, 0, 0, 7552, 7556, 3, 824, 412, 0, 7553, 7556, 3, 826, 413, 0, 7554, 7556, 1, 0, 0, 0, 7555, 7551, 1, 0, 0, 0, 7555, 7553, 1, 0, 0, 0, 7555, 7554, 1, 0, 0, 0, 7556, 7559, 1, 0, 0, 0, 7557, 7559, 5, 9, 0, 0, 7558, 7550, 1, 0, 0, 0, 7558, 7557, 1, 0, 0, 0, 7559, 759, 1, 0, 0, 0, 7560, 7565, 3, 780, 390, 0, 7561, 7562, 5, 6, 0, 0, 7562, 7564, 3, 780, 390, 0, 7563, 7561, 1, 0, 0, 0, 7564, 7567, 1, 0, 0, 0, 7565, 7563, 1, 0, 0, 0, 7565, 7566, 1, 0, 0, 0, 7566, 761, 1, 0, 0, 0, 7567, 7565, 1, 0, 0, 0, 7568, 7573, 3, 774, 387, 0, 7569, 7570, 5, 6, 0, 0, 7570, 7572, 3, 774, 387, 0, 7571, 7569, 1, 0, 0, 0, 7572, 7575, 1, 0, 0, 0, 7573, 7571, 1, 0, 0, 0, 7573, 7574, 1, 0, 0, 0, 7574, 763, 1, 0, 0, 0, 7575, 7573, 1, 0, 0, 0, 7576, 7581, 3, 790, 395, 0, 7577, 7578, 5, 6, 0, 0, 7578, 7580, 3, 790, 395, 0, 7579, 7577, 1, 0, 0, 0, 7580, 7583, 1, 0, 0, 0, 7581, 7579, 1, 0, 0, 0, 7581, 7582, 1, 0, 0, 0, 7582, 765, 1, 0, 0, 0, 7583, 7581, 1, 0, 0, 0, 7584, 7589, 3, 788, 394, 0, 7585, 7586, 5, 6, 0, 0, 7586, 7588, 3, 788, 394, 0, 7587, 7585, 1, 0, 0, 0, 7588, 7591, 1, 0, 0, 0, 7589, 7587, 1, 0, 0, 0, 7589, 7590, 1, 0, 0, 0, 7590, 767, 1, 0, 0, 0, 7591, 7589, 1, 0, 0, 0, 7592, 7593, 3, 780, 390, 0, 7593, 769, 1, 0, 0, 0, 7594, 7595, 3, 780, 390, 0, 7595, 771, 1, 0, 0, 0, 7596, 7597, 3, 780, 390, 0, 7597, 773, 1, 0, 0, 0, 7598, 7599, 3, 780, 390, 0, 7599, 775, 1, 0, 0, 0, 7600, 7601, 3, 780, 390, 0, 7601, 777, 1, 0, 0, 0, 7602, 7603, 3, 316, 158, 0, 7603, 779, 1, 0, 0, 0, 7604, 7606, 3, 818, 409, 0, 7605, 7607, 3, 752, 376, 0, 7606, 7605, 1, 0, 0, 0, 7606, 7607, 1, 0, 0, 0, 7607, 781, 1, 0, 0, 0, 7608, 7613, 3, 770, 385, 0, 7609, 7610, 5, 6, 0, 0, 7610, 7612, 3, 770, 385, 0, 7611, 7609, 1, 0, 0, 0, 7612, 7615, 1, 0, 0, 0, 7613, 7611, 1, 0, 0, 0, 7613, 7614, 1, 0, 0, 0, 7614, 783, 1, 0, 0, 0, 7615, 7613, 1, 0, 0, 0, 7616, 7621, 3, 818, 409, 0, 7617, 7618, 5, 6, 0, 0, 7618, 7620, 3, 818, 409, 0, 7619, 7617, 1, 0, 0, 0, 7620, 7623, 1, 0, 0, 0, 7621, 7619, 1, 0, 0, 0, 7621, 7622, 1, 0, 0, 0, 7622, 785, 1, 0, 0, 0, 7623, 7621, 1, 0, 0, 0, 7624, 7625, 3, 316, 158, 0, 7625, 787, 1, 0, 0, 0, 7626, 7627, 3, 316, 158, 0, 7627, 789, 1, 0, 0, 0, 7628, 7629, 3, 316, 158, 0, 7629, 791, 1, 0, 0, 0, 7630, 7631, 3, 818, 409, 0, 7631, 793, 1, 0, 0, 0, 7632, 7633, 3, 818, 409, 0, 7633, 795, 1, 0, 0, 0, 7634, 7639, 3, 820, 410, 0, 7635, 7636, 3, 818, 409, 0, 7636, 7637, 3, 752, 376, 0, 7637, 7639, 1, 0, 0, 0, 7638, 7634, 1, 0, 0, 0, 7638, 7635, 1, 0, 0, 0, 7639, 797, 1, 0, 0, 0, 7640, 7645, 3, 820, 410, 0, 7641, 7642, 3, 818, 409, 0, 7642, 7643, 3, 752, 376, 0, 7643, 7645, 1, 0, 0, 0, 7644, 7640, 1, 0, 0, 0, 7644, 7641, 1, 0, 0, 0, 7645, 799, 1, 0, 0, 0, 7646, 7647, 3, 818, 409, 0, 7647, 7648, 3, 754, 377, 0, 7648, 7651, 1, 0, 0, 0, 7649, 7651, 4, 400, 10, 0, 7650, 7646, 1, 0, 0, 0, 7650, 7649, 1, 0, 0, 0, 7651, 801, 1, 0, 0, 0, 7652, 7653, 3, 818, 409, 0, 7653, 803, 1, 0, 0, 0, 7654, 7659, 3, 820, 410, 0, 7655, 7656, 3, 818, 409, 0, 7656, 7657, 3, 752, 376, 0, 7657, 7659, 1, 0, 0, 0, 7658, 7654, 1, 0, 0, 0, 7658, 7655, 1, 0, 0, 0, 7659, 805, 1, 0, 0, 0, 7660, 7665, 3, 820, 410, 0, 7661, 7662, 3, 818, 409, 0, 7662, 7663, 3, 752, 376, 0, 7663, 7665, 1, 0, 0, 0, 7664, 7660, 1, 0, 0, 0, 7664, 7661, 1, 0, 0, 0, 7665, 807, 1, 0, 0, 0, 7666, 7669, 3, 810, 405, 0, 7667, 7668, 5, 487, 0, 0, 7668, 7670, 3, 810, 405, 0, 7669, 7667, 1, 0, 0, 0, 7669, 7670, 1, 0, 0, 0, 7670, 809, 1, 0, 0, 0, 7671, 7683, 5, 558, 0, 0, 7672, 7683, 5, 560, 0, 0, 7673, 7677, 5, 562, 0, 0, 7674, 7676, 5, 588, 0, 0, 7675, 7674, 1, 0, 0, 0, 7676, 7679, 1, 0, 0, 0, 7677, 7675, 1, 0, 0, 0, 7677, 7678, 1, 0, 0, 0, 7678, 7680, 1, 0, 0, 0, 7679, 7677, 1, 0, 0, 0, 7680, 7683, 5, 589, 0, 0, 7681, 7683, 5, 584, 0, 0, 7682, 7671, 1, 0, 0, 0, 7682, 7672, 1, 0, 0, 0, 7682, 7673, 1, 0, 0, 0, 7682, 7681, 1, 0, 0, 0, 7683, 811, 1, 0, 0, 0, 7684, 7686, 7, 29, 0, 0, 7685, 7684, 1, 0, 0, 0, 7685, 7686, 1, 0, 0, 0, 7686, 7687, 1, 0, 0, 0, 7687, 7688, 5, 571, 0, 0, 7688, 813, 1, 0, 0, 0, 7689, 7695, 3, 822, 411, 0, 7690, 7695, 5, 52, 0, 0, 7691, 7695, 5, 49, 0, 0, 7692, 7695, 5, 89, 0, 0, 7693, 7695, 5, 524, 0, 0, 7694, 7689, 1, 0, 0, 0, 7694, 7690, 1, 0, 0, 0, 7694, 7691, 1, 0, 0, 0, 7694, 7692, 1, 0, 0, 0, 7694, 7693, 1, 0, 0, 0, 7695, 815, 1, 0, 0, 0, 7696, 7701, 3, 814, 407, 0, 7697, 7698, 5, 6, 0, 0, 7698, 7700, 3, 814, 407, 0, 7699, 7697, 1, 0, 0, 0, 7700, 7703, 1, 0, 0, 0, 7701, 7699, 1, 0, 0, 0, 7701, 7702, 1, 0, 0, 0, 7702, 817, 1, 0, 0, 0, 7703, 7701, 1, 0, 0, 0, 7704, 7709, 3, 826, 413, 0, 7705, 7709, 3, 828, 414, 0, 7706, 7709, 3, 830, 415, 0, 7707, 7709, 3, 930, 465, 0, 7708, 7704, 1, 0, 0, 0, 7708, 7705, 1, 0, 0, 0, 7708, 7706, 1, 0, 0, 0, 7708, 7707, 1, 0, 0, 0, 7709, 819, 1, 0, 0, 0, 7710, 7715, 3, 826, 413, 0, 7711, 7715, 3, 828, 414, 0, 7712, 7715, 3, 930, 465, 0, 7713, 7715, 3, 832, 416, 0, 7714, 7710, 1, 0, 0, 0, 7714, 7711, 1, 0, 0, 0, 7714, 7712, 1, 0, 0, 0, 7714, 7713, 1, 0, 0, 0, 7715, 821, 1, 0, 0, 0, 7716, 7721, 3, 826, 413, 0, 7717, 7721, 3, 828, 414, 0, 7718, 7721, 3, 830, 415, 0, 7719, 7721, 3, 832, 416, 0, 7720, 7716, 1, 0, 0, 0, 7720, 7717, 1, 0, 0, 0, 7720, 7718, 1, 0, 0, 0, 7720, 7719, 1, 0, 0, 0, 7721, 823, 1, 0, 0, 0, 7722, 7726, 3, 822, 411, 0, 7723, 7726, 3, 930, 465, 0, 7724, 7726, 3, 834, 417, 0, 7725, 7722, 1, 0, 0, 0, 7725, 7723, 1, 0, 0, 0, 7725, 7724, 1, 0, 0, 0, 7726, 825, 1, 0, 0, 0, 7727, 7730, 5, 549, 0, 0, 7728, 7729, 5, 487, 0, 0, 7729, 7731, 3, 810, 405, 0, 7730, 7728, 1, 0, 0, 0, 7730, 7731, 1, 0, 0, 0, 7731, 7739, 1, 0, 0, 0, 7732, 7739, 3, 808, 404, 0, 7733, 7739, 5, 550, 0, 0, 7734, 7739, 5, 554, 0, 0, 7735, 7739, 5, 574, 0, 0, 7736, 7739, 5, 575, 0, 0, 7737, 7739, 3, 930, 465, 0, 7738, 7727, 1, 0, 0, 0, 7738, 7732, 1, 0, 0, 0, 7738, 7733, 1, 0, 0, 0, 7738, 7734, 1, 0, 0, 0, 7738, 7735, 1, 0, 0, 0, 7738, 7736, 1, 0, 0, 0, 7738, 7737, 1, 0, 0, 0, 7739, 827, 1, 0, 0, 0, 7740, 7741, 7, 109, 0, 0, 7741, 829, 1, 0, 0, 0, 7742, 7794, 5, 387, 0, 0, 7743, 7794, 5, 388, 0, 0, 7744, 7794, 3, 662, 331, 0, 7745, 7794, 5, 390, 0, 0, 7746, 7794, 5, 391, 0, 0, 7747, 7794, 3, 664, 332, 0, 7748, 7794, 5, 393, 0, 0, 7749, 7794, 5, 394, 0, 0, 7750, 7794, 5, 395, 0, 0, 7751, 7794, 5, 396, 0, 0, 7752, 7794, 5, 397, 0, 0, 7753, 7794, 5, 398, 0, 0, 7754, 7794, 5, 399, 0, 0, 7755, 7794, 5, 470, 0, 0, 7756, 7794, 5, 400, 0, 0, 7757, 7794, 5, 401, 0, 0, 7758, 7794, 5, 402, 0, 0, 7759, 7794, 5, 403, 0, 0, 7760, 7794, 5, 404, 0, 0, 7761, 7794, 5, 405, 0, 0, 7762, 7794, 5, 406, 0, 0, 7763, 7794, 5, 407, 0, 0, 7764, 7794, 5, 489, 0, 0, 7765, 7794, 5, 408, 0, 0, 7766, 7794, 3, 658, 329, 0, 7767, 7794, 5, 453, 0, 0, 7768, 7794, 5, 410, 0, 0, 7769, 7794, 5, 411, 0, 0, 7770, 7794, 5, 412, 0, 0, 7771, 7794, 5, 413, 0, 0, 7772, 7794, 5, 414, 0, 0, 7773, 7794, 5, 415, 0, 0, 7774, 7794, 5, 416, 0, 0, 7775, 7794, 5, 417, 0, 0, 7776, 7794, 5, 418, 0, 0, 7777, 7794, 5, 419, 0, 0, 7778, 7794, 5, 420, 0, 0, 7779, 7794, 5, 421, 0, 0, 7780, 7794, 5, 422, 0, 0, 7781, 7794, 5, 423, 0, 0, 7782, 7794, 5, 424, 0, 0, 7783, 7794, 5, 425, 0, 0, 7784, 7794, 5, 426, 0, 0, 7785, 7794, 5, 427, 0, 0, 7786, 7794, 5, 428, 0, 0, 7787, 7794, 5, 476, 0, 0, 7788, 7794, 5, 429, 0, 0, 7789, 7794, 5, 430, 0, 0, 7790, 7794, 5, 431, 0, 0, 7791, 7794, 5, 432, 0, 0, 7792, 7794, 5, 474, 0, 0, 7793, 7742, 1, 0, 0, 0, 7793, 7743, 1, 0, 0, 0, 7793, 7744, 1, 0, 0, 0, 7793, 7745, 1, 0, 0, 0, 7793, 7746, 1, 0, 0, 0, 7793, 7747, 1, 0, 0, 0, 7793, 7748, 1, 0, 0, 0, 7793, 7749, 1, 0, 0, 0, 7793, 7750, 1, 0, 0, 0, 7793, 7751, 1, 0, 0, 0, 7793, 7752, 1, 0, 0, 0, 7793, 7753, 1, 0, 0, 0, 7793, 7754, 1, 0, 0, 0, 7793, 7755, 1, 0, 0, 0, 7793, 7756, 1, 0, 0, 0, 7793, 7757, 1, 0, 0, 0, 7793, 7758, 1, 0, 0, 0, 7793, 7759, 1, 0, 0, 0, 7793, 7760, 1, 0, 0, 0, 7793, 7761, 1, 0, 0, 0, 7793, 7762, 1, 0, 0, 0, 7793, 7763, 1, 0, 0, 0, 7793, 7764, 1, 0, 0, 0, 7793, 7765, 1, 0, 0, 0, 7793, 7766, 1, 0, 0, 0, 7793, 7767, 1, 0, 0, 0, 7793, 7768, 1, 0, 0, 0, 7793, 7769, 1, 0, 0, 0, 7793, 7770, 1, 0, 0, 0, 7793, 7771, 1, 0, 0, 0, 7793, 7772, 1, 0, 0, 0, 7793, 7773, 1, 0, 0, 0, 7793, 7774, 1, 0, 0, 0, 7793, 7775, 1, 0, 0, 0, 7793, 7776, 1, 0, 0, 0, 7793, 7777, 1, 0, 0, 0, 7793, 7778, 1, 0, 0, 0, 7793, 7779, 1, 0, 0, 0, 7793, 7780, 1, 0, 0, 0, 7793, 7781, 1, 0, 0, 0, 7793, 7782, 1, 0, 0, 0, 7793, 7783, 1, 0, 0, 0, 7793, 7784, 1, 0, 0, 0, 7793, 7785, 1, 0, 0, 0, 7793, 7786, 1, 0, 0, 0, 7793, 7787, 1, 0, 0, 0, 7793, 7788, 1, 0, 0, 0, 7793, 7789, 1, 0, 0, 0, 7793, 7790, 1, 0, 0, 0, 7793, 7791, 1, 0, 0, 0, 7793, 7792, 1, 0, 0, 0, 7794, 831, 1, 0, 0, 0, 7795, 7796, 7, 110, 0, 0, 7796, 833, 1, 0, 0, 0, 7797, 7798, 7, 111, 0, 0, 7798, 835, 1, 0, 0, 0, 7799, 7801, 3, 838, 419, 0, 7800, 7799, 1, 0, 0, 0, 7800, 7801, 1, 0, 0, 0, 7801, 7812, 1, 0, 0, 0, 7802, 7810, 5, 178, 0, 0, 7803, 7807, 3, 840, 420, 0, 7804, 7807, 5, 178, 0, 0, 7805, 7807, 3, 838, 419, 0, 7806, 7803, 1, 0, 0, 0, 7806, 7804, 1, 0, 0, 0, 7806, 7805, 1, 0, 0, 0, 7807, 7808, 1, 0, 0, 0, 7808, 7806, 1, 0, 0, 0, 7808, 7809, 1, 0, 0, 0, 7809, 7811, 1, 0, 0, 0, 7810, 7806, 1, 0, 0, 0, 7810, 7811, 1, 0, 0, 0, 7811, 7813, 1, 0, 0, 0, 7812, 7802, 1, 0, 0, 0, 7812, 7813, 1, 0, 0, 0, 7813, 7814, 1, 0, 0, 0, 7814, 7818, 5, 146, 0, 0, 7815, 7817, 3, 846, 423, 0, 7816, 7815, 1, 0, 0, 0, 7817, 7820, 1, 0, 0, 0, 7818, 7816, 1, 0, 0, 0, 7818, 7819, 1, 0, 0, 0, 7819, 7822, 1, 0, 0, 0, 7820, 7818, 1, 0, 0, 0, 7821, 7823, 3, 924, 462, 0, 7822, 7821, 1, 0, 0, 0, 7822, 7823, 1, 0, 0, 0, 7823, 7824, 1, 0, 0, 0, 7824, 7826, 5, 454, 0, 0, 7825, 7827, 3, 928, 464, 0, 7826, 7825, 1, 0, 0, 0, 7826, 7827, 1, 0, 0, 0, 7827, 837, 1, 0, 0, 0, 7828, 7829, 5, 18, 0, 0, 7829, 7830, 3, 928, 464, 0, 7830, 7831, 5, 19, 0, 0, 7831, 839, 1, 0, 0, 0, 7832, 7879, 3, 928, 464, 0, 7833, 7834, 5, 496, 0, 0, 7834, 7837, 5, 62, 0, 0, 7835, 7838, 5, 28, 0, 0, 7836, 7838, 3, 818, 409, 0, 7837, 7835, 1, 0, 0, 0, 7837, 7836, 1, 0, 0, 0, 7838, 7880, 1, 0, 0, 0, 7839, 7841, 5, 497, 0, 0, 7840, 7839, 1, 0, 0, 0, 7840, 7841, 1, 0, 0, 0, 7841, 7842, 1, 0, 0, 0, 7842, 7844, 3, 652, 326, 0, 7843, 7845, 3, 98, 49, 0, 7844, 7843, 1, 0, 0, 0, 7844, 7845, 1, 0, 0, 0, 7845, 7848, 1, 0, 0, 0, 7846, 7847, 5, 77, 0, 0, 7847, 7849, 5, 78, 0, 0, 7848, 7846, 1, 0, 0, 0, 7848, 7849, 1, 0, 0, 0, 7849, 7855, 1, 0, 0, 0, 7850, 7853, 3, 844, 422, 0, 7851, 7853, 5, 53, 0, 0, 7852, 7850, 1, 0, 0, 0, 7852, 7851, 1, 0, 0, 0, 7853, 7854, 1, 0, 0, 0, 7854, 7856, 3, 932, 466, 0, 7855, 7852, 1, 0, 0, 0, 7855, 7856, 1, 0, 0, 0, 7856, 7880, 1, 0, 0, 0, 7857, 7859, 5, 269, 0, 0, 7858, 7857, 1, 0, 0, 0, 7858, 7859, 1, 0, 0, 0, 7859, 7860, 1, 0, 0, 0, 7860, 7862, 5, 324, 0, 0, 7861, 7858, 1, 0, 0, 0, 7861, 7862, 1, 0, 0, 0, 7862, 7863, 1, 0, 0, 0, 7863, 7875, 5, 172, 0, 0, 7864, 7865, 5, 2, 0, 0, 7865, 7870, 3, 842, 421, 0, 7866, 7867, 5, 6, 0, 0, 7867, 7869, 3, 842, 421, 0, 7868, 7866, 1, 0, 0, 0, 7869, 7872, 1, 0, 0, 0, 7870, 7868, 1, 0, 0, 0, 7870, 7871, 1, 0, 0, 0, 7871, 7873, 1, 0, 0, 0, 7872, 7870, 1, 0, 0, 0, 7873, 7874, 5, 3, 0, 0, 7874, 7876, 1, 0, 0, 0, 7875, 7864, 1, 0, 0, 0, 7875, 7876, 1, 0, 0, 0, 7876, 7877, 1, 0, 0, 0, 7877, 7878, 7, 112, 0, 0, 7878, 7880, 3, 560, 280, 0, 7879, 7833, 1, 0, 0, 0, 7879, 7840, 1, 0, 0, 0, 7879, 7861, 1, 0, 0, 0, 7880, 7881, 1, 0, 0, 0, 7881, 7882, 5, 7, 0, 0, 7882, 841, 1, 0, 0, 0, 7883, 7884, 3, 928, 464, 0, 7884, 7885, 3, 652, 326, 0, 7885, 843, 1, 0, 0, 0, 7886, 7887, 7, 113, 0, 0, 7887, 845, 1, 0, 0, 0, 7888, 7889, 3, 836, 418, 0, 7889, 7890, 5, 7, 0, 0, 7890, 7913, 1, 0, 0, 0, 7891, 7913, 3, 874, 437, 0, 7892, 7913, 3, 876, 438, 0, 7893, 7913, 3, 852, 426, 0, 7894, 7913, 3, 860, 430, 0, 7895, 7913, 3, 864, 432, 0, 7896, 7913, 3, 866, 433, 0, 7897, 7913, 3, 870, 435, 0, 7898, 7913, 3, 872, 436, 0, 7899, 7913, 3, 880, 440, 0, 7900, 7913, 3, 884, 442, 0, 7901, 7913, 3, 886, 443, 0, 7902, 7913, 3, 848, 424, 0, 7903, 7913, 3, 850, 425, 0, 7904, 7913, 3, 854, 427, 0, 7905, 7913, 3, 890, 445, 0, 7906, 7913, 3, 894, 447, 0, 7907, 7913, 3, 898, 449, 0, 7908, 7913, 3, 914, 457, 0, 7909, 7913, 3, 916, 458, 0, 7910, 7913, 3, 918, 459, 0, 7911, 7913, 3, 920, 460, 0, 7912, 7888, 1, 0, 0, 0, 7912, 7891, 1, 0, 0, 0, 7912, 7892, 1, 0, 0, 0, 7912, 7893, 1, 0, 0, 0, 7912, 7894, 1, 0, 0, 0, 7912, 7895, 1, 0, 0, 0, 7912, 7896, 1, 0, 0, 0, 7912, 7897, 1, 0, 0, 0, 7912, 7898, 1, 0, 0, 0, 7912, 7899, 1, 0, 0, 0, 7912, 7900, 1, 0, 0, 0, 7912, 7901, 1, 0, 0, 0, 7912, 7902, 1, 0, 0, 0, 7912, 7903, 1, 0, 0, 0, 7912, 7904, 1, 0, 0, 0, 7912, 7905, 1, 0, 0, 0, 7912, 7906, 1, 0, 0, 0, 7912, 7907, 1, 0, 0, 0, 7912, 7908, 1, 0, 0, 0, 7912, 7909, 1, 0, 0, 0, 7912, 7910, 1, 0, 0, 0, 7912, 7911, 1, 0, 0, 0, 7913, 847, 1, 0, 0, 0, 7914, 7915, 5, 498, 0, 0, 7915, 7916, 3, 932, 466, 0, 7916, 7917, 5, 7, 0, 0, 7917, 849, 1, 0, 0, 0, 7918, 7919, 5, 433, 0, 0, 7919, 7926, 3, 928, 464, 0, 7920, 7922, 5, 2, 0, 0, 7921, 7923, 3, 730, 365, 0, 7922, 7921, 1, 0, 0, 0, 7922, 7923, 1, 0, 0, 0, 7923, 7924, 1, 0, 0, 0, 7924, 7925, 5, 3, 0, 0, 7925, 7927, 5, 7, 0, 0, 7926, 7920, 1, 0, 0, 0, 7926, 7927, 1, 0, 0, 0, 7927, 7938, 1, 0, 0, 0, 7928, 7929, 5, 57, 0, 0, 7929, 7930, 3, 928, 464, 0, 7930, 7932, 5, 2, 0, 0, 7931, 7933, 3, 730, 365, 0, 7932, 7931, 1, 0, 0, 0, 7932, 7933, 1, 0, 0, 0, 7933, 7934, 1, 0, 0, 0, 7934, 7935, 5, 3, 0, 0, 7935, 7936, 5, 7, 0, 0, 7936, 7938, 1, 0, 0, 0, 7937, 7918, 1, 0, 0, 0, 7937, 7928, 1, 0, 0, 0, 7938, 851, 1, 0, 0, 0, 7939, 7940, 3, 858, 429, 0, 7940, 7941, 3, 844, 422, 0, 7941, 7942, 3, 932, 466, 0, 7942, 7943, 5, 7, 0, 0, 7943, 853, 1, 0, 0, 0, 7944, 7946, 5, 499, 0, 0, 7945, 7947, 7, 114, 0, 0, 7946, 7945, 1, 0, 0, 0, 7946, 7947, 1, 0, 0, 0, 7947, 7948, 1, 0, 0, 0, 7948, 7949, 5, 500, 0, 0, 7949, 7954, 3, 856, 428, 0, 7950, 7951, 5, 6, 0, 0, 7951, 7953, 3, 856, 428, 0, 7952, 7950, 1, 0, 0, 0, 7953, 7956, 1, 0, 0, 0, 7954, 7952, 1, 0, 0, 0, 7954, 7955, 1, 0, 0, 0, 7955, 7957, 1, 0, 0, 0, 7956, 7954, 1, 0, 0, 0, 7957, 7958, 5, 7, 0, 0, 7958, 855, 1, 0, 0, 0, 7959, 7960, 3, 858, 429, 0, 7960, 7961, 3, 844, 422, 0, 7961, 7962, 3, 818, 409, 0, 7962, 857, 1, 0, 0, 0, 7963, 7966, 3, 316, 158, 0, 7964, 7966, 5, 28, 0, 0, 7965, 7963, 1, 0, 0, 0, 7965, 7964, 1, 0, 0, 0, 7966, 7973, 1, 0, 0, 0, 7967, 7968, 5, 4, 0, 0, 7968, 7969, 3, 674, 337, 0, 7969, 7970, 5, 5, 0, 0, 7970, 7972, 1, 0, 0, 0, 7971, 7967, 1, 0, 0, 0, 7972, 7975, 1, 0, 0, 0, 7973, 7971, 1, 0, 0, 0, 7973, 7974, 1, 0, 0, 0, 7974, 859, 1, 0, 0, 0, 7975, 7973, 1, 0, 0, 0, 7976, 7977, 5, 220, 0, 0, 7977, 7978, 3, 932, 466, 0, 7978, 7982, 5, 93, 0, 0, 7979, 7981, 3, 846, 423, 0, 7980, 7979, 1, 0, 0, 0, 7981, 7984, 1, 0, 0, 0, 7982, 7980, 1, 0, 0, 0, 7982, 7983, 1, 0, 0, 0, 7983, 7996, 1, 0, 0, 0, 7984, 7982, 1, 0, 0, 0, 7985, 7986, 5, 502, 0, 0, 7986, 7987, 3, 674, 337, 0, 7987, 7991, 5, 93, 0, 0, 7988, 7990, 3, 846, 423, 0, 7989, 7988, 1, 0, 0, 0, 7990, 7993, 1, 0, 0, 0, 7991, 7989, 1, 0, 0, 0, 7991, 7992, 1, 0, 0, 0, 7992, 7995, 1, 0, 0, 0, 7993, 7991, 1, 0, 0, 0, 7994, 7985, 1, 0, 0, 0, 7995, 7998, 1, 0, 0, 0, 7996, 7994, 1, 0, 0, 0, 7996, 7997, 1, 0, 0, 0, 7997, 8000, 1, 0, 0, 0, 7998, 7996, 1, 0, 0, 0, 7999, 8001, 3, 862, 431, 0, 8000, 7999, 1, 0, 0, 0, 8000, 8001, 1, 0, 0, 0, 8001, 8002, 1, 0, 0, 0, 8002, 8003, 5, 454, 0, 0, 8003, 8004, 5, 220, 0, 0, 8004, 8005, 5, 7, 0, 0, 8005, 861, 1, 0, 0, 0, 8006, 8010, 5, 58, 0, 0, 8007, 8009, 3, 846, 423, 0, 8008, 8007, 1, 0, 0, 0, 8009, 8012, 1, 0, 0, 0, 8010, 8008, 1, 0, 0, 0, 8010, 8011, 1, 0, 0, 0, 8011, 863, 1, 0, 0, 0, 8012, 8010, 1, 0, 0, 0, 8013, 8015, 5, 40, 0, 0, 8014, 8016, 3, 932, 466, 0, 8015, 8014, 1, 0, 0, 0, 8015, 8016, 1, 0, 0, 0, 8016, 8026, 1, 0, 0, 0, 8017, 8018, 5, 102, 0, 0, 8018, 8019, 3, 730, 365, 0, 8019, 8023, 5, 93, 0, 0, 8020, 8022, 3, 846, 423, 0, 8021, 8020, 1, 0, 0, 0, 8022, 8025, 1, 0, 0, 0, 8023, 8021, 1, 0, 0, 0, 8023, 8024, 1, 0, 0, 0, 8024, 8027, 1, 0, 0, 0, 8025, 8023, 1, 0, 0, 0, 8026, 8017, 1, 0, 0, 0, 8027, 8028, 1, 0, 0, 0, 8028, 8026, 1, 0, 0, 0, 8028, 8029, 1, 0, 0, 0, 8029, 8031, 1, 0, 0, 0, 8030, 8032, 3, 862, 431, 0, 8031, 8030, 1, 0, 0, 0, 8031, 8032, 1, 0, 0, 0, 8032, 8033, 1, 0, 0, 0, 8033, 8034, 5, 454, 0, 0, 8034, 8035, 5, 40, 0, 0, 8035, 8036, 5, 7, 0, 0, 8036, 865, 1, 0, 0, 0, 8037, 8039, 3, 838, 419, 0, 8038, 8037, 1, 0, 0, 0, 8038, 8039, 1, 0, 0, 0, 8039, 8044, 1, 0, 0, 0, 8040, 8041, 5, 503, 0, 0, 8041, 8045, 3, 674, 337, 0, 8042, 8043, 5, 62, 0, 0, 8043, 8045, 3, 868, 434, 0, 8044, 8040, 1, 0, 0, 0, 8044, 8042, 1, 0, 0, 0, 8044, 8045, 1, 0, 0, 0, 8045, 8046, 1, 0, 0, 0, 8046, 8047, 3, 882, 441, 0, 8047, 867, 1, 0, 0, 0, 8048, 8049, 3, 314, 157, 0, 8049, 8072, 5, 68, 0, 0, 8050, 8052, 3, 818, 409, 0, 8051, 8053, 3, 534, 267, 0, 8052, 8051, 1, 0, 0, 0, 8052, 8053, 1, 0, 0, 0, 8053, 8073, 1, 0, 0, 0, 8054, 8073, 3, 560, 280, 0, 8055, 8073, 3, 520, 260, 0, 8056, 8057, 5, 202, 0, 0, 8057, 8060, 3, 674, 337, 0, 8058, 8059, 5, 100, 0, 0, 8059, 8061, 3, 730, 365, 0, 8060, 8058, 1, 0, 0, 0, 8060, 8061, 1, 0, 0, 0, 8061, 8073, 1, 0, 0, 0, 8062, 8064, 5, 504, 0, 0, 8063, 8062, 1, 0, 0, 0, 8063, 8064, 1, 0, 0, 0, 8064, 8065, 1, 0, 0, 0, 8065, 8066, 3, 674, 337, 0, 8066, 8067, 5, 24, 0, 0, 8067, 8070, 3, 674, 337, 0, 8068, 8069, 5, 147, 0, 0, 8069, 8071, 3, 674, 337, 0, 8070, 8068, 1, 0, 0, 0, 8070, 8071, 1, 0, 0, 0, 8071, 8073, 1, 0, 0, 0, 8072, 8050, 1, 0, 0, 0, 8072, 8054, 1, 0, 0, 0, 8072, 8055, 1, 0, 0, 0, 8072, 8056, 1, 0, 0, 0, 8072, 8063, 1, 0, 0, 0, 8073, 869, 1, 0, 0, 0, 8074, 8076, 3, 838, 419, 0, 8075, 8074, 1, 0, 0, 0, 8075, 8076, 1, 0, 0, 0, 8076, 8077, 1, 0, 0, 0, 8077, 8078, 5, 505, 0, 0, 8078, 8081, 3, 314, 157, 0, 8079, 8080, 5, 506, 0, 0, 8080, 8082, 5, 571, 0, 0, 8081, 8079, 1, 0, 0, 0, 8081, 8082, 1, 0, 0, 0, 8082, 8083, 1, 0, 0, 0, 8083, 8084, 5, 68, 0, 0, 8084, 8085, 5, 35, 0, 0, 8085, 8086, 3, 674, 337, 0, 8086, 8087, 3, 882, 441, 0, 8087, 871, 1, 0, 0, 0, 8088, 8090, 7, 115, 0, 0, 8089, 8091, 3, 928, 464, 0, 8090, 8089, 1, 0, 0, 0, 8090, 8091, 1, 0, 0, 0, 8091, 8094, 1, 0, 0, 0, 8092, 8093, 5, 102, 0, 0, 8093, 8095, 3, 932, 466, 0, 8094, 8092, 1, 0, 0, 0, 8094, 8095, 1, 0, 0, 0, 8095, 8096, 1, 0, 0, 0, 8096, 8097, 5, 7, 0, 0, 8097, 873, 1, 0, 0, 0, 8098, 8113, 5, 508, 0, 0, 8099, 8100, 5, 268, 0, 0, 8100, 8114, 3, 932, 466, 0, 8101, 8108, 5, 509, 0, 0, 8102, 8103, 5, 202, 0, 0, 8103, 8104, 3, 674, 337, 0, 8104, 8105, 5, 100, 0, 0, 8105, 8106, 3, 730, 365, 0, 8106, 8109, 1, 0, 0, 0, 8107, 8109, 3, 560, 280, 0, 8108, 8102, 1, 0, 0, 0, 8108, 8107, 1, 0, 0, 0, 8109, 8114, 1, 0, 0, 0, 8110, 8112, 3, 932, 466, 0, 8111, 8110, 1, 0, 0, 0, 8111, 8112, 1, 0, 0, 0, 8112, 8114, 1, 0, 0, 0, 8113, 8099, 1, 0, 0, 0, 8113, 8101, 1, 0, 0, 0, 8113, 8111, 1, 0, 0, 0, 8114, 8115, 1, 0, 0, 0, 8115, 8116, 5, 7, 0, 0, 8116, 875, 1, 0, 0, 0, 8117, 8147, 5, 510, 0, 0, 8118, 8120, 7, 116, 0, 0, 8119, 8118, 1, 0, 0, 0, 8119, 8120, 1, 0, 0, 0, 8120, 8133, 1, 0, 0, 0, 8121, 8134, 3, 826, 413, 0, 8122, 8123, 5, 511, 0, 0, 8123, 8134, 3, 808, 404, 0, 8124, 8131, 3, 808, 404, 0, 8125, 8126, 5, 6, 0, 0, 8126, 8128, 3, 674, 337, 0, 8127, 8125, 1, 0, 0, 0, 8128, 8129, 1, 0, 0, 0, 8129, 8127, 1, 0, 0, 0, 8129, 8130, 1, 0, 0, 0, 8130, 8132, 1, 0, 0, 0, 8131, 8127, 1, 0, 0, 0, 8131, 8132, 1, 0, 0, 0, 8132, 8134, 1, 0, 0, 0, 8133, 8121, 1, 0, 0, 0, 8133, 8122, 1, 0, 0, 0, 8133, 8124, 1, 0, 0, 0, 8133, 8134, 1, 0, 0, 0, 8134, 8144, 1, 0, 0, 0, 8135, 8136, 5, 100, 0, 0, 8136, 8141, 3, 878, 439, 0, 8137, 8138, 5, 6, 0, 0, 8138, 8140, 3, 878, 439, 0, 8139, 8137, 1, 0, 0, 0, 8140, 8143, 1, 0, 0, 0, 8141, 8139, 1, 0, 0, 0, 8141, 8142, 1, 0, 0, 0, 8142, 8145, 1, 0, 0, 0, 8143, 8141, 1, 0, 0, 0, 8144, 8135, 1, 0, 0, 0, 8144, 8145, 1, 0, 0, 0, 8145, 8146, 1, 0, 0, 0, 8146, 8148, 5, 7, 0, 0, 8147, 8119, 1, 0, 0, 0, 8147, 8148, 1, 0, 0, 0, 8148, 877, 1, 0, 0, 0, 8149, 8150, 3, 826, 413, 0, 8150, 8151, 5, 10, 0, 0, 8151, 8152, 3, 674, 337, 0, 8152, 879, 1, 0, 0, 0, 8153, 8154, 5, 518, 0, 0, 8154, 8157, 3, 932, 466, 0, 8155, 8156, 5, 6, 0, 0, 8156, 8158, 3, 932, 466, 0, 8157, 8155, 1, 0, 0, 0, 8157, 8158, 1, 0, 0, 0, 8158, 8159, 1, 0, 0, 0, 8159, 8160, 5, 7, 0, 0, 8160, 881, 1, 0, 0, 0, 8161, 8165, 5, 519, 0, 0, 8162, 8164, 3, 846, 423, 0, 8163, 8162, 1, 0, 0, 0, 8164, 8167, 1, 0, 0, 0, 8165, 8163, 1, 0, 0, 0, 8165, 8166, 1, 0, 0, 0, 8166, 8168, 1, 0, 0, 0, 8167, 8165, 1, 0, 0, 0, 8168, 8169, 5, 454, 0, 0, 8169, 8171, 5, 519, 0, 0, 8170, 8172, 3, 928, 464, 0, 8171, 8170, 1, 0, 0, 0, 8171, 8172, 1, 0, 0, 0, 8172, 8173, 1, 0, 0, 0, 8173, 8174, 5, 7, 0, 0, 8174, 883, 1, 0, 0, 0, 8175, 8177, 3, 4, 2, 0, 8176, 8178, 3, 888, 444, 0, 8177, 8176, 1, 0, 0, 0, 8177, 8178, 1, 0, 0, 0, 8178, 8179, 1, 0, 0, 0, 8179, 8180, 5, 7, 0, 0, 8180, 885, 1, 0, 0, 0, 8181, 8182, 5, 202, 0, 0, 8182, 8198, 3, 674, 337, 0, 8183, 8185, 3, 888, 444, 0, 8184, 8183, 1, 0, 0, 0, 8184, 8185, 1, 0, 0, 0, 8185, 8188, 1, 0, 0, 0, 8186, 8187, 5, 100, 0, 0, 8187, 8189, 3, 730, 365, 0, 8188, 8186, 1, 0, 0, 0, 8188, 8189, 1, 0, 0, 0, 8189, 8199, 1, 0, 0, 0, 8190, 8191, 5, 100, 0, 0, 8191, 8193, 3, 730, 365, 0, 8192, 8190, 1, 0, 0, 0, 8192, 8193, 1, 0, 0, 0, 8193, 8195, 1, 0, 0, 0, 8194, 8196, 3, 888, 444, 0, 8195, 8194, 1, 0, 0, 0, 8195, 8196, 1, 0, 0, 0, 8196, 8199, 1, 0, 0, 0, 8197, 8199, 1, 0, 0, 0, 8198, 8184, 1, 0, 0, 0, 8198, 8192, 1, 0, 0, 0, 8198, 8197, 1, 0, 0, 0, 8199, 8200, 1, 0, 0, 0, 8200, 8201, 5, 7, 0, 0, 8201, 887, 1, 0, 0, 0, 8202, 8204, 5, 71, 0, 0, 8203, 8205, 5, 346, 0, 0, 8204, 8203, 1, 0, 0, 0, 8204, 8205, 1, 0, 0, 0, 8205, 8206, 1, 0, 0, 0, 8206, 8207, 3, 730, 365, 0, 8207, 889, 1, 0, 0, 0, 8208, 8240, 5, 520, 0, 0, 8209, 8214, 3, 922, 461, 0, 8210, 8212, 5, 269, 0, 0, 8211, 8210, 1, 0, 0, 0, 8211, 8212, 1, 0, 0, 0, 8212, 8213, 1, 0, 0, 0, 8213, 8215, 5, 324, 0, 0, 8214, 8211, 1, 0, 0, 0, 8214, 8215, 1, 0, 0, 0, 8215, 8216, 1, 0, 0, 0, 8216, 8224, 5, 62, 0, 0, 8217, 8225, 3, 560, 280, 0, 8218, 8219, 5, 202, 0, 0, 8219, 8222, 3, 932, 466, 0, 8220, 8221, 5, 100, 0, 0, 8221, 8223, 3, 730, 365, 0, 8222, 8220, 1, 0, 0, 0, 8222, 8223, 1, 0, 0, 0, 8223, 8225, 1, 0, 0, 0, 8224, 8217, 1, 0, 0, 0, 8224, 8218, 1, 0, 0, 0, 8225, 8241, 1, 0, 0, 0, 8226, 8238, 3, 818, 409, 0, 8227, 8228, 5, 2, 0, 0, 8228, 8233, 3, 892, 446, 0, 8229, 8230, 5, 6, 0, 0, 8230, 8232, 3, 892, 446, 0, 8231, 8229, 1, 0, 0, 0, 8232, 8235, 1, 0, 0, 0, 8233, 8231, 1, 0, 0, 0, 8233, 8234, 1, 0, 0, 0, 8234, 8236, 1, 0, 0, 0, 8235, 8233, 1, 0, 0, 0, 8236, 8237, 5, 3, 0, 0, 8237, 8239, 1, 0, 0, 0, 8238, 8227, 1, 0, 0, 0, 8238, 8239, 1, 0, 0, 0, 8239, 8241, 1, 0, 0, 0, 8240, 8209, 1, 0, 0, 0, 8240, 8226, 1, 0, 0, 0, 8241, 8242, 1, 0, 0, 0, 8242, 8243, 5, 7, 0, 0, 8243, 891, 1, 0, 0, 0, 8244, 8245, 3, 818, 409, 0, 8245, 8246, 5, 20, 0, 0, 8246, 8248, 1, 0, 0, 0, 8247, 8244, 1, 0, 0, 0, 8247, 8248, 1, 0, 0, 0, 8248, 8249, 1, 0, 0, 0, 8249, 8250, 3, 674, 337, 0, 8250, 893, 1, 0, 0, 0, 8251, 8253, 5, 61, 0, 0, 8252, 8254, 3, 896, 448, 0, 8253, 8252, 1, 0, 0, 0, 8253, 8254, 1, 0, 0, 0, 8254, 8256, 1, 0, 0, 0, 8255, 8257, 3, 332, 166, 0, 8256, 8255, 1, 0, 0, 0, 8256, 8257, 1, 0, 0, 0, 8257, 8258, 1, 0, 0, 0, 8258, 8259, 3, 922, 461, 0, 8259, 8260, 5, 71, 0, 0, 8260, 8261, 3, 730, 365, 0, 8261, 8262, 5, 7, 0, 0, 8262, 895, 1, 0, 0, 0, 8263, 8278, 5, 268, 0, 0, 8264, 8278, 5, 293, 0, 0, 8265, 8278, 5, 207, 0, 0, 8266, 8278, 5, 249, 0, 0, 8267, 8269, 7, 50, 0, 0, 8268, 8267, 1, 0, 0, 0, 8268, 8269, 1, 0, 0, 0, 8269, 8270, 1, 0, 0, 0, 8270, 8278, 3, 674, 337, 0, 8271, 8278, 5, 30, 0, 0, 8272, 8275, 7, 117, 0, 0, 8273, 8276, 3, 674, 337, 0, 8274, 8276, 5, 30, 0, 0, 8275, 8273, 1, 0, 0, 0, 8275, 8274, 1, 0, 0, 0, 8275, 8276, 1, 0, 0, 0, 8276, 8278, 1, 0, 0, 0, 8277, 8263, 1, 0, 0, 0, 8277, 8264, 1, 0, 0, 0, 8277, 8265, 1, 0, 0, 0, 8277, 8266, 1, 0, 0, 0, 8277, 8268, 1, 0, 0, 0, 8277, 8271, 1, 0, 0, 0, 8277, 8272, 1, 0, 0, 0, 8278, 897, 1, 0, 0, 0, 8279, 8281, 5, 265, 0, 0, 8280, 8282, 3, 896, 448, 0, 8281, 8280, 1, 0, 0, 0, 8281, 8282, 1, 0, 0, 0, 8282, 8283, 1, 0, 0, 0, 8283, 8284, 3, 922, 461, 0, 8284, 8285, 5, 7, 0, 0, 8285, 899, 1, 0, 0, 0, 8286, 8288, 3, 572, 286, 0, 8287, 8286, 1, 0, 0, 0, 8287, 8288, 1, 0, 0, 0, 8288, 8289, 1, 0, 0, 0, 8289, 8290, 5, 525, 0, 0, 8290, 8292, 5, 71, 0, 0, 8291, 8293, 5, 81, 0, 0, 8292, 8291, 1, 0, 0, 0, 8292, 8293, 1, 0, 0, 0, 8293, 8294, 1, 0, 0, 0, 8294, 8296, 3, 774, 387, 0, 8295, 8297, 5, 9, 0, 0, 8296, 8295, 1, 0, 0, 0, 8296, 8297, 1, 0, 0, 0, 8297, 8302, 1, 0, 0, 0, 8298, 8300, 5, 36, 0, 0, 8299, 8298, 1, 0, 0, 0, 8299, 8300, 1, 0, 0, 0, 8300, 8301, 1, 0, 0, 0, 8301, 8303, 3, 818, 409, 0, 8302, 8299, 1, 0, 0, 0, 8302, 8303, 1, 0, 0, 0, 8303, 8304, 1, 0, 0, 0, 8304, 8305, 5, 100, 0, 0, 8305, 8306, 3, 902, 451, 0, 8306, 8307, 5, 80, 0, 0, 8307, 8309, 3, 674, 337, 0, 8308, 8310, 3, 904, 452, 0, 8309, 8308, 1, 0, 0, 0, 8310, 8311, 1, 0, 0, 0, 8311, 8309, 1, 0, 0, 0, 8311, 8312, 1, 0, 0, 0, 8312, 901, 1, 0, 0, 0, 8313, 8315, 5, 81, 0, 0, 8314, 8313, 1, 0, 0, 0, 8314, 8315, 1, 0, 0, 0, 8315, 8316, 1, 0, 0, 0, 8316, 8318, 3, 774, 387, 0, 8317, 8319, 5, 9, 0, 0, 8318, 8317, 1, 0, 0, 0, 8318, 8319, 1, 0, 0, 0, 8319, 8325, 1, 0, 0, 0, 8320, 8323, 3, 564, 282, 0, 8321, 8323, 3, 608, 304, 0, 8322, 8320, 1, 0, 0, 0, 8322, 8321, 1, 0, 0, 0, 8323, 8325, 1, 0, 0, 0, 8324, 8314, 1, 0, 0, 0, 8324, 8322, 1, 0, 0, 0, 8325, 8330, 1, 0, 0, 0, 8326, 8328, 5, 36, 0, 0, 8327, 8326, 1, 0, 0, 0, 8327, 8328, 1, 0, 0, 0, 8328, 8329, 1, 0, 0, 0, 8329, 8331, 3, 818, 409, 0, 8330, 8327, 1, 0, 0, 0, 8330, 8331, 1, 0, 0, 0, 8331, 903, 1, 0, 0, 0, 8332, 8333, 5, 102, 0, 0, 8333, 8336, 5, 526, 0, 0, 8334, 8335, 5, 33, 0, 0, 8335, 8337, 3, 674, 337, 0, 8336, 8334, 1, 0, 0, 0, 8336, 8337, 1, 0, 0, 0, 8337, 8338, 1, 0, 0, 0, 8338, 8343, 5, 93, 0, 0, 8339, 8344, 3, 908, 454, 0, 8340, 8344, 5, 182, 0, 0, 8341, 8342, 5, 57, 0, 0, 8342, 8344, 5, 270, 0, 0, 8343, 8339, 1, 0, 0, 0, 8343, 8340, 1, 0, 0, 0, 8343, 8341, 1, 0, 0, 0, 8344, 8359, 1, 0, 0, 0, 8345, 8346, 5, 102, 0, 0, 8346, 8347, 5, 77, 0, 0, 8347, 8350, 5, 526, 0, 0, 8348, 8349, 5, 33, 0, 0, 8349, 8351, 3, 674, 337, 0, 8350, 8348, 1, 0, 0, 0, 8350, 8351, 1, 0, 0, 0, 8351, 8352, 1, 0, 0, 0, 8352, 8356, 5, 93, 0, 0, 8353, 8357, 3, 906, 453, 0, 8354, 8355, 5, 57, 0, 0, 8355, 8357, 5, 270, 0, 0, 8356, 8353, 1, 0, 0, 0, 8356, 8354, 1, 0, 0, 0, 8357, 8359, 1, 0, 0, 0, 8358, 8332, 1, 0, 0, 0, 8358, 8345, 1, 0, 0, 0, 8359, 905, 1, 0, 0, 0, 8360, 8362, 5, 241, 0, 0, 8361, 8363, 3, 144, 72, 0, 8362, 8361, 1, 0, 0, 0, 8362, 8363, 1, 0, 0, 0, 8363, 8367, 1, 0, 0, 0, 8364, 8365, 5, 463, 0, 0, 8365, 8366, 7, 76, 0, 0, 8366, 8368, 5, 450, 0, 0, 8367, 8364, 1, 0, 0, 0, 8367, 8368, 1, 0, 0, 0, 8368, 8369, 1, 0, 0, 0, 8369, 8370, 3, 910, 455, 0, 8370, 907, 1, 0, 0, 0, 8371, 8372, 5, 369, 0, 0, 8372, 8390, 5, 333, 0, 0, 8373, 8374, 3, 800, 400, 0, 8374, 8375, 5, 10, 0, 0, 8375, 8376, 3, 912, 456, 0, 8376, 8391, 1, 0, 0, 0, 8377, 8378, 3, 144, 72, 0, 8378, 8379, 5, 10, 0, 0, 8379, 8380, 5, 2, 0, 0, 8380, 8385, 3, 912, 456, 0, 8381, 8382, 5, 6, 0, 0, 8382, 8384, 3, 912, 456, 0, 8383, 8381, 1, 0, 0, 0, 8384, 8387, 1, 0, 0, 0, 8385, 8383, 1, 0, 0, 0, 8385, 8386, 1, 0, 0, 0, 8386, 8388, 1, 0, 0, 0, 8387, 8385, 1, 0, 0, 0, 8388, 8389, 5, 3, 0, 0, 8389, 8391, 1, 0, 0, 0, 8390, 8373, 1, 0, 0, 0, 8390, 8377, 1, 0, 0, 0, 8391, 8392, 1, 0, 0, 0, 8392, 8390, 1, 0, 0, 0, 8392, 8393, 1, 0, 0, 0, 8393, 909, 1, 0, 0, 0, 8394, 8395, 5, 422, 0, 0, 8395, 8396, 5, 2, 0, 0, 8396, 8401, 3, 912, 456, 0, 8397, 8398, 5, 6, 0, 0, 8398, 8400, 3, 912, 456, 0, 8399, 8397, 1, 0, 0, 0, 8400, 8403, 1, 0, 0, 0, 8401, 8399, 1, 0, 0, 0, 8401, 8402, 1, 0, 0, 0, 8402, 8404, 1, 0, 0, 0, 8403, 8401, 1, 0, 0, 0, 8404, 8405, 5, 3, 0, 0, 8405, 8409, 1, 0, 0, 0, 8406, 8407, 5, 53, 0, 0, 8407, 8409, 5, 422, 0, 0, 8408, 8394, 1, 0, 0, 0, 8408, 8406, 1, 0, 0, 0, 8409, 911, 1, 0, 0, 0, 8410, 8413, 3, 588, 294, 0, 8411, 8413, 5, 53, 0, 0, 8412, 8410, 1, 0, 0, 0, 8412, 8411, 1, 0, 0, 0, 8413, 913, 1, 0, 0, 0, 8414, 8415, 5, 157, 0, 0, 8415, 8416, 3, 922, 461, 0, 8416, 8417, 5, 7, 0, 0, 8417, 915, 1, 0, 0, 0, 8418, 8419, 5, 78, 0, 0, 8419, 8420, 5, 7, 0, 0, 8420, 917, 1, 0, 0, 0, 8421, 8427, 7, 67, 0, 0, 8422, 8424, 5, 33, 0, 0, 8423, 8425, 5, 269, 0, 0, 8424, 8423, 1, 0, 0, 0, 8424, 8425, 1, 0, 0, 0, 8425, 8426, 1, 0, 0, 0, 8426, 8428, 5, 153, 0, 0, 8427, 8422, 1, 0, 0, 0, 8427, 8428, 1, 0, 0, 0, 8428, 8429, 1, 0, 0, 0, 8429, 8430, 5, 7, 0, 0, 8430, 919, 1, 0, 0, 0, 8431, 8432, 5, 333, 0, 0, 8432, 8433, 3, 316, 158, 0, 8433, 8434, 5, 94, 0, 0, 8434, 8435, 5, 53, 0, 0, 8435, 8436, 5, 7, 0, 0, 8436, 8444, 1, 0, 0, 0, 8437, 8440, 5, 313, 0, 0, 8438, 8441, 3, 316, 158, 0, 8439, 8441, 5, 30, 0, 0, 8440, 8438, 1, 0, 0, 0, 8440, 8439, 1, 0, 0, 0, 8441, 8442, 1, 0, 0, 0, 8442, 8444, 5, 7, 0, 0, 8443, 8431, 1, 0, 0, 0, 8443, 8437, 1, 0, 0, 0, 8444, 921, 1, 0, 0, 0, 8445, 8448, 3, 818, 409, 0, 8446, 8448, 5, 28, 0, 0, 8447, 8445, 1, 0, 0, 0, 8447, 8446, 1, 0, 0, 0, 8448, 923, 1, 0, 0, 0, 8449, 8466, 5, 517, 0, 0, 8450, 8451, 5, 102, 0, 0, 8451, 8456, 3, 926, 463, 0, 8452, 8453, 5, 82, 0, 0, 8453, 8455, 3, 926, 463, 0, 8454, 8452, 1, 0, 0, 0, 8455, 8458, 1, 0, 0, 0, 8456, 8454, 1, 0, 0, 0, 8456, 8457, 1, 0, 0, 0, 8457, 8459, 1, 0, 0, 0, 8458, 8456, 1, 0, 0, 0, 8459, 8463, 5, 93, 0, 0, 8460, 8462, 3, 846, 423, 0, 8461, 8460, 1, 0, 0, 0, 8462, 8465, 1, 0, 0, 0, 8463, 8461, 1, 0, 0, 0, 8463, 8464, 1, 0, 0, 0, 8464, 8467, 1, 0, 0, 0, 8465, 8463, 1, 0, 0, 0, 8466, 8450, 1, 0, 0, 0, 8467, 8468, 1, 0, 0, 0, 8468, 8466, 1, 0, 0, 0, 8468, 8469, 1, 0, 0, 0, 8469, 925, 1, 0, 0, 0, 8470, 8474, 3, 928, 464, 0, 8471, 8472, 5, 511, 0, 0, 8472, 8474, 3, 808, 404, 0, 8473, 8470, 1, 0, 0, 0, 8473, 8471, 1, 0, 0, 0, 8474, 927, 1, 0, 0, 0, 8475, 8478, 3, 818, 409, 0, 8476, 8478, 3, 930, 465, 0, 8477, 8475, 1, 0, 0, 0, 8477, 8476, 1, 0, 0, 0, 8478, 929, 1, 0, 0, 0, 8479, 8480, 7, 118, 0, 0, 8480, 931, 1, 0, 0, 0, 8481, 8483, 3, 756, 378, 0, 8482, 8481, 1, 0, 0, 0, 8482, 8483, 1, 0, 0, 0, 8483, 8485, 1, 0, 0, 0, 8484, 8486, 3, 580, 290, 0, 8485, 8484, 1, 0, 0, 0, 8485, 8486, 1, 0, 0, 0, 8486, 8488, 1, 0, 0, 0, 8487, 8489, 3, 610, 305, 0, 8488, 8487, 1, 0, 0, 0, 8488, 8489, 1, 0, 0, 0, 8489, 8491, 1, 0, 0, 0, 8490, 8492, 3, 638, 319, 0, 8491, 8490, 1, 0, 0, 0, 8491, 8492, 1, 0, 0, 0, 8492, 8494, 1, 0, 0, 0, 8493, 8495, 3, 600, 300, 0, 8494, 8493, 1, 0, 0, 0, 8494, 8495, 1, 0, 0, 0, 8495, 8498, 1, 0, 0, 0, 8496, 8497, 5, 67, 0, 0, 8497, 8499, 3, 674, 337, 0, 8498, 8496, 1, 0, 0, 0, 8498, 8499, 1, 0, 0, 0, 8499, 8501, 1, 0, 0, 0, 8500, 8502, 3, 702, 351, 0, 8501, 8500, 1, 0, 0, 0, 8501, 8502, 1, 0, 0, 0, 8502, 933, 1, 0, 0, 0, 1188, 937, 944, 1064, 1066, 1075, 1080, 1086, 1121, 1131, 1137, 1142, 1149, 1154, 1161, 1172, 1180, 1184, 1196, 1202, 1208, 1212, 1217, 1221, 1234, 1244, 1246, 1252, 1257, 1270, 1273, 1278, 1283, 1294, 1298, 1310, 1314, 1317, 1321, 1333, 1351, 1358, 1366, 1371, 1378, 1386, 1392, 1400, 1408, 1412, 1426, 1431, 1436, 1448, 1454, 1466, 1471, 1481, 1487, 1492, 1500, 1505, 1512, 1517, 1522, 1532, 1537, 1542, 1549, 1553, 1567, 1573, 1579, 1584, 1591, 1603, 1611, 1619, 1635, 1644, 1653, 1662, 1666, 1678, 1686, 1696, 1716, 1721, 1724, 1731, 1734, 1738, 1742, 1745, 1750, 1755, 1759, 1768, 1774, 1778, 1787, 1790, 1796, 1805, 1817, 1821, 1825, 1830, 1833, 1839, 1841, 1843, 1847, 1853, 1857, 1862, 1867, 1871, 1874, 1881, 1894, 1907, 1921, 1938, 1948, 1955, 1960, 1964, 1971, 1976, 1979, 1981, 1986, 1990, 1994, 1998, 2003, 2006, 2010, 2013, 2017, 2025, 2030, 2033, 2037, 2043, 2052, 2056, 2062, 2064, 2073, 2078, 2090, 2095, 2099, 2103, 2108, 2112, 2115, 2118, 2121, 2124, 2127, 2132, 2135, 2138, 2141, 2144, 2147, 2153, 2157, 2160, 2163, 2166, 2169, 2171, 2178, 2186, 2196, 2206, 2211, 2214, 2219, 2224, 2229, 2232, 2237, 2246, 2248, 2252, 2255, 2259, 2264, 2269, 2273, 2276, 2280, 2283, 2288, 2291, 2296, 2299, 2303, 2306, 2309, 2314, 2317, 2325, 2337, 2341, 2348, 2353, 2356, 2359, 2362, 2367, 2378, 2384, 2388, 2391, 2394, 2399, 2406, 2409, 2413, 2421, 2426, 2429, 2432, 2439, 2444, 2453, 2456, 2459, 2464, 2467, 2479, 2489, 2506, 2510, 2514, 2516, 2533, 2535, 2551, 2562, 2565, 2568, 2577, 2586, 2602, 2605, 2608, 2616, 2620, 2627, 2636, 2640, 2646, 2650, 2653, 2656, 2659, 2662, 2668, 2672, 2677, 2681, 2684, 2687, 2690, 2695, 2701, 2705, 2709, 2713, 2719, 2721, 2726, 2732, 2738, 2742, 2757, 2762, 2765, 2767, 2770, 2774, 2778, 2781, 2784, 2792, 2798, 2800, 2806, 2811, 2816, 2820, 2827, 2829, 2840, 2879, 2889, 2891, 2894, 2898, 2902, 2912, 2914, 2920, 2922, 2931, 2943, 2957, 2962, 2965, 2972, 2977, 2985, 2987, 2993, 2998, 3002, 3007, 3013, 3020, 3026, 3028, 3037, 3043, 3051, 3057, 3062, 3067, 3075, 3090, 3092, 3096, 3100, 3103, 3106, 3115, 3118, 3121, 3127, 3133, 3137, 3149, 3155, 3158, 3163, 3167, 3174, 3184, 3186, 3210, 3222, 3227, 3229, 3233, 3236, 3239, 3249, 3252, 3262, 3267, 3272, 3275, 3278, 3286, 3292, 3299, 3307, 3310, 3321, 3325, 3331, 3338, 3341, 3350, 3364, 3367, 3381, 3392, 3395, 3407, 3412, 3425, 3430, 3443, 3452, 3455, 3458, 3465, 3468, 3480, 3486, 3488, 3496, 3504, 3512, 3524, 3529, 3540, 3551, 3559, 3567, 3574, 3581, 3583, 3586, 3591, 3596, 3615, 3624, 3627, 3654, 3663, 3666, 3670, 3674, 3678, 3685, 3689, 3693, 3697, 3701, 3706, 3710, 3715, 3721, 3726, 3733, 3737, 3743, 3747, 3752, 3760, 3766, 3771, 3778, 3783, 3787, 3792, 3798, 3805, 3810, 3817, 3822, 3829, 3833, 3841, 3845, 3847, 3850, 3855, 3865, 3880, 3883, 3891, 3898, 3903, 3909, 3913, 3920, 3925, 3928, 3931, 3935, 3944, 3962, 3965, 3997, 4002, 4008, 4028, 4033, 4039, 4042, 4046, 4050, 4056, 4059, 4063, 4067, 4072, 4075, 4078, 4081, 4094, 4100, 4108, 4115, 4120, 4123, 4130, 4133, 4141, 4144, 4149, 4156, 4159, 4179, 4191, 4194, 4200, 4205, 4214, 4222, 4227, 4233, 4240, 4248, 4251, 4262, 4264, 4278, 4284, 4292, 4294, 4300, 4304, 4307, 4310, 4315, 4320, 4324, 4327, 4330, 4333, 4336, 4344, 4355, 4358, 4361, 4366, 4369, 4373, 4377, 4383, 4391, 4394, 4407, 4412, 4414, 4419, 4426, 4433, 4442, 4450, 4458, 4465, 4473, 4480, 4488, 4492, 4496, 4498, 4504, 4509, 4513, 4520, 4525, 4530, 4535, 4537, 4547, 4557, 4573, 4591, 4603, 4610, 4625, 4630, 4633, 4638, 4643, 4648, 4651, 4654, 4659, 4666, 4670, 4675, 4682, 4686, 4692, 4701, 4710, 4722, 4724, 4737, 4743, 4747, 4749, 4756, 4769, 4776, 4778, 4794, 4798, 4802, 4807, 4812, 4817, 4822, 4825, 4837, 4890, 4899, 4903, 4912, 4916, 4925, 4929, 4934, 4937, 4941, 4946, 4948, 4957, 4962, 4973, 4977, 4991, 4999, 5037, 5039, 5058, 5061, 5088, 5092, 5096, 5100, 5104, 5107, 5122, 5129, 5143, 5156, 5181, 5200, 5215, 5231, 5238, 5249, 5252, 5271, 5274, 5287, 5291, 5311, 5323, 5327, 5349, 5353, 5363, 5367, 5373, 5377, 5381, 5385, 5392, 5397, 5408, 5412, 5415, 5420, 5426, 5437, 5441, 5444, 5448, 5452, 5455, 5465, 5468, 5472, 5477, 5483, 5486, 5491, 5494, 5501, 5503, 5509, 5513, 5522, 5527, 5529, 5539, 5542, 5547, 5555, 5558, 5563, 5565, 5567, 5573, 5590, 5596, 5609, 5615, 5619, 5624, 5654, 5669, 5674, 5678, 5691, 5695, 5697, 5706, 5712, 5714, 5718, 5721, 5724, 5727, 5730, 5732, 5735, 5739, 5747, 5752, 5755, 5761, 5765, 5769, 5774, 5776, 5780, 5784, 5791, 5797, 5801, 5803, 5805, 5818, 5826, 5834, 5845, 5854, 5859, 5863, 5867, 5874, 5877, 5879, 5887, 5891, 5894, 5901, 5908, 5913, 5920, 5923, 5925, 5928, 5934, 5939, 5943, 5950, 5960, 5967, 5970, 5973, 5977, 5988, 5991, 5994, 5997, 6000, 6007, 6010, 6013, 6020, 6032, 6039, 6041, 6046, 6051, 6053, 6059, 6066, 6071, 6076, 6080, 6084, 6088, 6090, 6094, 6098, 6101, 6104, 6106, 6116, 6118, 6123, 6127, 6132, 6136, 6143, 6148, 6152, 6155, 6161, 6164, 6183, 6190, 6194, 6197, 6201, 6205, 6208, 6211, 6216, 6225, 6232, 6236, 6240, 6244, 6247, 6249, 6254, 6258, 6263, 6269, 6276, 6281, 6286, 6295, 6302, 6310, 6321, 6326, 6330, 6333, 6337, 6342, 6346, 6351, 6359, 6370, 6375, 6379, 6382, 6385, 6387, 6390, 6393, 6396, 6400, 6404, 6408, 6410, 6419, 6424, 6430, 6434, 6436, 6443, 6448, 6454, 6456, 6460, 6467, 6472, 6475, 6481, 6485, 6491, 6500, 6506, 6508, 6513, 6516, 6525, 6532, 6534, 6541, 6546, 6549, 6559, 6570, 6575, 6579, 6587, 6597, 6604, 6610, 6621, 6627, 6637, 6646, 6650, 6653, 6655, 6657, 6661, 6669, 6672, 6677, 6682, 6689, 6691, 6697, 6701, 6704, 6709, 6712, 6714, 6720, 6729, 6735, 6738, 6746, 6749, 6753, 6759, 6761, 6764, 6768, 6773, 6780, 6787, 6789, 6795, 6797, 6802, 6804, 6808, 6817, 6821, 6829, 6831, 6845, 6848, 6856, 6865, 6871, 6876, 6884, 6886, 6891, 6895, 6900, 6905, 6911, 6927, 6929, 6938, 6953, 6958, 6961, 6967, 6972, 6985, 6990, 6994, 7001, 7020, 7032, 7037, 7045, 7047, 7049, 7058, 7061, 7066, 7071, 7075, 7078, 7087, 7095, 7100, 7102, 7105, 7109, 7120, 7141, 7149, 7162, 7172, 7178, 7184, 7187, 7190, 7216, 7218, 7239, 7249, 7262, 7267, 7271, 7273, 7285, 7292, 7298, 7304, 7308, 7319, 7329, 7333, 7338, 7341, 7344, 7353, 7364, 7366, 7370, 7375, 7384, 7389, 7397, 7407, 7415, 7419, 7422, 7429, 7437, 7441, 7448, 7456, 7465, 7468, 7480, 7489, 7496, 7505, 7515, 7520, 7524, 7526, 7529, 7534, 7539, 7547, 7555, 7558, 7565, 7573, 7581, 7589, 7606, 7613, 7621, 7638, 7644, 7650, 7658, 7664, 7669, 7677, 7682, 7685, 7694, 7701, 7708, 7714, 7720, 7725, 7730, 7738, 7793, 7800, 7806, 7808, 7810, 7812, 7818, 7822, 7826, 7837, 7840, 7844, 7848, 7852, 7855, 7858, 7861, 7870, 7875, 7879, 7912, 7922, 7926, 7932, 7937, 7946, 7954, 7965, 7973, 7982, 7991, 7996, 8000, 8010, 8015, 8023, 8028, 8031, 8038, 8044, 8052, 8060, 8063, 8070, 8072, 8075, 8081, 8090, 8094, 8108, 8111, 8113, 8119, 8129, 8131, 8133, 8141, 8144, 8147, 8157, 8165, 8171, 8177, 8184, 8188, 8192, 8195, 8198, 8204, 8211, 8214, 8222, 8224, 8233, 8238, 8240, 8247, 8253, 8256, 8268, 8275, 8277, 8281, 8287, 8292, 8296, 8299, 8302, 8311, 8314, 8318, 8322, 8324, 8327, 8330, 8336, 8343, 8350, 8356, 8358, 8362, 8367, 8385, 8390, 8392, 8401, 8408, 8412, 8424, 8427, 8440, 8443, 8447, 8456, 8463, 8468, 8473, 8477, 8482, 8485, 8488, 8491, 8494, 8498, 8501] \ No newline at end of file diff --git a/src/lib/postgresql/PostgreSqlParser.ts b/src/lib/postgresql/PostgreSqlParser.ts index fdcc11d8..908f2837 100644 --- a/src/lib/postgresql/PostgreSqlParser.ts +++ b/src/lib/postgresql/PostgreSqlParser.ts @@ -608,880 +608,472 @@ export class PostgreSqlParser extends SQLParserBase { public static readonly EndDollarStringConstant = 589; public static readonly AfterEscapeStringConstantWithNewlineMode_Continued = 590; public static readonly RULE_program = 0; - public static readonly RULE_plsqlroot = 1; - public static readonly RULE_singleStmt = 2; - public static readonly RULE_stmt = 3; - public static readonly RULE_plsqlconsolecommand = 4; - public static readonly RULE_callstmt = 5; - public static readonly RULE_createrolestmt = 6; - public static readonly RULE_opt_with = 7; - public static readonly RULE_optrolelist = 8; - public static readonly RULE_alteroptrolelist = 9; - public static readonly RULE_alteroptroleelem = 10; - public static readonly RULE_createoptroleelem = 11; - public static readonly RULE_createuserstmt = 12; - public static readonly RULE_alterrolestmt = 13; - public static readonly RULE_opt_in_database = 14; - public static readonly RULE_alterrolesetstmt = 15; - public static readonly RULE_alterroutinestmt = 16; - public static readonly RULE_alter_routine_cluase = 17; - public static readonly RULE_routine_action_list = 18; - public static readonly RULE_routine_action = 19; - public static readonly RULE_creategroupstmt = 20; - public static readonly RULE_altergroupstmt = 21; - public static readonly RULE_add_drop = 22; - public static readonly RULE_createschemastmt = 23; - public static readonly RULE_schema_name_create = 24; - public static readonly RULE_optschemaeltlist = 25; - public static readonly RULE_schema_stmt = 26; - public static readonly RULE_variablesetstmt = 27; - public static readonly RULE_set_rest = 28; - public static readonly RULE_generic_set = 29; - public static readonly RULE_set_rest_more = 30; - public static readonly RULE_var_name = 31; - public static readonly RULE_var_list = 32; - public static readonly RULE_var_value = 33; - public static readonly RULE_iso_level = 34; - public static readonly RULE_opt_boolean_or_string_column = 35; - public static readonly RULE_opt_boolean_or_string = 36; - public static readonly RULE_zone_value = 37; - public static readonly RULE_opt_encoding = 38; - public static readonly RULE_nonreservedword_or_sconst_column = 39; - public static readonly RULE_nonreservedword_or_sconst = 40; - public static readonly RULE_variableresetstmt = 41; - public static readonly RULE_reset_rest = 42; - public static readonly RULE_generic_reset = 43; - public static readonly RULE_setresetclause = 44; - public static readonly RULE_functionsetresetclause = 45; - public static readonly RULE_variableshowstmt = 46; - public static readonly RULE_constraintssetstmt = 47; - public static readonly RULE_constraints_set_list = 48; - public static readonly RULE_constraints_set_mode = 49; - public static readonly RULE_checkpointstmt = 50; - public static readonly RULE_discardstmt = 51; - public static readonly RULE_altertablestmt = 52; - public static readonly RULE_alter_table_cmds = 53; - public static readonly RULE_partition_bound_spec = 54; - public static readonly RULE_partition_bound_cluase = 55; - public static readonly RULE_partition_bound_choose = 56; - public static readonly RULE_partition_with_cluase = 57; - public static readonly RULE_partition_cmd = 58; - public static readonly RULE_index_partition_cmd = 59; - public static readonly RULE_alter_table_cmd = 60; - public static readonly RULE_alter_column_default = 61; - public static readonly RULE_opt_drop_behavior = 62; - public static readonly RULE_opt_collate_clause = 63; - public static readonly RULE_alter_using = 64; - public static readonly RULE_replica_identity = 65; - public static readonly RULE_reloptions = 66; - public static readonly RULE_opt_reloptions = 67; - public static readonly RULE_reloption_list = 68; - public static readonly RULE_reloption_elem = 69; - public static readonly RULE_alter_identity_column_option_list = 70; - public static readonly RULE_alter_identity_column_option = 71; - public static readonly RULE_partitionboundspec = 72; - public static readonly RULE_hash_partbound_elem = 73; - public static readonly RULE_hash_partbound = 74; - public static readonly RULE_altercompositetypestmt = 75; - public static readonly RULE_alter_type_cmds = 76; - public static readonly RULE_alter_type_cmd = 77; - public static readonly RULE_closeportalstmt = 78; - public static readonly RULE_copystmt = 79; - public static readonly RULE_copy_from = 80; - public static readonly RULE_opt_program = 81; - public static readonly RULE_copy_file_name = 82; - public static readonly RULE_copy_options = 83; - public static readonly RULE_copy_opt_list = 84; - public static readonly RULE_copy_opt_item = 85; - public static readonly RULE_opt_binary = 86; - public static readonly RULE_copy_delimiter = 87; - public static readonly RULE_opt_using = 88; - public static readonly RULE_copy_generic_opt_list = 89; - public static readonly RULE_copy_generic_opt_elem = 90; - public static readonly RULE_copy_generic_opt_arg = 91; - public static readonly RULE_copy_generic_opt_arg_list = 92; - public static readonly RULE_copy_generic_opt_arg_list_item = 93; - public static readonly RULE_createstmt = 94; - public static readonly RULE_opttemp = 95; - public static readonly RULE_table_column_list = 96; - public static readonly RULE_opttableelementlist = 97; - public static readonly RULE_opttypedtableelementlist = 98; - public static readonly RULE_tableelementlist = 99; - public static readonly RULE_typedtableelementlist = 100; - public static readonly RULE_tableelement = 101; - public static readonly RULE_typedtableelement = 102; - public static readonly RULE_column_def = 103; - public static readonly RULE_compressionCluase = 104; - public static readonly RULE_storageCluase = 105; - public static readonly RULE_columnOptions = 106; - public static readonly RULE_colquallist = 107; - public static readonly RULE_colconstraint = 108; - public static readonly RULE_colconstraintelem = 109; - public static readonly RULE_nulls_distinct = 110; - public static readonly RULE_generated_when = 111; - public static readonly RULE_deferrable_trigger = 112; - public static readonly RULE_initially_trigger = 113; - public static readonly RULE_tablelikeclause = 114; - public static readonly RULE_tablelikeoptionlist = 115; - public static readonly RULE_tablelikeoption = 116; - public static readonly RULE_tableconstraint = 117; - public static readonly RULE_constraintelem = 118; - public static readonly RULE_opt_no_inherit = 119; - public static readonly RULE_opt_column_list = 120; - public static readonly RULE_opt_column_list_create = 121; - public static readonly RULE_column_list = 122; - public static readonly RULE_column_list_create = 123; - public static readonly RULE_opt_c_include = 124; - public static readonly RULE_key_match = 125; - public static readonly RULE_exclusionconstraintlist = 126; - public static readonly RULE_exclusionconstraintelem = 127; - public static readonly RULE_exclusionwhereclause = 128; - public static readonly RULE_key_actions = 129; - public static readonly RULE_key_update = 130; - public static readonly RULE_key_delete = 131; - public static readonly RULE_key_action = 132; - public static readonly RULE_optinherit = 133; - public static readonly RULE_optpartitionspec = 134; - public static readonly RULE_partitionspec = 135; - public static readonly RULE_part_params = 136; - public static readonly RULE_part_elem = 137; - public static readonly RULE_table_access_method_clause = 138; - public static readonly RULE_optwith = 139; - public static readonly RULE_oncommitoption = 140; - public static readonly RULE_opttablespace = 141; - public static readonly RULE_index_paramenters_create = 142; - public static readonly RULE_optconstablespace = 143; - public static readonly RULE_existingindex = 144; - public static readonly RULE_createstatsstmt = 145; - public static readonly RULE_alterstatsstmt = 146; - public static readonly RULE_createasstmt = 147; - public static readonly RULE_create_as_target = 148; - public static readonly RULE_opt_with_data = 149; - public static readonly RULE_creatematviewstmt = 150; - public static readonly RULE_create_mv_target = 151; - public static readonly RULE_optnolog = 152; - public static readonly RULE_refreshmatviewstmt = 153; - public static readonly RULE_createseqstmt = 154; - public static readonly RULE_alterseqstmt = 155; - public static readonly RULE_optseqoptlist = 156; - public static readonly RULE_optparenthesizedseqoptlist = 157; - public static readonly RULE_seqoptlist = 158; - public static readonly RULE_seqoptelem = 159; - public static readonly RULE_opt_by = 160; - public static readonly RULE_numericonly = 161; - public static readonly RULE_numericonly_list = 162; - public static readonly RULE_createplangstmt = 163; - public static readonly RULE_opt_trusted = 164; - public static readonly RULE_handler_name = 165; - public static readonly RULE_opt_inline_handler = 166; - public static readonly RULE_validator_clause = 167; - public static readonly RULE_opt_validator = 168; - public static readonly RULE_opt_procedural = 169; - public static readonly RULE_createtablespacestmt = 170; - public static readonly RULE_opttablespaceowner = 171; - public static readonly RULE_createextensionstmt = 172; - public static readonly RULE_create_extension_opt_list = 173; - public static readonly RULE_create_extension_opt_item = 174; - public static readonly RULE_alterextensionstmt = 175; - public static readonly RULE_alter_extension_opt_list = 176; - public static readonly RULE_alter_extension_opt_item = 177; - public static readonly RULE_alterextensioncontentsstmt = 178; - public static readonly RULE_createfdwstmt = 179; - public static readonly RULE_fdw_option = 180; - public static readonly RULE_fdw_options = 181; - public static readonly RULE_opt_fdw_options = 182; - public static readonly RULE_alterfdwstmt = 183; - public static readonly RULE_create_generic_options = 184; - public static readonly RULE_generic_option_list = 185; - public static readonly RULE_alter_generic_options = 186; - public static readonly RULE_alter_generic_option_list = 187; - public static readonly RULE_alter_generic_option_elem = 188; - public static readonly RULE_generic_option_elem = 189; - public static readonly RULE_generic_option_name = 190; - public static readonly RULE_generic_option_arg = 191; - public static readonly RULE_createforeignserverstmt = 192; - public static readonly RULE_opt_type = 193; - public static readonly RULE_foreign_server_version = 194; - public static readonly RULE_opt_foreign_server_version = 195; - public static readonly RULE_alterforeignserverstmt = 196; - public static readonly RULE_createforeigntablestmt = 197; - public static readonly RULE_importforeignschemastmt = 198; - public static readonly RULE_import_qualification_type = 199; - public static readonly RULE_import_qualification = 200; - public static readonly RULE_createusermappingstmt = 201; - public static readonly RULE_auth_ident = 202; - public static readonly RULE_alterusermappingstmt = 203; - public static readonly RULE_createpolicystmt = 204; - public static readonly RULE_alterpolicystmt = 205; - public static readonly RULE_alterprocedurestmt = 206; - public static readonly RULE_procedure_cluase = 207; - public static readonly RULE_procedure_action = 208; - public static readonly RULE_rowsecurityoptionalexpr = 209; - public static readonly RULE_rowsecurityoptionalwithcheck = 210; - public static readonly RULE_rowsecuritydefaulttorole = 211; - public static readonly RULE_rowsecurityoptionaltorole = 212; - public static readonly RULE_rowsecuritydefaultpermissive = 213; - public static readonly RULE_rowsecuritydefaultforcmd = 214; - public static readonly RULE_row_security_cmd = 215; - public static readonly RULE_createamstmt = 216; - public static readonly RULE_am_type = 217; - public static readonly RULE_createtrigstmt = 218; - public static readonly RULE_triggeractiontime = 219; - public static readonly RULE_foreachrow = 220; - public static readonly RULE_roworstatment = 221; - public static readonly RULE_triggerevents = 222; - public static readonly RULE_triggeroneevent = 223; - public static readonly RULE_triggerreferencing = 224; - public static readonly RULE_triggertransitions = 225; - public static readonly RULE_triggertransition = 226; - public static readonly RULE_transitionoldornew = 227; - public static readonly RULE_transitionrowortable = 228; - public static readonly RULE_transitionrelname = 229; - public static readonly RULE_triggerforspec = 230; - public static readonly RULE_triggerforopteach = 231; - public static readonly RULE_triggerfortype = 232; - public static readonly RULE_triggerwhen = 233; - public static readonly RULE_function_or_procedure = 234; - public static readonly RULE_triggerfuncargs = 235; - public static readonly RULE_triggerfuncarg = 236; - public static readonly RULE_optconstrfromtable = 237; - public static readonly RULE_constraintattributespec = 238; - public static readonly RULE_constraintattributeElem = 239; - public static readonly RULE_createeventtrigstmt = 240; - public static readonly RULE_event_trigger_when_list = 241; - public static readonly RULE_event_trigger_when_item = 242; - public static readonly RULE_event_trigger_value_list = 243; - public static readonly RULE_altereventtrigstmt = 244; - public static readonly RULE_enable_trigger = 245; - public static readonly RULE_createassertionstmt = 246; - public static readonly RULE_definestmt = 247; - public static readonly RULE_definition = 248; - public static readonly RULE_def_list = 249; - public static readonly RULE_def_elem = 250; - public static readonly RULE_def_arg = 251; - public static readonly RULE_old_aggr_definition = 252; - public static readonly RULE_old_aggr_list = 253; - public static readonly RULE_old_aggr_elem = 254; - public static readonly RULE_opt_enum_val_list = 255; - public static readonly RULE_enum_val_list = 256; - public static readonly RULE_alterenumstmt = 257; - public static readonly RULE_opt_if_not_exists = 258; - public static readonly RULE_createopclassstmt = 259; - public static readonly RULE_opclass_item_list = 260; - public static readonly RULE_opclass_item = 261; - public static readonly RULE_opt_default = 262; - public static readonly RULE_opt_opfamily = 263; - public static readonly RULE_opclass_purpose = 264; - public static readonly RULE_opt_recheck = 265; - public static readonly RULE_createopfamilystmt = 266; - public static readonly RULE_alteropfamilystmt = 267; - public static readonly RULE_opclass_drop_list = 268; - public static readonly RULE_opclass_drop = 269; - public static readonly RULE_reassignownedstmt = 270; - public static readonly RULE_dropstmt = 271; - public static readonly RULE_view_nameList = 272; - public static readonly RULE_object_type_any_name = 273; - public static readonly RULE_object_type_name = 274; - public static readonly RULE_object_type_name_on_any_name = 275; - public static readonly RULE_any_name_list = 276; - public static readonly RULE_relation_column_name = 277; - public static readonly RULE_relation_name = 278; - public static readonly RULE_any_name = 279; - public static readonly RULE_attrs = 280; - public static readonly RULE_type_name_list = 281; - public static readonly RULE_truncatestmt = 282; - public static readonly RULE_truncate_table = 283; - public static readonly RULE_commentstmt = 284; - public static readonly RULE_comment_text = 285; - public static readonly RULE_seclabelstmt = 286; - public static readonly RULE_opt_provider = 287; - public static readonly RULE_security_label = 288; - public static readonly RULE_fetchstmt = 289; - public static readonly RULE_fetch_args = 290; - public static readonly RULE_from_in = 291; - public static readonly RULE_opt_from_in = 292; - public static readonly RULE_grantstmt = 293; - public static readonly RULE_revokestmt = 294; - public static readonly RULE_privileges = 295; - public static readonly RULE_beforeprivilegeselectlist = 296; - public static readonly RULE_beforeprivilegeselect = 297; - public static readonly RULE_privilege_list = 298; - public static readonly RULE_privilege = 299; - public static readonly RULE_privilege_target = 300; - public static readonly RULE_grantee_list = 301; - public static readonly RULE_grantee = 302; - public static readonly RULE_opt_grant_grant_option = 303; - public static readonly RULE_grantrolestmt = 304; - public static readonly RULE_revokerolestmt = 305; - public static readonly RULE_opt_grant_admin_option = 306; - public static readonly RULE_opt_granted_by = 307; - public static readonly RULE_alterdefaultprivilegesstmt = 308; - public static readonly RULE_defacloptionlist = 309; - public static readonly RULE_defacloption = 310; - public static readonly RULE_defaclaction = 311; - public static readonly RULE_defacl_privilege_target = 312; - public static readonly RULE_indexstmt = 313; - public static readonly RULE_opt_unique = 314; - public static readonly RULE_opt_concurrently = 315; - public static readonly RULE_opt_index_name = 316; - public static readonly RULE_access_method_clause = 317; - public static readonly RULE_index_params = 318; - public static readonly RULE_index_elem_options = 319; - public static readonly RULE_index_elem = 320; - public static readonly RULE_opt_include = 321; - public static readonly RULE_index_including_params = 322; - public static readonly RULE_opt_collate = 323; - public static readonly RULE_opt_class = 324; - public static readonly RULE_opt_asc_desc = 325; - public static readonly RULE_opt_nulls_order = 326; - public static readonly RULE_createfunctionstmt = 327; - public static readonly RULE_attrilist = 328; - public static readonly RULE_opt_or_replace = 329; - public static readonly RULE_func_args = 330; - public static readonly RULE_func_args_list = 331; - public static readonly RULE_routine_with_argtypes_list = 332; - public static readonly RULE_routine_with_argtypes = 333; - public static readonly RULE_procedure_with_argtypes_list = 334; - public static readonly RULE_procedure_with_argtypes = 335; - public static readonly RULE_function_with_argtypes_list = 336; - public static readonly RULE_function_with_argtypes = 337; - public static readonly RULE_func_args_with_defaults = 338; - public static readonly RULE_func_args_with_defaults_list = 339; - public static readonly RULE_func_arg = 340; - public static readonly RULE_arg_class = 341; - public static readonly RULE_param_name = 342; - public static readonly RULE_func_return = 343; - public static readonly RULE_func_type = 344; - public static readonly RULE_func_arg_with_default = 345; - public static readonly RULE_aggr_arg = 346; - public static readonly RULE_aggr_args = 347; - public static readonly RULE_aggr_args_list = 348; - public static readonly RULE_aggregate_with_argtypes = 349; - public static readonly RULE_aggregate_with_argtypes_list = 350; - public static readonly RULE_createfunc_opt_list = 351; - public static readonly RULE_common_func_opt_item = 352; - public static readonly RULE_createfunc_opt_item = 353; - public static readonly RULE_transform_type_list = 354; - public static readonly RULE_opt_definition = 355; - public static readonly RULE_table_func_column = 356; - public static readonly RULE_table_func_column_list = 357; - public static readonly RULE_alterfunctionstmt = 358; - public static readonly RULE_alterFunctionTypeClause = 359; - public static readonly RULE_alterfunc_opt_list = 360; - public static readonly RULE_opt_restrict = 361; - public static readonly RULE_removefuncstmt = 362; - public static readonly RULE_removeaggrstmt = 363; - public static readonly RULE_removeoperstmt = 364; - public static readonly RULE_oper_argtypes = 365; - public static readonly RULE_any_operator = 366; - public static readonly RULE_operator_with_argtypes_list = 367; - public static readonly RULE_operator_with_argtypes = 368; - public static readonly RULE_dostmt = 369; - public static readonly RULE_dostmt_opt_list = 370; - public static readonly RULE_dostmt_opt_item = 371; - public static readonly RULE_createcaststmt = 372; - public static readonly RULE_cast_context = 373; - public static readonly RULE_opt_if_exists = 374; - public static readonly RULE_createtransformstmt = 375; - public static readonly RULE_transform_element_list = 376; - public static readonly RULE_reindexstmt = 377; - public static readonly RULE_reindex_target_type = 378; - public static readonly RULE_reindex_target_multitable = 379; - public static readonly RULE_reindex_option_list = 380; - public static readonly RULE_reindex_option_elem = 381; - public static readonly RULE_altertblspcstmt = 382; - public static readonly RULE_renamestmt = 383; - public static readonly RULE_opt_set_data = 384; - public static readonly RULE_alterobjectdependsstmt = 385; - public static readonly RULE_opt_no = 386; - public static readonly RULE_alterobjectschemastmt = 387; - public static readonly RULE_alteroperatorstmt = 388; - public static readonly RULE_operator_def_list = 389; - public static readonly RULE_operator_def_elem = 390; - public static readonly RULE_operator_def_arg = 391; - public static readonly RULE_altertypestmt = 392; - public static readonly RULE_alterownerstmt = 393; - public static readonly RULE_createpublicationstmt = 394; - public static readonly RULE_opt_publication_for_tables = 395; - public static readonly RULE_publication_for_tables = 396; - public static readonly RULE_alterpublicationstmt = 397; - public static readonly RULE_createsubscriptionstmt = 398; - public static readonly RULE_publication_name_list = 399; - public static readonly RULE_publication_name_item = 400; - public static readonly RULE_altersubscriptionstmt = 401; - public static readonly RULE_rulestmt = 402; - public static readonly RULE_ruleactionlist = 403; - public static readonly RULE_ruleactionmulti = 404; - public static readonly RULE_ruleactionstmt = 405; - public static readonly RULE_ruleactionstmtOrEmpty = 406; - public static readonly RULE_event = 407; - public static readonly RULE_opt_instead = 408; - public static readonly RULE_notifystmt = 409; - public static readonly RULE_notify_payload = 410; - public static readonly RULE_listenstmt = 411; - public static readonly RULE_unlistenstmt = 412; - public static readonly RULE_transactionstmt = 413; - public static readonly RULE_opt_transaction = 414; - public static readonly RULE_transaction_mode_item = 415; - public static readonly RULE_transaction_mode_list = 416; - public static readonly RULE_transaction_mode_list_or_empty = 417; - public static readonly RULE_opt_transaction_chain = 418; - public static readonly RULE_viewstmt = 419; - public static readonly RULE_opt_check_option = 420; - public static readonly RULE_loadstmt = 421; - public static readonly RULE_createdbstmt = 422; - public static readonly RULE_createdb_opt_list = 423; - public static readonly RULE_createdb_opt_items = 424; - public static readonly RULE_createdb_opt_item = 425; - public static readonly RULE_createdb_opt_name = 426; - public static readonly RULE_opt_equal = 427; - public static readonly RULE_alterdatabasestmt = 428; - public static readonly RULE_alterdatabasesetstmt = 429; - public static readonly RULE_drop_option_list = 430; - public static readonly RULE_drop_option = 431; - public static readonly RULE_altercollationstmt = 432; - public static readonly RULE_altersystemstmt = 433; - public static readonly RULE_createdomainstmt = 434; - public static readonly RULE_alterdomainstmt = 435; - public static readonly RULE_opt_as = 436; - public static readonly RULE_altertsdictionarystmt = 437; - public static readonly RULE_altertsconfigurationstmt = 438; - public static readonly RULE_any_with = 439; - public static readonly RULE_createconversionstmt = 440; - public static readonly RULE_clusterstmt = 441; - public static readonly RULE_opt_verbose_list = 442; - public static readonly RULE_cluster_index_specification = 443; - public static readonly RULE_vacuumstmt = 444; - public static readonly RULE_analyzestmt = 445; - public static readonly RULE_vac_analyze_option_list = 446; - public static readonly RULE_analyze_keyword = 447; - public static readonly RULE_vac_analyze_option_elem = 448; - public static readonly RULE_vac_analyze_option_name = 449; - public static readonly RULE_vac_analyze_option_arg = 450; - public static readonly RULE_opt_analyze = 451; - public static readonly RULE_analyze_options_list = 452; - public static readonly RULE_analyze_option_elem = 453; - public static readonly RULE_opt_verbose = 454; - public static readonly RULE_opt_skiplock = 455; - public static readonly RULE_opt_buffer_usage_limit = 456; - public static readonly RULE_opt_full = 457; - public static readonly RULE_opt_freeze = 458; - public static readonly RULE_opt_name_list = 459; - public static readonly RULE_vacuum_relation = 460; - public static readonly RULE_vacuum_relation_list = 461; - public static readonly RULE_opt_vacuum_relation_list = 462; - public static readonly RULE_explainstmt = 463; - public static readonly RULE_explainablestmt = 464; - public static readonly RULE_explain_option_list = 465; - public static readonly RULE_explain_option_elem = 466; - public static readonly RULE_explain_option_name = 467; - public static readonly RULE_explain_option_arg = 468; - public static readonly RULE_preparestmt = 469; - public static readonly RULE_prep_type_clause = 470; - public static readonly RULE_preparablestmt = 471; - public static readonly RULE_executestmt = 472; - public static readonly RULE_execute_param_clause = 473; - public static readonly RULE_deallocatestmt = 474; - public static readonly RULE_insertstmt = 475; - public static readonly RULE_insert_target = 476; - public static readonly RULE_insert_rest = 477; - public static readonly RULE_override_kind = 478; - public static readonly RULE_insert_column_list = 479; - public static readonly RULE_insert_column_item = 480; - public static readonly RULE_opt_on_conflict = 481; - public static readonly RULE_opt_conf_expr = 482; - public static readonly RULE_returning_clause = 483; - public static readonly RULE_deletestmt = 484; - public static readonly RULE_using_clause = 485; - public static readonly RULE_lockstmt = 486; - public static readonly RULE_opt_lock = 487; - public static readonly RULE_lock_type = 488; - public static readonly RULE_opt_nowait = 489; - public static readonly RULE_opt_nowait_or_skip = 490; - public static readonly RULE_updatestmt = 491; - public static readonly RULE_set_clause_list = 492; - public static readonly RULE_set_clause = 493; - public static readonly RULE_set_target = 494; - public static readonly RULE_set_target_list = 495; - public static readonly RULE_declarecursorstmt = 496; - public static readonly RULE_cursor_name = 497; - public static readonly RULE_cursor_options = 498; - public static readonly RULE_opt_hold = 499; - public static readonly RULE_selectstmt = 500; - public static readonly RULE_select_with_parens = 501; - public static readonly RULE_select_no_parens = 502; - public static readonly RULE_select_clause = 503; - public static readonly RULE_simple_select = 504; - public static readonly RULE_set_operator = 505; - public static readonly RULE_set_operator_with_all_or_distinct = 506; - public static readonly RULE_with_clause = 507; - public static readonly RULE_cte_list = 508; - public static readonly RULE_common_table_expr = 509; - public static readonly RULE_search_cluase = 510; - public static readonly RULE_cycle_cluase = 511; - public static readonly RULE_opt_materialized = 512; - public static readonly RULE_opt_with_clause = 513; - public static readonly RULE_into_clause = 514; - public static readonly RULE_opt_strict = 515; - public static readonly RULE_opttempTableName = 516; - public static readonly RULE_opt_table = 517; - public static readonly RULE_all_or_distinct = 518; - public static readonly RULE_distinct_clause = 519; - public static readonly RULE_opt_all_clause = 520; - public static readonly RULE_opt_sort_clause = 521; - public static readonly RULE_sort_clause = 522; - public static readonly RULE_sortby_list = 523; - public static readonly RULE_sortby = 524; - public static readonly RULE_select_limit = 525; - public static readonly RULE_opt_select_limit = 526; - public static readonly RULE_limit_clause = 527; - public static readonly RULE_fetch_clause = 528; - public static readonly RULE_offset_clause = 529; - public static readonly RULE_select_limit_value = 530; - public static readonly RULE_select_offset_value = 531; - public static readonly RULE_select_fetch_first_value = 532; - public static readonly RULE_i_or_f_const = 533; - public static readonly RULE_row_or_rows = 534; - public static readonly RULE_first_or_next = 535; - public static readonly RULE_group_clause = 536; - public static readonly RULE_group_by_list = 537; - public static readonly RULE_group_by_item = 538; - public static readonly RULE_empty_grouping_set = 539; - public static readonly RULE_rollup_clause = 540; - public static readonly RULE_cube_clause = 541; - public static readonly RULE_grouping_sets_clause = 542; - public static readonly RULE_having_clause = 543; - public static readonly RULE_for_locking_clause = 544; - public static readonly RULE_opt_for_locking_clause = 545; - public static readonly RULE_for_locking_items = 546; - public static readonly RULE_for_locking_item = 547; - public static readonly RULE_for_locking_strength = 548; - public static readonly RULE_locked_rels_list = 549; - public static readonly RULE_values_clause = 550; - public static readonly RULE_from_clause = 551; - public static readonly RULE_from_list = 552; - public static readonly RULE_table_ref = 553; - public static readonly RULE_alias_clause = 554; - public static readonly RULE_opt_alias_clause = 555; - public static readonly RULE_func_alias_clause = 556; - public static readonly RULE_join_type = 557; - public static readonly RULE_join_qual = 558; - public static readonly RULE_relation_expr = 559; - public static readonly RULE_view_relation_expr = 560; - public static readonly RULE_publication_relation_expr = 561; - public static readonly RULE_relation_expr_list = 562; - public static readonly RULE_publication_relation_expr_list = 563; - public static readonly RULE_relation_expr_opt_alias = 564; - public static readonly RULE_tablesample_clause = 565; - public static readonly RULE_opt_repeatable_clause = 566; - public static readonly RULE_func_table = 567; - public static readonly RULE_rowsfrom_item = 568; - public static readonly RULE_rowsfrom_list = 569; - public static readonly RULE_opt_col_def_list = 570; - public static readonly RULE_opt_ordinality = 571; - public static readonly RULE_where_clause = 572; - public static readonly RULE_where_or_current_clause = 573; - public static readonly RULE_opttablefuncelementlist = 574; - public static readonly RULE_tablefuncelementlist = 575; - public static readonly RULE_tablefuncelement = 576; - public static readonly RULE_xmltable = 577; - public static readonly RULE_xmltable_column_list = 578; - public static readonly RULE_xmltable_column_el = 579; - public static readonly RULE_xmltable_column_option_list = 580; - public static readonly RULE_xmltable_column_option_el = 581; - public static readonly RULE_xml_namespace_list = 582; - public static readonly RULE_xml_namespace_el = 583; - public static readonly RULE_typename = 584; - public static readonly RULE_opt_array_bounds = 585; - public static readonly RULE_simpletypename = 586; - public static readonly RULE_consttypename = 587; - public static readonly RULE_generictype = 588; - public static readonly RULE_opt_type_modifiers = 589; - public static readonly RULE_numeric = 590; - public static readonly RULE_opt_float = 591; - public static readonly RULE_bit = 592; - public static readonly RULE_constbit = 593; - public static readonly RULE_bitwithlength = 594; - public static readonly RULE_bitwithoutlength = 595; - public static readonly RULE_character = 596; - public static readonly RULE_constcharacter = 597; - public static readonly RULE_character_c = 598; - public static readonly RULE_opt_varying = 599; - public static readonly RULE_constdatetime = 600; - public static readonly RULE_constinterval = 601; - public static readonly RULE_opt_timezone = 602; - public static readonly RULE_opt_interval = 603; - public static readonly RULE_interval_second = 604; - public static readonly RULE_opt_escape = 605; - public static readonly RULE_a_expr = 606; - public static readonly RULE_a_expr_qual = 607; - public static readonly RULE_a_expr_lessless = 608; - public static readonly RULE_a_expr_or = 609; - public static readonly RULE_a_expr_and = 610; - public static readonly RULE_a_expr_in = 611; - public static readonly RULE_a_expr_unary_not = 612; - public static readonly RULE_a_expr_isnull = 613; - public static readonly RULE_a_expr_is_not = 614; - public static readonly RULE_a_expr_compare = 615; - public static readonly RULE_a_expr_like = 616; - public static readonly RULE_a_expr_qual_op = 617; - public static readonly RULE_a_expr_unary_qualop = 618; - public static readonly RULE_a_expr_add = 619; - public static readonly RULE_a_expr_mul = 620; - public static readonly RULE_a_expr_caret = 621; - public static readonly RULE_a_expr_unary_sign = 622; - public static readonly RULE_a_expr_at_time_zone = 623; - public static readonly RULE_a_expr_collate = 624; - public static readonly RULE_a_expr_typecast = 625; - public static readonly RULE_b_expr = 626; - public static readonly RULE_c_expr = 627; - public static readonly RULE_plsqlvariablename = 628; - public static readonly RULE_func_application = 629; - public static readonly RULE_func_expr = 630; - public static readonly RULE_func_expr_windowless = 631; - public static readonly RULE_func_expr_common_subexpr = 632; - public static readonly RULE_xml_root_version = 633; - public static readonly RULE_opt_xml_root_standalone = 634; - public static readonly RULE_xml_attributes = 635; - public static readonly RULE_xml_attribute_list = 636; - public static readonly RULE_xml_attribute_el = 637; - public static readonly RULE_document_or_content = 638; - public static readonly RULE_xml_whitespace_option = 639; - public static readonly RULE_xmlexists_argument = 640; - public static readonly RULE_xml_passing_mech = 641; - public static readonly RULE_within_group_clause = 642; - public static readonly RULE_filter_clause = 643; - public static readonly RULE_window_clause = 644; - public static readonly RULE_window_definition_list = 645; - public static readonly RULE_window_definition = 646; - public static readonly RULE_over_clause = 647; - public static readonly RULE_window_specification = 648; - public static readonly RULE_opt_existing_window_name = 649; - public static readonly RULE_opt_partition_clause = 650; - public static readonly RULE_opt_frame_clause = 651; - public static readonly RULE_frame_extent = 652; - public static readonly RULE_frame_bound = 653; - public static readonly RULE_opt_window_exclusion_clause = 654; - public static readonly RULE_row = 655; - public static readonly RULE_explicit_row = 656; - public static readonly RULE_implicit_row = 657; - public static readonly RULE_sub_type = 658; - public static readonly RULE_all_op = 659; - public static readonly RULE_mathop = 660; - public static readonly RULE_qual_op = 661; - public static readonly RULE_qual_all_op = 662; - public static readonly RULE_subquery_Op = 663; - public static readonly RULE_expr_list = 664; - public static readonly RULE_column_expr_list_noparen = 665; - public static readonly RULE_column_expr_list = 666; - public static readonly RULE_column_expr = 667; - public static readonly RULE_column_expr_noparen = 668; - public static readonly RULE_func_arg_list = 669; - public static readonly RULE_func_arg_expr = 670; - public static readonly RULE_type_list = 671; - public static readonly RULE_array_expr = 672; - public static readonly RULE_array_expr_list = 673; - public static readonly RULE_extract_list = 674; - public static readonly RULE_extract_arg = 675; - public static readonly RULE_unicode_normal_form = 676; - public static readonly RULE_overlay_list = 677; - public static readonly RULE_position_list = 678; - public static readonly RULE_substr_list = 679; - public static readonly RULE_trim_list = 680; - public static readonly RULE_in_expr = 681; - public static readonly RULE_case_expr = 682; - public static readonly RULE_when_clause_list = 683; - public static readonly RULE_when_clause = 684; - public static readonly RULE_case_default = 685; - public static readonly RULE_case_arg = 686; - public static readonly RULE_columnref = 687; - public static readonly RULE_indirection_el = 688; - public static readonly RULE_opt_slice_bound = 689; - public static readonly RULE_indirection = 690; - public static readonly RULE_opt_indirection = 691; - public static readonly RULE_opt_target_list = 692; - public static readonly RULE_target_list = 693; - public static readonly RULE_target_el = 694; - public static readonly RULE_qualified_name_list = 695; - public static readonly RULE_table_name_list = 696; - public static readonly RULE_schema_name_list = 697; - public static readonly RULE_database_nameList = 698; - public static readonly RULE_procedure_name_list = 699; - public static readonly RULE_tablespace_name_create = 700; - public static readonly RULE_tablespace_name = 701; - public static readonly RULE_table_name_create = 702; - public static readonly RULE_table_name = 703; - public static readonly RULE_view_name_create = 704; - public static readonly RULE_view_name = 705; - public static readonly RULE_qualified_name = 706; - public static readonly RULE_tablespace_name_list = 707; - public static readonly RULE_name_list = 708; - public static readonly RULE_database_name_create = 709; - public static readonly RULE_database_name = 710; - public static readonly RULE_schema_name = 711; - public static readonly RULE_routine_name_create = 712; - public static readonly RULE_routine_name = 713; - public static readonly RULE_procedure_name = 714; - public static readonly RULE_procedure_name_create = 715; - public static readonly RULE_column_name = 716; - public static readonly RULE_column_name_create = 717; - public static readonly RULE_name = 718; - public static readonly RULE_attr_name = 719; - public static readonly RULE_file_name = 720; - public static readonly RULE_function_name_create = 721; - public static readonly RULE_function_name = 722; - public static readonly RULE_usual_name = 723; - public static readonly RULE_aexprconst = 724; - public static readonly RULE_xconst = 725; - public static readonly RULE_bconst = 726; - public static readonly RULE_fconst = 727; - public static readonly RULE_iconst = 728; - public static readonly RULE_sconst = 729; - public static readonly RULE_anysconst = 730; - public static readonly RULE_opt_uescape = 731; - public static readonly RULE_signediconst = 732; - public static readonly RULE_groupname = 733; - public static readonly RULE_roleid = 734; - public static readonly RULE_rolespec = 735; - public static readonly RULE_role_list = 736; - public static readonly RULE_colid = 737; - public static readonly RULE_index_method_choices = 738; - public static readonly RULE_exclude_element = 739; - public static readonly RULE_index_paramenters = 740; - public static readonly RULE_type_function_name = 741; - public static readonly RULE_type_usual_name = 742; - public static readonly RULE_nonreservedword_column = 743; - public static readonly RULE_nonreservedword = 744; - public static readonly RULE_collabel = 745; - public static readonly RULE_identifier = 746; - public static readonly RULE_plsqlidentifier = 747; - public static readonly RULE_unreserved_keyword = 748; - public static readonly RULE_col_name_keyword = 749; - public static readonly RULE_type_func_name_keyword = 750; - public static readonly RULE_reserved_keyword = 751; - public static readonly RULE_pl_function = 752; - public static readonly RULE_comp_options = 753; - public static readonly RULE_comp_option = 754; - public static readonly RULE_sharp = 755; - public static readonly RULE_option_value = 756; - public static readonly RULE_opt_semi = 757; - public static readonly RULE_pl_block = 758; - public static readonly RULE_decl_sect = 759; - public static readonly RULE_decl_start = 760; - public static readonly RULE_decl_stmts = 761; - public static readonly RULE_label_decl = 762; - public static readonly RULE_decl_stmt = 763; - public static readonly RULE_decl_statement = 764; - public static readonly RULE_opt_scrollable = 765; - public static readonly RULE_decl_cursor_query = 766; - public static readonly RULE_decl_cursor_args = 767; - public static readonly RULE_decl_cursor_arglist = 768; - public static readonly RULE_decl_cursor_arg = 769; - public static readonly RULE_decl_is_for = 770; - public static readonly RULE_decl_aliasitem = 771; - public static readonly RULE_decl_varname = 772; - public static readonly RULE_decl_const = 773; - public static readonly RULE_decl_datatype = 774; - public static readonly RULE_decl_collate = 775; - public static readonly RULE_decl_notnull = 776; - public static readonly RULE_decl_defval = 777; - public static readonly RULE_decl_defkey = 778; - public static readonly RULE_assign_operator = 779; - public static readonly RULE_proc_sect = 780; - public static readonly RULE_proc_stmt = 781; - public static readonly RULE_stmt_perform = 782; - public static readonly RULE_stmt_call = 783; - public static readonly RULE_opt_expr_list = 784; - public static readonly RULE_stmt_assign = 785; - public static readonly RULE_stmt_getdiag = 786; - public static readonly RULE_getdiag_area_opt = 787; - public static readonly RULE_getdiag_list = 788; - public static readonly RULE_getdiag_list_item = 789; - public static readonly RULE_getdiag_item = 790; - public static readonly RULE_getdiag_target = 791; - public static readonly RULE_assign_var = 792; - public static readonly RULE_stmt_if = 793; - public static readonly RULE_stmt_elsifs = 794; - public static readonly RULE_stmt_else = 795; - public static readonly RULE_stmt_case = 796; - public static readonly RULE_opt_expr_until_when = 797; - public static readonly RULE_case_when_list = 798; - public static readonly RULE_case_when = 799; - public static readonly RULE_opt_case_else = 800; - public static readonly RULE_stmt_loop = 801; - public static readonly RULE_stmt_while = 802; - public static readonly RULE_stmt_for = 803; - public static readonly RULE_for_control = 804; - public static readonly RULE_opt_for_using_expression = 805; - public static readonly RULE_opt_cursor_parameters = 806; - public static readonly RULE_opt_reverse = 807; - public static readonly RULE_opt_by_expression = 808; - public static readonly RULE_for_variable = 809; - public static readonly RULE_stmt_foreach_a = 810; - public static readonly RULE_foreach_slice = 811; - public static readonly RULE_stmt_exit = 812; - public static readonly RULE_exit_type = 813; - public static readonly RULE_stmt_return = 814; - public static readonly RULE_opt_return_result = 815; - public static readonly RULE_stmt_raise = 816; - public static readonly RULE_opt_stmt_raise_level = 817; - public static readonly RULE_opt_raise_list = 818; - public static readonly RULE_opt_raise_using = 819; - public static readonly RULE_opt_raise_using_elem = 820; - public static readonly RULE_opt_raise_using_elem_list = 821; - public static readonly RULE_stmt_assert = 822; - public static readonly RULE_opt_stmt_assert_message = 823; - public static readonly RULE_loop_body = 824; - public static readonly RULE_stmt_execsql = 825; - public static readonly RULE_stmt_dynexecute = 826; - public static readonly RULE_opt_execute_using = 827; - public static readonly RULE_opt_execute_using_list = 828; - public static readonly RULE_opt_execute_into = 829; - public static readonly RULE_stmt_open = 830; - public static readonly RULE_opt_open_bound_list_item = 831; - public static readonly RULE_opt_open_bound_list = 832; - public static readonly RULE_opt_open_using = 833; - public static readonly RULE_opt_scroll_option = 834; - public static readonly RULE_opt_scroll_option_no = 835; - public static readonly RULE_stmt_fetch = 836; - public static readonly RULE_into_target = 837; - public static readonly RULE_opt_cursor_from = 838; - public static readonly RULE_opt_fetch_direction = 839; - public static readonly RULE_stmt_move = 840; - public static readonly RULE_mergestmt = 841; - public static readonly RULE_data_source = 842; - public static readonly RULE_join_condition = 843; - public static readonly RULE_merge_when_clause = 844; - public static readonly RULE_merge_insert = 845; - public static readonly RULE_merge_update = 846; - public static readonly RULE_default_values_or_values = 847; - public static readonly RULE_exprofdefaultlist = 848; - public static readonly RULE_exprofdefault = 849; - public static readonly RULE_stmt_close = 850; - public static readonly RULE_stmt_null = 851; - public static readonly RULE_stmt_commit = 852; - public static readonly RULE_stmt_rollback = 853; - public static readonly RULE_plsql_opt_transaction_chain = 854; - public static readonly RULE_stmt_set = 855; - public static readonly RULE_cursor_variable = 856; - public static readonly RULE_exception_sect = 857; - public static readonly RULE_proc_exceptions = 858; - public static readonly RULE_proc_exception = 859; - public static readonly RULE_proc_conditions = 860; - public static readonly RULE_proc_condition = 861; - public static readonly RULE_opt_block_label = 862; - public static readonly RULE_opt_loop_label = 863; - public static readonly RULE_opt_label = 864; - public static readonly RULE_opt_exitcond = 865; - public static readonly RULE_any_identifier = 866; - public static readonly RULE_plsql_unreserved_keyword = 867; - public static readonly RULE_sql_expression = 868; - public static readonly RULE_expr_until_then = 869; - public static readonly RULE_expr_until_semi = 870; - public static readonly RULE_expr_until_rightbracket = 871; - public static readonly RULE_expr_until_loop = 872; - public static readonly RULE_make_execsql_stmt = 873; - public static readonly RULE_opt_returning_clause_into = 874; + public static readonly RULE_singleStmt = 1; + public static readonly RULE_stmt = 2; + public static readonly RULE_callstmt = 3; + public static readonly RULE_createrolestmt = 4; + public static readonly RULE_alteroptroleelem = 5; + public static readonly RULE_createoptroleelem = 6; + public static readonly RULE_createuserstmt = 7; + public static readonly RULE_alterrolestmt = 8; + public static readonly RULE_alterrolesetstmt = 9; + public static readonly RULE_alterroutinestmt = 10; + public static readonly RULE_alter_routine_cluase = 11; + public static readonly RULE_routine_action = 12; + public static readonly RULE_creategroupstmt = 13; + public static readonly RULE_altergroupstmt = 14; + public static readonly RULE_createschemastmt = 15; + public static readonly RULE_schema_name_create = 16; + public static readonly RULE_schema_stmt = 17; + public static readonly RULE_variablesetstmt = 18; + public static readonly RULE_set_rest = 19; + public static readonly RULE_generic_set = 20; + public static readonly RULE_set_rest_more = 21; + public static readonly RULE_var_name = 22; + public static readonly RULE_var_list = 23; + public static readonly RULE_var_value = 24; + public static readonly RULE_iso_level = 25; + public static readonly RULE_opt_boolean_or_string_column = 26; + public static readonly RULE_opt_boolean_or_string = 27; + public static readonly RULE_zone_value = 28; + public static readonly RULE_nonreservedword_or_sconst = 29; + public static readonly RULE_variableresetstmt = 30; + public static readonly RULE_reset_rest = 31; + public static readonly RULE_setresetclause = 32; + public static readonly RULE_functionsetresetclause = 33; + public static readonly RULE_variableshowstmt = 34; + public static readonly RULE_constraintssetstmt = 35; + public static readonly RULE_checkpointstmt = 36; + public static readonly RULE_discardstmt = 37; + public static readonly RULE_altertablestmt = 38; + public static readonly RULE_alter_table_cmds = 39; + public static readonly RULE_partition_bound_spec = 40; + public static readonly RULE_partition_bound_cluase = 41; + public static readonly RULE_partition_bound_choose = 42; + public static readonly RULE_partition_with_cluase = 43; + public static readonly RULE_partition_cmd = 44; + public static readonly RULE_index_partition_cmd = 45; + public static readonly RULE_alter_table_cmd = 46; + public static readonly RULE_alter_column_default = 47; + public static readonly RULE_opt_drop_behavior = 48; + public static readonly RULE_opt_collate_clause = 49; + public static readonly RULE_reloptions = 50; + public static readonly RULE_opt_reloptions = 51; + public static readonly RULE_reloption_elem = 52; + public static readonly RULE_partitionboundspec = 53; + public static readonly RULE_altercompositetypestmt = 54; + public static readonly RULE_alter_type_cmd = 55; + public static readonly RULE_closeportalstmt = 56; + public static readonly RULE_copystmt = 57; + public static readonly RULE_copy_options = 58; + public static readonly RULE_copy_generic_opt_elem = 59; + public static readonly RULE_createstmt = 60; + public static readonly RULE_opttemp = 61; + public static readonly RULE_opttypedtableelementlist = 62; + public static readonly RULE_tableelementlist = 63; + public static readonly RULE_tableelement = 64; + public static readonly RULE_typedtableelement = 65; + public static readonly RULE_column_def = 66; + public static readonly RULE_colconstraint = 67; + public static readonly RULE_colconstraintelem = 68; + public static readonly RULE_generated_when = 69; + public static readonly RULE_tablelikeoption = 70; + public static readonly RULE_constraintelem = 71; + public static readonly RULE_opt_column_list = 72; + public static readonly RULE_opt_column_list_create = 73; + public static readonly RULE_column_list = 74; + public static readonly RULE_opt_c_include = 75; + public static readonly RULE_key_match = 76; + public static readonly RULE_exclusionconstraintelem = 77; + public static readonly RULE_key_actions = 78; + public static readonly RULE_key_update = 79; + public static readonly RULE_key_delete = 80; + public static readonly RULE_key_action = 81; + public static readonly RULE_optinherit = 82; + public static readonly RULE_partitionspec = 83; + public static readonly RULE_part_elem = 84; + public static readonly RULE_table_access_method_clause = 85; + public static readonly RULE_optwith = 86; + public static readonly RULE_oncommitoption = 87; + public static readonly RULE_opttablespace = 88; + public static readonly RULE_optconstablespace = 89; + public static readonly RULE_existingindex = 90; + public static readonly RULE_createstatsstmt = 91; + public static readonly RULE_alterstatsstmt = 92; + public static readonly RULE_createasstmt = 93; + public static readonly RULE_create_as_target = 94; + public static readonly RULE_opt_with_data = 95; + public static readonly RULE_creatematviewstmt = 96; + public static readonly RULE_refreshmatviewstmt = 97; + public static readonly RULE_createseqstmt = 98; + public static readonly RULE_alterseqstmt = 99; + public static readonly RULE_seqoptelem = 100; + public static readonly RULE_numericonly = 101; + public static readonly RULE_createplangstmt = 102; + public static readonly RULE_createtablespacestmt = 103; + public static readonly RULE_createextensionstmt = 104; + public static readonly RULE_alterextensionstmt = 105; + public static readonly RULE_alterextensioncontentsstmt = 106; + public static readonly RULE_createfdwstmt = 107; + public static readonly RULE_fdw_option = 108; + public static readonly RULE_alterfdwstmt = 109; + public static readonly RULE_create_generic_options = 110; + public static readonly RULE_alter_generic_options = 111; + public static readonly RULE_alter_generic_option_elem = 112; + public static readonly RULE_generic_option_elem = 113; + public static readonly RULE_createforeignserverstmt = 114; + public static readonly RULE_foreign_server_version = 115; + public static readonly RULE_alterforeignserverstmt = 116; + public static readonly RULE_createforeigntablestmt = 117; + public static readonly RULE_importforeignschemastmt = 118; + public static readonly RULE_createusermappingstmt = 119; + public static readonly RULE_alterusermappingstmt = 120; + public static readonly RULE_createpolicystmt = 121; + public static readonly RULE_alterpolicystmt = 122; + public static readonly RULE_alterprocedurestmt = 123; + public static readonly RULE_procedure_action = 124; + public static readonly RULE_rowsecurityoptionalexpr = 125; + public static readonly RULE_rowsecurityoptionalwithcheck = 126; + public static readonly RULE_createamstmt = 127; + public static readonly RULE_createtrigstmt = 128; + public static readonly RULE_triggeractiontime = 129; + public static readonly RULE_triggerevents = 130; + public static readonly RULE_triggeroneevent = 131; + public static readonly RULE_triggerwhen = 132; + public static readonly RULE_function_or_procedure = 133; + public static readonly RULE_triggerfuncargs = 134; + public static readonly RULE_triggerfuncarg = 135; + public static readonly RULE_constraintattributeElem = 136; + public static readonly RULE_createeventtrigstmt = 137; + public static readonly RULE_event_trigger_when_item = 138; + public static readonly RULE_altereventtrigstmt = 139; + public static readonly RULE_createassertionstmt = 140; + public static readonly RULE_definestmt = 141; + public static readonly RULE_definition = 142; + public static readonly RULE_def_elem = 143; + public static readonly RULE_def_arg = 144; + public static readonly RULE_old_aggr_elem = 145; + public static readonly RULE_alterenumstmt = 146; + public static readonly RULE_opt_if_not_exists = 147; + public static readonly RULE_createopclassstmt = 148; + public static readonly RULE_opclass_item = 149; + public static readonly RULE_createopfamilystmt = 150; + public static readonly RULE_alteropfamilystmt = 151; + public static readonly RULE_opclass_drop = 152; + public static readonly RULE_reassignownedstmt = 153; + public static readonly RULE_dropstmt = 154; + public static readonly RULE_object_type_any_name = 155; + public static readonly RULE_object_type_name = 156; + public static readonly RULE_any_name_list = 157; + public static readonly RULE_any_name = 158; + public static readonly RULE_attrs = 159; + public static readonly RULE_truncatestmt = 160; + public static readonly RULE_truncate_table = 161; + public static readonly RULE_commentstmt = 162; + public static readonly RULE_seclabelstmt = 163; + public static readonly RULE_fetchstmt = 164; + public static readonly RULE_fetch_args = 165; + public static readonly RULE_from_in = 166; + public static readonly RULE_grantstmt = 167; + public static readonly RULE_revokestmt = 168; + public static readonly RULE_privileges = 169; + public static readonly RULE_beforeprivilegeselect = 170; + public static readonly RULE_privilege = 171; + public static readonly RULE_privilege_target = 172; + public static readonly RULE_grantee_list = 173; + public static readonly RULE_grantrolestmt = 174; + public static readonly RULE_revokerolestmt = 175; + public static readonly RULE_alterdefaultprivilegesstmt = 176; + public static readonly RULE_defaclaction = 177; + public static readonly RULE_defacl_privilege_target = 178; + public static readonly RULE_indexstmt = 179; + public static readonly RULE_index_params = 180; + public static readonly RULE_index_elem = 181; + public static readonly RULE_createfunctionstmt = 182; + public static readonly RULE_opt_or_replace = 183; + public static readonly RULE_func_args = 184; + public static readonly RULE_func_args_list = 185; + public static readonly RULE_routine_with_argtypes_list = 186; + public static readonly RULE_routine_with_argtypes = 187; + public static readonly RULE_procedure_with_argtypes_list = 188; + public static readonly RULE_procedure_with_argtypes = 189; + public static readonly RULE_function_with_argtypes_list = 190; + public static readonly RULE_function_with_argtypes = 191; + public static readonly RULE_func_arg = 192; + public static readonly RULE_arg_class = 193; + public static readonly RULE_func_type = 194; + public static readonly RULE_func_arg_with_default = 195; + public static readonly RULE_aggr_args = 196; + public static readonly RULE_aggregate_with_argtypes = 197; + public static readonly RULE_common_func_opt_item = 198; + public static readonly RULE_createfunc_opt_item = 199; + public static readonly RULE_opt_definition = 200; + public static readonly RULE_table_func_column = 201; + public static readonly RULE_alterfunctionstmt = 202; + public static readonly RULE_removefuncstmt = 203; + public static readonly RULE_removeaggrstmt = 204; + public static readonly RULE_removeoperstmt = 205; + public static readonly RULE_oper_argtypes = 206; + public static readonly RULE_any_operator = 207; + public static readonly RULE_operator_with_argtypes = 208; + public static readonly RULE_dostmt = 209; + public static readonly RULE_createcaststmt = 210; + public static readonly RULE_opt_if_exists = 211; + public static readonly RULE_createtransformstmt = 212; + public static readonly RULE_sql_with_function = 213; + public static readonly RULE_reindexstmt = 214; + public static readonly RULE_altertblspcstmt = 215; + public static readonly RULE_renamestmt = 216; + public static readonly RULE_alterobjectdependsstmt = 217; + public static readonly RULE_alterobjectschemastmt = 218; + public static readonly RULE_alteroperatorstmt = 219; + public static readonly RULE_operator_def_list = 220; + public static readonly RULE_operator_def_elem = 221; + public static readonly RULE_altertypestmt = 222; + public static readonly RULE_alterownerstmt = 223; + public static readonly RULE_createpublicationstmt = 224; + public static readonly RULE_alterpublicationstmt = 225; + public static readonly RULE_createsubscriptionstmt = 226; + public static readonly RULE_altersubscriptionstmt = 227; + public static readonly RULE_rulestmt = 228; + public static readonly RULE_ruleactionstmt = 229; + public static readonly RULE_notifystmt = 230; + public static readonly RULE_notify_payload = 231; + public static readonly RULE_listenstmt = 232; + public static readonly RULE_unlistenstmt = 233; + public static readonly RULE_transactionstmt = 234; + public static readonly RULE_opt_transaction = 235; + public static readonly RULE_transaction_mode_item = 236; + public static readonly RULE_transaction_mode_list = 237; + public static readonly RULE_viewstmt = 238; + public static readonly RULE_loadstmt = 239; + public static readonly RULE_createdbstmt = 240; + public static readonly RULE_createdb_opt_item = 241; + public static readonly RULE_alterdatabasestmt = 242; + public static readonly RULE_alterdatabasesetstmt = 243; + public static readonly RULE_altercollationstmt = 244; + public static readonly RULE_altersystemstmt = 245; + public static readonly RULE_createdomainstmt = 246; + public static readonly RULE_alterdomainstmt = 247; + public static readonly RULE_altertsdictionarystmt = 248; + public static readonly RULE_altertsconfigurationstmt = 249; + public static readonly RULE_createconversionstmt = 250; + public static readonly RULE_clusterstmt = 251; + public static readonly RULE_vacuumstmt = 252; + public static readonly RULE_analyzestmt = 253; + public static readonly RULE_analyze_keyword = 254; + public static readonly RULE_vac_analyze_option_elem = 255; + public static readonly RULE_analyze_option_elem = 256; + public static readonly RULE_opt_verbose = 257; + public static readonly RULE_vacuum_relation = 258; + public static readonly RULE_vacuum_relation_list = 259; + public static readonly RULE_explainstmt = 260; + public static readonly RULE_explainablestmt = 261; + public static readonly RULE_explain_option_list = 262; + public static readonly RULE_preparestmt = 263; + public static readonly RULE_prep_type_clause = 264; + public static readonly RULE_preparablestmt = 265; + public static readonly RULE_executestmt = 266; + public static readonly RULE_execute_param_clause = 267; + public static readonly RULE_deallocatestmt = 268; + public static readonly RULE_insertstmt = 269; + public static readonly RULE_insert_rest = 270; + public static readonly RULE_insert_column_list = 271; + public static readonly RULE_insert_column_item = 272; + public static readonly RULE_returning_clause = 273; + public static readonly RULE_deletestmt = 274; + public static readonly RULE_lockstmt = 275; + public static readonly RULE_updatestmt = 276; + public static readonly RULE_set_clause_list = 277; + public static readonly RULE_set_clause = 278; + public static readonly RULE_declarecursorstmt = 279; + public static readonly RULE_selectstmt = 280; + public static readonly RULE_select_with_parens = 281; + public static readonly RULE_select_no_parens = 282; + public static readonly RULE_select_clause = 283; + public static readonly RULE_simple_select = 284; + public static readonly RULE_set_operator_with_all_or_distinct = 285; + public static readonly RULE_with_clause = 286; + public static readonly RULE_common_table_expr = 287; + public static readonly RULE_search_cluase = 288; + public static readonly RULE_cycle_cluase = 289; + public static readonly RULE_into_clause = 290; + public static readonly RULE_opttempTableName = 291; + public static readonly RULE_distinct_clause = 292; + public static readonly RULE_sort_clause = 293; + public static readonly RULE_sortby = 294; + public static readonly RULE_select_limit = 295; + public static readonly RULE_limit_clause = 296; + public static readonly RULE_fetch_clause = 297; + public static readonly RULE_offset_clause = 298; + public static readonly RULE_select_fetch_first_value = 299; + public static readonly RULE_group_clause = 300; + public static readonly RULE_group_by_list = 301; + public static readonly RULE_group_by_item = 302; + public static readonly RULE_for_locking_clause = 303; + public static readonly RULE_values_clause = 304; + public static readonly RULE_from_clause = 305; + public static readonly RULE_from_list = 306; + public static readonly RULE_table_ref = 307; + public static readonly RULE_alias_clause = 308; + public static readonly RULE_func_alias_clause = 309; + public static readonly RULE_join_type = 310; + public static readonly RULE_join_qual = 311; + public static readonly RULE_relation_expr = 312; + public static readonly RULE_publication_relation_expr = 313; + public static readonly RULE_relation_expr_list = 314; + public static readonly RULE_relation_expr_opt_alias = 315; + public static readonly RULE_tablesample_clause = 316; + public static readonly RULE_func_table = 317; + public static readonly RULE_rowsfrom_item = 318; + public static readonly RULE_where_clause = 319; + public static readonly RULE_where_or_current_clause = 320; + public static readonly RULE_tablefuncelementlist = 321; + public static readonly RULE_tablefuncelement = 322; + public static readonly RULE_xmltable = 323; + public static readonly RULE_xmltable_column_el = 324; + public static readonly RULE_xml_namespace_el = 325; + public static readonly RULE_typename = 326; + public static readonly RULE_simpletypename = 327; + public static readonly RULE_consttypename = 328; + public static readonly RULE_numeric = 329; + public static readonly RULE_opt_float = 330; + public static readonly RULE_bit = 331; + public static readonly RULE_character = 332; + public static readonly RULE_constdatetime = 333; + public static readonly RULE_opt_interval = 334; + public static readonly RULE_interval_second = 335; + public static readonly RULE_comparisonOperator = 336; + public static readonly RULE_expression = 337; + public static readonly RULE_booleanExpression = 338; + public static readonly RULE_predicate = 339; + public static readonly RULE_valueExpression = 340; + public static readonly RULE_primaryExpression = 341; + public static readonly RULE_func_application = 342; + public static readonly RULE_func_expr = 343; + public static readonly RULE_func_expr_windowless = 344; + public static readonly RULE_func_expr_common_subexpr = 345; + public static readonly RULE_xml_attribute_list = 346; + public static readonly RULE_xml_attribute_el = 347; + public static readonly RULE_document_or_content = 348; + public static readonly RULE_xmlexists_argument = 349; + public static readonly RULE_xml_passing_mech = 350; + public static readonly RULE_window_clause = 351; + public static readonly RULE_window_definition = 352; + public static readonly RULE_over_clause = 353; + public static readonly RULE_window_specification = 354; + public static readonly RULE_opt_frame_clause = 355; + public static readonly RULE_frame_bound = 356; + public static readonly RULE_row = 357; + public static readonly RULE_explicit_row = 358; + public static readonly RULE_sub_type = 359; + public static readonly RULE_all_op = 360; + public static readonly RULE_mathop = 361; + public static readonly RULE_qual_op = 362; + public static readonly RULE_qual_all_op = 363; + public static readonly RULE_subquery_Op = 364; + public static readonly RULE_expr_list = 365; + public static readonly RULE_column_expr = 366; + public static readonly RULE_column_expr_noparen = 367; + public static readonly RULE_func_arg_list = 368; + public static readonly RULE_func_arg_expr = 369; + public static readonly RULE_array_expr = 370; + public static readonly RULE_extract_arg = 371; + public static readonly RULE_unicode_normal_form = 372; + public static readonly RULE_substr_list = 373; + public static readonly RULE_when_clause = 374; + public static readonly RULE_indirection_el = 375; + public static readonly RULE_indirection = 376; + public static readonly RULE_opt_indirection = 377; + public static readonly RULE_target_list = 378; + public static readonly RULE_target_el = 379; + public static readonly RULE_qualified_name_list = 380; + public static readonly RULE_table_name_list = 381; + public static readonly RULE_schema_name_list = 382; + public static readonly RULE_database_nameList = 383; + public static readonly RULE_tablespace_name_create = 384; + public static readonly RULE_tablespace_name = 385; + public static readonly RULE_table_name_create = 386; + public static readonly RULE_table_name = 387; + public static readonly RULE_view_name_create = 388; + public static readonly RULE_view_name = 389; + public static readonly RULE_qualified_name = 390; + public static readonly RULE_tablespace_name_list = 391; + public static readonly RULE_name_list = 392; + public static readonly RULE_database_name_create = 393; + public static readonly RULE_database_name = 394; + public static readonly RULE_schema_name = 395; + public static readonly RULE_routine_name_create = 396; + public static readonly RULE_routine_name = 397; + public static readonly RULE_procedure_name = 398; + public static readonly RULE_procedure_name_create = 399; + public static readonly RULE_column_name = 400; + public static readonly RULE_column_name_create = 401; + public static readonly RULE_function_name_create = 402; + public static readonly RULE_function_name = 403; + public static readonly RULE_sconst = 404; + public static readonly RULE_anysconst = 405; + public static readonly RULE_signediconst = 406; + public static readonly RULE_rolespec = 407; + public static readonly RULE_role_list = 408; + public static readonly RULE_colid = 409; + public static readonly RULE_type_function_name = 410; + public static readonly RULE_nonreservedword = 411; + public static readonly RULE_collabel = 412; + public static readonly RULE_identifier = 413; + public static readonly RULE_unreserved_keyword = 414; + public static readonly RULE_col_name_keyword = 415; + public static readonly RULE_type_func_name_keyword = 416; + public static readonly RULE_reserved_keyword = 417; + public static readonly RULE_pl_block = 418; + public static readonly RULE_label_decl = 419; + public static readonly RULE_decl_statement = 420; + public static readonly RULE_decl_cursor_arg = 421; + public static readonly RULE_assign_operator = 422; + public static readonly RULE_proc_stmt = 423; + public static readonly RULE_stmt_perform = 424; + public static readonly RULE_stmt_call = 425; + public static readonly RULE_stmt_assign = 426; + public static readonly RULE_stmt_getdiag = 427; + public static readonly RULE_getdiag_list_item = 428; + public static readonly RULE_assign_var = 429; + public static readonly RULE_stmt_if = 430; + public static readonly RULE_stmt_else = 431; + public static readonly RULE_stmt_case = 432; + public static readonly RULE_stmt_loop_while_for = 433; + public static readonly RULE_for_control = 434; + public static readonly RULE_stmt_foreach_a = 435; + public static readonly RULE_stmt_exit = 436; + public static readonly RULE_stmt_return = 437; + public static readonly RULE_stmt_raise = 438; + public static readonly RULE_opt_raise_using_elem = 439; + public static readonly RULE_stmt_assert = 440; + public static readonly RULE_loop_body = 441; + public static readonly RULE_stmt_execsql = 442; + public static readonly RULE_stmt_dynexecute = 443; + public static readonly RULE_opt_execute_into = 444; + public static readonly RULE_stmt_open = 445; + public static readonly RULE_opt_open_bound_list_item = 446; + public static readonly RULE_stmt_fetch = 447; + public static readonly RULE_opt_fetch_direction = 448; + public static readonly RULE_stmt_move = 449; + public static readonly RULE_mergestmt = 450; + public static readonly RULE_data_source = 451; + public static readonly RULE_merge_when_clause = 452; + public static readonly RULE_merge_insert = 453; + public static readonly RULE_merge_update = 454; + public static readonly RULE_default_values_or_values = 455; + public static readonly RULE_exprofdefault = 456; + public static readonly RULE_stmt_close = 457; + public static readonly RULE_stmt_null = 458; + public static readonly RULE_stmt_commit_or_rollback = 459; + public static readonly RULE_stmt_set = 460; + public static readonly RULE_cursor_variable = 461; + public static readonly RULE_exception_sect = 462; + public static readonly RULE_proc_condition = 463; + public static readonly RULE_any_identifier = 464; + public static readonly RULE_plsql_unreserved_keyword = 465; + public static readonly RULE_sql_expression = 466; public static readonly literalNames = [ null, "'$'", "'('", "')'", "'['", "']'", "','", "';'", "':'", "'*'", @@ -1712,229 +1304,125 @@ export class PostgreSqlParser extends SQLParserBase { "AfterEscapeStringConstantWithNewlineMode_Continued" ]; public static readonly ruleNames = [ - "program", "plsqlroot", "singleStmt", "stmt", "plsqlconsolecommand", - "callstmt", "createrolestmt", "opt_with", "optrolelist", "alteroptrolelist", - "alteroptroleelem", "createoptroleelem", "createuserstmt", "alterrolestmt", - "opt_in_database", "alterrolesetstmt", "alterroutinestmt", "alter_routine_cluase", - "routine_action_list", "routine_action", "creategroupstmt", "altergroupstmt", - "add_drop", "createschemastmt", "schema_name_create", "optschemaeltlist", - "schema_stmt", "variablesetstmt", "set_rest", "generic_set", "set_rest_more", - "var_name", "var_list", "var_value", "iso_level", "opt_boolean_or_string_column", - "opt_boolean_or_string", "zone_value", "opt_encoding", "nonreservedword_or_sconst_column", - "nonreservedword_or_sconst", "variableresetstmt", "reset_rest", - "generic_reset", "setresetclause", "functionsetresetclause", "variableshowstmt", - "constraintssetstmt", "constraints_set_list", "constraints_set_mode", - "checkpointstmt", "discardstmt", "altertablestmt", "alter_table_cmds", - "partition_bound_spec", "partition_bound_cluase", "partition_bound_choose", - "partition_with_cluase", "partition_cmd", "index_partition_cmd", - "alter_table_cmd", "alter_column_default", "opt_drop_behavior", - "opt_collate_clause", "alter_using", "replica_identity", "reloptions", - "opt_reloptions", "reloption_list", "reloption_elem", "alter_identity_column_option_list", - "alter_identity_column_option", "partitionboundspec", "hash_partbound_elem", - "hash_partbound", "altercompositetypestmt", "alter_type_cmds", "alter_type_cmd", - "closeportalstmt", "copystmt", "copy_from", "opt_program", "copy_file_name", - "copy_options", "copy_opt_list", "copy_opt_item", "opt_binary", - "copy_delimiter", "opt_using", "copy_generic_opt_list", "copy_generic_opt_elem", - "copy_generic_opt_arg", "copy_generic_opt_arg_list", "copy_generic_opt_arg_list_item", - "createstmt", "opttemp", "table_column_list", "opttableelementlist", - "opttypedtableelementlist", "tableelementlist", "typedtableelementlist", - "tableelement", "typedtableelement", "column_def", "compressionCluase", - "storageCluase", "columnOptions", "colquallist", "colconstraint", - "colconstraintelem", "nulls_distinct", "generated_when", "deferrable_trigger", - "initially_trigger", "tablelikeclause", "tablelikeoptionlist", "tablelikeoption", - "tableconstraint", "constraintelem", "opt_no_inherit", "opt_column_list", - "opt_column_list_create", "column_list", "column_list_create", "opt_c_include", - "key_match", "exclusionconstraintlist", "exclusionconstraintelem", - "exclusionwhereclause", "key_actions", "key_update", "key_delete", - "key_action", "optinherit", "optpartitionspec", "partitionspec", - "part_params", "part_elem", "table_access_method_clause", "optwith", - "oncommitoption", "opttablespace", "index_paramenters_create", "optconstablespace", - "existingindex", "createstatsstmt", "alterstatsstmt", "createasstmt", - "create_as_target", "opt_with_data", "creatematviewstmt", "create_mv_target", - "optnolog", "refreshmatviewstmt", "createseqstmt", "alterseqstmt", - "optseqoptlist", "optparenthesizedseqoptlist", "seqoptlist", "seqoptelem", - "opt_by", "numericonly", "numericonly_list", "createplangstmt", - "opt_trusted", "handler_name", "opt_inline_handler", "validator_clause", - "opt_validator", "opt_procedural", "createtablespacestmt", "opttablespaceowner", - "createextensionstmt", "create_extension_opt_list", "create_extension_opt_item", - "alterextensionstmt", "alter_extension_opt_list", "alter_extension_opt_item", - "alterextensioncontentsstmt", "createfdwstmt", "fdw_option", "fdw_options", - "opt_fdw_options", "alterfdwstmt", "create_generic_options", "generic_option_list", - "alter_generic_options", "alter_generic_option_list", "alter_generic_option_elem", - "generic_option_elem", "generic_option_name", "generic_option_arg", - "createforeignserverstmt", "opt_type", "foreign_server_version", - "opt_foreign_server_version", "alterforeignserverstmt", "createforeigntablestmt", - "importforeignschemastmt", "import_qualification_type", "import_qualification", - "createusermappingstmt", "auth_ident", "alterusermappingstmt", "createpolicystmt", - "alterpolicystmt", "alterprocedurestmt", "procedure_cluase", "procedure_action", - "rowsecurityoptionalexpr", "rowsecurityoptionalwithcheck", "rowsecuritydefaulttorole", - "rowsecurityoptionaltorole", "rowsecuritydefaultpermissive", "rowsecuritydefaultforcmd", - "row_security_cmd", "createamstmt", "am_type", "createtrigstmt", - "triggeractiontime", "foreachrow", "roworstatment", "triggerevents", - "triggeroneevent", "triggerreferencing", "triggertransitions", "triggertransition", - "transitionoldornew", "transitionrowortable", "transitionrelname", - "triggerforspec", "triggerforopteach", "triggerfortype", "triggerwhen", - "function_or_procedure", "triggerfuncargs", "triggerfuncarg", "optconstrfromtable", - "constraintattributespec", "constraintattributeElem", "createeventtrigstmt", - "event_trigger_when_list", "event_trigger_when_item", "event_trigger_value_list", - "altereventtrigstmt", "enable_trigger", "createassertionstmt", "definestmt", - "definition", "def_list", "def_elem", "def_arg", "old_aggr_definition", - "old_aggr_list", "old_aggr_elem", "opt_enum_val_list", "enum_val_list", - "alterenumstmt", "opt_if_not_exists", "createopclassstmt", "opclass_item_list", - "opclass_item", "opt_default", "opt_opfamily", "opclass_purpose", - "opt_recheck", "createopfamilystmt", "alteropfamilystmt", "opclass_drop_list", - "opclass_drop", "reassignownedstmt", "dropstmt", "view_nameList", - "object_type_any_name", "object_type_name", "object_type_name_on_any_name", - "any_name_list", "relation_column_name", "relation_name", "any_name", - "attrs", "type_name_list", "truncatestmt", "truncate_table", "commentstmt", - "comment_text", "seclabelstmt", "opt_provider", "security_label", - "fetchstmt", "fetch_args", "from_in", "opt_from_in", "grantstmt", - "revokestmt", "privileges", "beforeprivilegeselectlist", "beforeprivilegeselect", - "privilege_list", "privilege", "privilege_target", "grantee_list", - "grantee", "opt_grant_grant_option", "grantrolestmt", "revokerolestmt", - "opt_grant_admin_option", "opt_granted_by", "alterdefaultprivilegesstmt", - "defacloptionlist", "defacloption", "defaclaction", "defacl_privilege_target", - "indexstmt", "opt_unique", "opt_concurrently", "opt_index_name", - "access_method_clause", "index_params", "index_elem_options", "index_elem", - "opt_include", "index_including_params", "opt_collate", "opt_class", - "opt_asc_desc", "opt_nulls_order", "createfunctionstmt", "attrilist", + "program", "singleStmt", "stmt", "callstmt", "createrolestmt", "alteroptroleelem", + "createoptroleelem", "createuserstmt", "alterrolestmt", "alterrolesetstmt", + "alterroutinestmt", "alter_routine_cluase", "routine_action", "creategroupstmt", + "altergroupstmt", "createschemastmt", "schema_name_create", "schema_stmt", + "variablesetstmt", "set_rest", "generic_set", "set_rest_more", "var_name", + "var_list", "var_value", "iso_level", "opt_boolean_or_string_column", + "opt_boolean_or_string", "zone_value", "nonreservedword_or_sconst", + "variableresetstmt", "reset_rest", "setresetclause", "functionsetresetclause", + "variableshowstmt", "constraintssetstmt", "checkpointstmt", "discardstmt", + "altertablestmt", "alter_table_cmds", "partition_bound_spec", "partition_bound_cluase", + "partition_bound_choose", "partition_with_cluase", "partition_cmd", + "index_partition_cmd", "alter_table_cmd", "alter_column_default", + "opt_drop_behavior", "opt_collate_clause", "reloptions", "opt_reloptions", + "reloption_elem", "partitionboundspec", "altercompositetypestmt", + "alter_type_cmd", "closeportalstmt", "copystmt", "copy_options", + "copy_generic_opt_elem", "createstmt", "opttemp", "opttypedtableelementlist", + "tableelementlist", "tableelement", "typedtableelement", "column_def", + "colconstraint", "colconstraintelem", "generated_when", "tablelikeoption", + "constraintelem", "opt_column_list", "opt_column_list_create", "column_list", + "opt_c_include", "key_match", "exclusionconstraintelem", "key_actions", + "key_update", "key_delete", "key_action", "optinherit", "partitionspec", + "part_elem", "table_access_method_clause", "optwith", "oncommitoption", + "opttablespace", "optconstablespace", "existingindex", "createstatsstmt", + "alterstatsstmt", "createasstmt", "create_as_target", "opt_with_data", + "creatematviewstmt", "refreshmatviewstmt", "createseqstmt", "alterseqstmt", + "seqoptelem", "numericonly", "createplangstmt", "createtablespacestmt", + "createextensionstmt", "alterextensionstmt", "alterextensioncontentsstmt", + "createfdwstmt", "fdw_option", "alterfdwstmt", "create_generic_options", + "alter_generic_options", "alter_generic_option_elem", "generic_option_elem", + "createforeignserverstmt", "foreign_server_version", "alterforeignserverstmt", + "createforeigntablestmt", "importforeignschemastmt", "createusermappingstmt", + "alterusermappingstmt", "createpolicystmt", "alterpolicystmt", "alterprocedurestmt", + "procedure_action", "rowsecurityoptionalexpr", "rowsecurityoptionalwithcheck", + "createamstmt", "createtrigstmt", "triggeractiontime", "triggerevents", + "triggeroneevent", "triggerwhen", "function_or_procedure", "triggerfuncargs", + "triggerfuncarg", "constraintattributeElem", "createeventtrigstmt", + "event_trigger_when_item", "altereventtrigstmt", "createassertionstmt", + "definestmt", "definition", "def_elem", "def_arg", "old_aggr_elem", + "alterenumstmt", "opt_if_not_exists", "createopclassstmt", "opclass_item", + "createopfamilystmt", "alteropfamilystmt", "opclass_drop", "reassignownedstmt", + "dropstmt", "object_type_any_name", "object_type_name", "any_name_list", + "any_name", "attrs", "truncatestmt", "truncate_table", "commentstmt", + "seclabelstmt", "fetchstmt", "fetch_args", "from_in", "grantstmt", + "revokestmt", "privileges", "beforeprivilegeselect", "privilege", + "privilege_target", "grantee_list", "grantrolestmt", "revokerolestmt", + "alterdefaultprivilegesstmt", "defaclaction", "defacl_privilege_target", + "indexstmt", "index_params", "index_elem", "createfunctionstmt", "opt_or_replace", "func_args", "func_args_list", "routine_with_argtypes_list", "routine_with_argtypes", "procedure_with_argtypes_list", "procedure_with_argtypes", - "function_with_argtypes_list", "function_with_argtypes", "func_args_with_defaults", - "func_args_with_defaults_list", "func_arg", "arg_class", "param_name", - "func_return", "func_type", "func_arg_with_default", "aggr_arg", - "aggr_args", "aggr_args_list", "aggregate_with_argtypes", "aggregate_with_argtypes_list", - "createfunc_opt_list", "common_func_opt_item", "createfunc_opt_item", - "transform_type_list", "opt_definition", "table_func_column", "table_func_column_list", - "alterfunctionstmt", "alterFunctionTypeClause", "alterfunc_opt_list", - "opt_restrict", "removefuncstmt", "removeaggrstmt", "removeoperstmt", - "oper_argtypes", "any_operator", "operator_with_argtypes_list", - "operator_with_argtypes", "dostmt", "dostmt_opt_list", "dostmt_opt_item", - "createcaststmt", "cast_context", "opt_if_exists", "createtransformstmt", - "transform_element_list", "reindexstmt", "reindex_target_type", - "reindex_target_multitable", "reindex_option_list", "reindex_option_elem", - "altertblspcstmt", "renamestmt", "opt_set_data", "alterobjectdependsstmt", - "opt_no", "alterobjectschemastmt", "alteroperatorstmt", "operator_def_list", - "operator_def_elem", "operator_def_arg", "altertypestmt", "alterownerstmt", - "createpublicationstmt", "opt_publication_for_tables", "publication_for_tables", - "alterpublicationstmt", "createsubscriptionstmt", "publication_name_list", - "publication_name_item", "altersubscriptionstmt", "rulestmt", "ruleactionlist", - "ruleactionmulti", "ruleactionstmt", "ruleactionstmtOrEmpty", "event", - "opt_instead", "notifystmt", "notify_payload", "listenstmt", "unlistenstmt", - "transactionstmt", "opt_transaction", "transaction_mode_item", "transaction_mode_list", - "transaction_mode_list_or_empty", "opt_transaction_chain", "viewstmt", - "opt_check_option", "loadstmt", "createdbstmt", "createdb_opt_list", - "createdb_opt_items", "createdb_opt_item", "createdb_opt_name", - "opt_equal", "alterdatabasestmt", "alterdatabasesetstmt", "drop_option_list", - "drop_option", "altercollationstmt", "altersystemstmt", "createdomainstmt", - "alterdomainstmt", "opt_as", "altertsdictionarystmt", "altertsconfigurationstmt", - "any_with", "createconversionstmt", "clusterstmt", "opt_verbose_list", - "cluster_index_specification", "vacuumstmt", "analyzestmt", "vac_analyze_option_list", - "analyze_keyword", "vac_analyze_option_elem", "vac_analyze_option_name", - "vac_analyze_option_arg", "opt_analyze", "analyze_options_list", - "analyze_option_elem", "opt_verbose", "opt_skiplock", "opt_buffer_usage_limit", - "opt_full", "opt_freeze", "opt_name_list", "vacuum_relation", "vacuum_relation_list", - "opt_vacuum_relation_list", "explainstmt", "explainablestmt", "explain_option_list", - "explain_option_elem", "explain_option_name", "explain_option_arg", - "preparestmt", "prep_type_clause", "preparablestmt", "executestmt", - "execute_param_clause", "deallocatestmt", "insertstmt", "insert_target", - "insert_rest", "override_kind", "insert_column_list", "insert_column_item", - "opt_on_conflict", "opt_conf_expr", "returning_clause", "deletestmt", - "using_clause", "lockstmt", "opt_lock", "lock_type", "opt_nowait", - "opt_nowait_or_skip", "updatestmt", "set_clause_list", "set_clause", - "set_target", "set_target_list", "declarecursorstmt", "cursor_name", - "cursor_options", "opt_hold", "selectstmt", "select_with_parens", - "select_no_parens", "select_clause", "simple_select", "set_operator", - "set_operator_with_all_or_distinct", "with_clause", "cte_list", - "common_table_expr", "search_cluase", "cycle_cluase", "opt_materialized", - "opt_with_clause", "into_clause", "opt_strict", "opttempTableName", - "opt_table", "all_or_distinct", "distinct_clause", "opt_all_clause", - "opt_sort_clause", "sort_clause", "sortby_list", "sortby", "select_limit", - "opt_select_limit", "limit_clause", "fetch_clause", "offset_clause", - "select_limit_value", "select_offset_value", "select_fetch_first_value", - "i_or_f_const", "row_or_rows", "first_or_next", "group_clause", - "group_by_list", "group_by_item", "empty_grouping_set", "rollup_clause", - "cube_clause", "grouping_sets_clause", "having_clause", "for_locking_clause", - "opt_for_locking_clause", "for_locking_items", "for_locking_item", - "for_locking_strength", "locked_rels_list", "values_clause", "from_clause", - "from_list", "table_ref", "alias_clause", "opt_alias_clause", "func_alias_clause", - "join_type", "join_qual", "relation_expr", "view_relation_expr", - "publication_relation_expr", "relation_expr_list", "publication_relation_expr_list", - "relation_expr_opt_alias", "tablesample_clause", "opt_repeatable_clause", - "func_table", "rowsfrom_item", "rowsfrom_list", "opt_col_def_list", - "opt_ordinality", "where_clause", "where_or_current_clause", "opttablefuncelementlist", - "tablefuncelementlist", "tablefuncelement", "xmltable", "xmltable_column_list", - "xmltable_column_el", "xmltable_column_option_list", "xmltable_column_option_el", - "xml_namespace_list", "xml_namespace_el", "typename", "opt_array_bounds", - "simpletypename", "consttypename", "generictype", "opt_type_modifiers", - "numeric", "opt_float", "bit", "constbit", "bitwithlength", "bitwithoutlength", - "character", "constcharacter", "character_c", "opt_varying", "constdatetime", - "constinterval", "opt_timezone", "opt_interval", "interval_second", - "opt_escape", "a_expr", "a_expr_qual", "a_expr_lessless", "a_expr_or", - "a_expr_and", "a_expr_in", "a_expr_unary_not", "a_expr_isnull", - "a_expr_is_not", "a_expr_compare", "a_expr_like", "a_expr_qual_op", - "a_expr_unary_qualop", "a_expr_add", "a_expr_mul", "a_expr_caret", - "a_expr_unary_sign", "a_expr_at_time_zone", "a_expr_collate", "a_expr_typecast", - "b_expr", "c_expr", "plsqlvariablename", "func_application", "func_expr", - "func_expr_windowless", "func_expr_common_subexpr", "xml_root_version", - "opt_xml_root_standalone", "xml_attributes", "xml_attribute_list", - "xml_attribute_el", "document_or_content", "xml_whitespace_option", - "xmlexists_argument", "xml_passing_mech", "within_group_clause", - "filter_clause", "window_clause", "window_definition_list", "window_definition", - "over_clause", "window_specification", "opt_existing_window_name", - "opt_partition_clause", "opt_frame_clause", "frame_extent", "frame_bound", - "opt_window_exclusion_clause", "row", "explicit_row", "implicit_row", - "sub_type", "all_op", "mathop", "qual_op", "qual_all_op", "subquery_Op", - "expr_list", "column_expr_list_noparen", "column_expr_list", "column_expr", - "column_expr_noparen", "func_arg_list", "func_arg_expr", "type_list", - "array_expr", "array_expr_list", "extract_list", "extract_arg", - "unicode_normal_form", "overlay_list", "position_list", "substr_list", - "trim_list", "in_expr", "case_expr", "when_clause_list", "when_clause", - "case_default", "case_arg", "columnref", "indirection_el", "opt_slice_bound", - "indirection", "opt_indirection", "opt_target_list", "target_list", - "target_el", "qualified_name_list", "table_name_list", "schema_name_list", - "database_nameList", "procedure_name_list", "tablespace_name_create", + "function_with_argtypes_list", "function_with_argtypes", "func_arg", + "arg_class", "func_type", "func_arg_with_default", "aggr_args", + "aggregate_with_argtypes", "common_func_opt_item", "createfunc_opt_item", + "opt_definition", "table_func_column", "alterfunctionstmt", "removefuncstmt", + "removeaggrstmt", "removeoperstmt", "oper_argtypes", "any_operator", + "operator_with_argtypes", "dostmt", "createcaststmt", "opt_if_exists", + "createtransformstmt", "sql_with_function", "reindexstmt", "altertblspcstmt", + "renamestmt", "alterobjectdependsstmt", "alterobjectschemastmt", + "alteroperatorstmt", "operator_def_list", "operator_def_elem", "altertypestmt", + "alterownerstmt", "createpublicationstmt", "alterpublicationstmt", + "createsubscriptionstmt", "altersubscriptionstmt", "rulestmt", "ruleactionstmt", + "notifystmt", "notify_payload", "listenstmt", "unlistenstmt", "transactionstmt", + "opt_transaction", "transaction_mode_item", "transaction_mode_list", + "viewstmt", "loadstmt", "createdbstmt", "createdb_opt_item", "alterdatabasestmt", + "alterdatabasesetstmt", "altercollationstmt", "altersystemstmt", + "createdomainstmt", "alterdomainstmt", "altertsdictionarystmt", + "altertsconfigurationstmt", "createconversionstmt", "clusterstmt", + "vacuumstmt", "analyzestmt", "analyze_keyword", "vac_analyze_option_elem", + "analyze_option_elem", "opt_verbose", "vacuum_relation", "vacuum_relation_list", + "explainstmt", "explainablestmt", "explain_option_list", "preparestmt", + "prep_type_clause", "preparablestmt", "executestmt", "execute_param_clause", + "deallocatestmt", "insertstmt", "insert_rest", "insert_column_list", + "insert_column_item", "returning_clause", "deletestmt", "lockstmt", + "updatestmt", "set_clause_list", "set_clause", "declarecursorstmt", + "selectstmt", "select_with_parens", "select_no_parens", "select_clause", + "simple_select", "set_operator_with_all_or_distinct", "with_clause", + "common_table_expr", "search_cluase", "cycle_cluase", "into_clause", + "opttempTableName", "distinct_clause", "sort_clause", "sortby", + "select_limit", "limit_clause", "fetch_clause", "offset_clause", + "select_fetch_first_value", "group_clause", "group_by_list", "group_by_item", + "for_locking_clause", "values_clause", "from_clause", "from_list", + "table_ref", "alias_clause", "func_alias_clause", "join_type", "join_qual", + "relation_expr", "publication_relation_expr", "relation_expr_list", + "relation_expr_opt_alias", "tablesample_clause", "func_table", "rowsfrom_item", + "where_clause", "where_or_current_clause", "tablefuncelementlist", + "tablefuncelement", "xmltable", "xmltable_column_el", "xml_namespace_el", + "typename", "simpletypename", "consttypename", "numeric", "opt_float", + "bit", "character", "constdatetime", "opt_interval", "interval_second", + "comparisonOperator", "expression", "booleanExpression", "predicate", + "valueExpression", "primaryExpression", "func_application", "func_expr", + "func_expr_windowless", "func_expr_common_subexpr", "xml_attribute_list", + "xml_attribute_el", "document_or_content", "xmlexists_argument", + "xml_passing_mech", "window_clause", "window_definition", "over_clause", + "window_specification", "opt_frame_clause", "frame_bound", "row", + "explicit_row", "sub_type", "all_op", "mathop", "qual_op", "qual_all_op", + "subquery_Op", "expr_list", "column_expr", "column_expr_noparen", + "func_arg_list", "func_arg_expr", "array_expr", "extract_arg", "unicode_normal_form", + "substr_list", "when_clause", "indirection_el", "indirection", "opt_indirection", + "target_list", "target_el", "qualified_name_list", "table_name_list", + "schema_name_list", "database_nameList", "tablespace_name_create", "tablespace_name", "table_name_create", "table_name", "view_name_create", "view_name", "qualified_name", "tablespace_name_list", "name_list", "database_name_create", "database_name", "schema_name", "routine_name_create", "routine_name", "procedure_name", "procedure_name_create", "column_name", - "column_name_create", "name", "attr_name", "file_name", "function_name_create", - "function_name", "usual_name", "aexprconst", "xconst", "bconst", - "fconst", "iconst", "sconst", "anysconst", "opt_uescape", "signediconst", - "groupname", "roleid", "rolespec", "role_list", "colid", "index_method_choices", - "exclude_element", "index_paramenters", "type_function_name", "type_usual_name", - "nonreservedword_column", "nonreservedword", "collabel", "identifier", - "plsqlidentifier", "unreserved_keyword", "col_name_keyword", "type_func_name_keyword", - "reserved_keyword", "pl_function", "comp_options", "comp_option", - "sharp", "option_value", "opt_semi", "pl_block", "decl_sect", "decl_start", - "decl_stmts", "label_decl", "decl_stmt", "decl_statement", "opt_scrollable", - "decl_cursor_query", "decl_cursor_args", "decl_cursor_arglist", - "decl_cursor_arg", "decl_is_for", "decl_aliasitem", "decl_varname", - "decl_const", "decl_datatype", "decl_collate", "decl_notnull", "decl_defval", - "decl_defkey", "assign_operator", "proc_sect", "proc_stmt", "stmt_perform", - "stmt_call", "opt_expr_list", "stmt_assign", "stmt_getdiag", "getdiag_area_opt", - "getdiag_list", "getdiag_list_item", "getdiag_item", "getdiag_target", - "assign_var", "stmt_if", "stmt_elsifs", "stmt_else", "stmt_case", - "opt_expr_until_when", "case_when_list", "case_when", "opt_case_else", - "stmt_loop", "stmt_while", "stmt_for", "for_control", "opt_for_using_expression", - "opt_cursor_parameters", "opt_reverse", "opt_by_expression", "for_variable", - "stmt_foreach_a", "foreach_slice", "stmt_exit", "exit_type", "stmt_return", - "opt_return_result", "stmt_raise", "opt_stmt_raise_level", "opt_raise_list", - "opt_raise_using", "opt_raise_using_elem", "opt_raise_using_elem_list", - "stmt_assert", "opt_stmt_assert_message", "loop_body", "stmt_execsql", - "stmt_dynexecute", "opt_execute_using", "opt_execute_using_list", - "opt_execute_into", "stmt_open", "opt_open_bound_list_item", "opt_open_bound_list", - "opt_open_using", "opt_scroll_option", "opt_scroll_option_no", "stmt_fetch", - "into_target", "opt_cursor_from", "opt_fetch_direction", "stmt_move", - "mergestmt", "data_source", "join_condition", "merge_when_clause", - "merge_insert", "merge_update", "default_values_or_values", "exprofdefaultlist", - "exprofdefault", "stmt_close", "stmt_null", "stmt_commit", "stmt_rollback", - "plsql_opt_transaction_chain", "stmt_set", "cursor_variable", "exception_sect", - "proc_exceptions", "proc_exception", "proc_conditions", "proc_condition", - "opt_block_label", "opt_loop_label", "opt_label", "opt_exitcond", - "any_identifier", "plsql_unreserved_keyword", "sql_expression", - "expr_until_then", "expr_until_semi", "expr_until_rightbracket", - "expr_until_loop", "make_execsql_stmt", "opt_returning_clause_into", + "column_name_create", "function_name_create", "function_name", "sconst", + "anysconst", "signediconst", "rolespec", "role_list", "colid", "type_function_name", + "nonreservedword", "collabel", "identifier", "unreserved_keyword", + "col_name_keyword", "type_func_name_keyword", "reserved_keyword", + "pl_block", "label_decl", "decl_statement", "decl_cursor_arg", "assign_operator", + "proc_stmt", "stmt_perform", "stmt_call", "stmt_assign", "stmt_getdiag", + "getdiag_list_item", "assign_var", "stmt_if", "stmt_else", "stmt_case", + "stmt_loop_while_for", "for_control", "stmt_foreach_a", "stmt_exit", + "stmt_return", "stmt_raise", "opt_raise_using_elem", "stmt_assert", + "loop_body", "stmt_execsql", "stmt_dynexecute", "opt_execute_into", + "stmt_open", "opt_open_bound_list_item", "stmt_fetch", "opt_fetch_direction", + "stmt_move", "mergestmt", "data_source", "merge_when_clause", "merge_insert", + "merge_update", "default_values_or_values", "exprofdefault", "stmt_close", + "stmt_null", "stmt_commit_or_rollback", "stmt_set", "cursor_variable", + "exception_sect", "proc_condition", "any_identifier", "plsql_unreserved_keyword", + "sql_expression", ]; public get grammarFileName(): string { return "PostgreSqlParser.g4"; } @@ -1958,21 +1446,21 @@ export class PostgreSqlParser extends SQLParserBase { try { this.enterOuterAlt(localContext, 1); { - this.state = 1753; + this.state = 937; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 2 || _la === 31 || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 570441729) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & 142606337) !== 0) || _la === 105 || _la === 129 || ((((_la - 138)) & ~0x1F) === 0 && ((1 << (_la - 138)) & 2159673601) !== 0) || ((((_la - 177)) & ~0x1F) === 0 && ((1 << (_la - 177)) & 100680739) !== 0) || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & 1090557953) !== 0) || ((((_la - 290)) & ~0x1F) === 0 && ((1 << (_la - 290)) & 679839745) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 272417) !== 0) || ((((_la - 358)) & ~0x1F) === 0 && ((1 << (_la - 358)) & 6401) !== 0) || ((((_la - 422)) & ~0x1F) === 0 && ((1 << (_la - 422)) & 4196353) !== 0) || _la === 454 || _la === 525 || _la === 581) { { { - this.state = 1750; + this.state = 934; this.singleStmt(); } } - this.state = 1755; + this.state = 939; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 1756; + this.state = 940; this.match(PostgreSqlParser.EOF); } } @@ -1990,45 +1478,21 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public plsqlroot(): PlsqlrootContext { - let localContext = new PlsqlrootContext(this.context, this.state); - this.enterRule(localContext, 2, PostgreSqlParser.RULE_plsqlroot); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 1758; - this.pl_function(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public singleStmt(): SingleStmtContext { let localContext = new SingleStmtContext(this.context, this.state); - this.enterRule(localContext, 4, PostgreSqlParser.RULE_singleStmt); + this.enterRule(localContext, 2, PostgreSqlParser.RULE_singleStmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1760; + this.state = 942; this.stmt(); - this.state = 1762; + this.state = 944; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 7) { { - this.state = 1761; + this.state = 943; this.match(PostgreSqlParser.SEMI); } } @@ -2051,865 +1515,841 @@ export class PostgreSqlParser extends SQLParserBase { } public stmt(): StmtContext { let localContext = new StmtContext(this.context, this.state); - this.enterRule(localContext, 6, PostgreSqlParser.RULE_stmt); + this.enterRule(localContext, 4, PostgreSqlParser.RULE_stmt); + let _la: number; try { - this.state = 1881; + this.state = 1066; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 2, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1764; + this.state = 946; this.altereventtrigstmt(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1765; + this.state = 947; this.altercollationstmt(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1766; + this.state = 948; this.alterdatabasestmt(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 1767; + this.state = 949; this.alterdatabasesetstmt(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 1768; + this.state = 950; this.alterdefaultprivilegesstmt(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 1769; + this.state = 951; this.alterdomainstmt(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 1770; + this.state = 952; this.alterenumstmt(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 1771; + this.state = 953; this.alterextensionstmt(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 1772; + this.state = 954; this.alterextensioncontentsstmt(); } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 1773; + this.state = 955; this.alterfdwstmt(); } break; case 11: this.enterOuterAlt(localContext, 11); { - this.state = 1774; + this.state = 956; this.alterforeignserverstmt(); } break; case 12: this.enterOuterAlt(localContext, 12); { - this.state = 1775; + this.state = 957; this.alterfunctionstmt(); } break; case 13: this.enterOuterAlt(localContext, 13); { - this.state = 1776; + this.state = 958; this.altergroupstmt(); } break; case 14: this.enterOuterAlt(localContext, 14); { - this.state = 1777; + this.state = 959; this.alterobjectdependsstmt(); } break; case 15: this.enterOuterAlt(localContext, 15); { - this.state = 1778; + this.state = 960; this.alterobjectschemastmt(); } break; case 16: this.enterOuterAlt(localContext, 16); { - this.state = 1779; + this.state = 961; this.alterownerstmt(); } break; case 17: this.enterOuterAlt(localContext, 17); { - this.state = 1780; + this.state = 962; this.alteroperatorstmt(); } break; case 18: this.enterOuterAlt(localContext, 18); { - this.state = 1781; + this.state = 963; this.altertypestmt(); } break; case 19: this.enterOuterAlt(localContext, 19); { - this.state = 1782; + this.state = 964; this.alterpolicystmt(); } break; case 20: this.enterOuterAlt(localContext, 20); { - this.state = 1783; + this.state = 965; this.alterprocedurestmt(); } break; case 21: this.enterOuterAlt(localContext, 21); { - this.state = 1784; + this.state = 966; this.alterseqstmt(); } break; case 22: this.enterOuterAlt(localContext, 22); { - this.state = 1785; + this.state = 967; this.altersystemstmt(); } break; case 23: this.enterOuterAlt(localContext, 23); { - this.state = 1786; + this.state = 968; this.altertablestmt(); } break; case 24: this.enterOuterAlt(localContext, 24); { - this.state = 1787; + this.state = 969; this.altertblspcstmt(); } break; case 25: this.enterOuterAlt(localContext, 25); { - this.state = 1788; + this.state = 970; this.altercompositetypestmt(); } break; case 26: this.enterOuterAlt(localContext, 26); { - this.state = 1789; + this.state = 971; this.alterpublicationstmt(); } break; case 27: this.enterOuterAlt(localContext, 27); { - this.state = 1790; + this.state = 972; this.alterrolesetstmt(); } break; case 28: this.enterOuterAlt(localContext, 28); { - this.state = 1791; + this.state = 973; this.alterroutinestmt(); } break; case 29: this.enterOuterAlt(localContext, 29); { - this.state = 1792; + this.state = 974; this.alterrolestmt(); } break; case 30: this.enterOuterAlt(localContext, 30); { - this.state = 1793; + this.state = 975; this.altersubscriptionstmt(); } break; case 31: this.enterOuterAlt(localContext, 31); { - this.state = 1794; + this.state = 976; this.alterstatsstmt(); } break; case 32: this.enterOuterAlt(localContext, 32); { - this.state = 1795; + this.state = 977; this.altertsconfigurationstmt(); } break; case 33: this.enterOuterAlt(localContext, 33); { - this.state = 1796; + this.state = 978; this.altertsdictionarystmt(); } break; case 34: this.enterOuterAlt(localContext, 34); { - this.state = 1797; + this.state = 979; this.alterusermappingstmt(); } break; case 35: this.enterOuterAlt(localContext, 35); { - this.state = 1798; + this.state = 980; this.analyzestmt(); } break; case 36: this.enterOuterAlt(localContext, 36); { - this.state = 1799; + this.state = 981; this.callstmt(); } break; case 37: this.enterOuterAlt(localContext, 37); { - this.state = 1800; + this.state = 982; this.checkpointstmt(); } break; case 38: this.enterOuterAlt(localContext, 38); { - this.state = 1801; + this.state = 983; this.closeportalstmt(); } break; case 39: this.enterOuterAlt(localContext, 39); { - this.state = 1802; + this.state = 984; this.clusterstmt(); } break; case 40: this.enterOuterAlt(localContext, 40); { - this.state = 1803; + this.state = 985; this.commentstmt(); } break; case 41: this.enterOuterAlt(localContext, 41); { - this.state = 1804; + this.state = 986; this.constraintssetstmt(); } break; case 42: this.enterOuterAlt(localContext, 42); { - this.state = 1805; + this.state = 987; this.copystmt(); } break; case 43: this.enterOuterAlt(localContext, 43); { - this.state = 1806; + this.state = 988; this.createamstmt(); } break; case 44: this.enterOuterAlt(localContext, 44); { - this.state = 1807; + this.state = 989; this.createasstmt(); } break; case 45: this.enterOuterAlt(localContext, 45); { - this.state = 1808; + this.state = 990; this.createassertionstmt(); } break; case 46: this.enterOuterAlt(localContext, 46); { - this.state = 1809; + this.state = 991; this.createcaststmt(); } break; case 47: this.enterOuterAlt(localContext, 47); { - this.state = 1810; + this.state = 992; this.createconversionstmt(); } break; case 48: this.enterOuterAlt(localContext, 48); { - this.state = 1811; + this.state = 993; this.createdomainstmt(); } break; case 49: this.enterOuterAlt(localContext, 49); { - this.state = 1812; + this.state = 994; this.createextensionstmt(); } break; case 50: this.enterOuterAlt(localContext, 50); { - this.state = 1813; + this.state = 995; this.createfdwstmt(); } break; case 51: this.enterOuterAlt(localContext, 51); { - this.state = 1814; + this.state = 996; this.createforeignserverstmt(); } break; case 52: this.enterOuterAlt(localContext, 52); { - this.state = 1815; + this.state = 997; this.createforeigntablestmt(); } break; case 53: this.enterOuterAlt(localContext, 53); { - this.state = 1816; + this.state = 998; this.createfunctionstmt(); } break; case 54: this.enterOuterAlt(localContext, 54); { - this.state = 1817; + this.state = 999; this.creategroupstmt(); } break; case 55: this.enterOuterAlt(localContext, 55); { - this.state = 1818; + this.state = 1000; this.creatematviewstmt(); } break; case 56: this.enterOuterAlt(localContext, 56); { - this.state = 1819; + this.state = 1001; this.createopclassstmt(); } break; case 57: this.enterOuterAlt(localContext, 57); { - this.state = 1820; + this.state = 1002; this.createopfamilystmt(); } break; case 58: this.enterOuterAlt(localContext, 58); { - this.state = 1821; + this.state = 1003; this.createpublicationstmt(); } break; case 59: this.enterOuterAlt(localContext, 59); { - this.state = 1822; + this.state = 1004; this.alteropfamilystmt(); } break; case 60: this.enterOuterAlt(localContext, 60); { - this.state = 1823; + this.state = 1005; this.createpolicystmt(); } break; case 61: this.enterOuterAlt(localContext, 61); { - this.state = 1824; + this.state = 1006; this.createplangstmt(); } break; case 62: this.enterOuterAlt(localContext, 62); { - this.state = 1825; + this.state = 1007; this.createschemastmt(); } break; case 63: this.enterOuterAlt(localContext, 63); { - this.state = 1826; + this.state = 1008; this.createseqstmt(); } break; case 64: this.enterOuterAlt(localContext, 64); { - this.state = 1827; + this.state = 1009; this.createstmt(); } break; case 65: this.enterOuterAlt(localContext, 65); { - this.state = 1828; + this.state = 1010; this.createsubscriptionstmt(); } break; case 66: this.enterOuterAlt(localContext, 66); { - this.state = 1829; + this.state = 1011; this.createstatsstmt(); } break; case 67: this.enterOuterAlt(localContext, 67); { - this.state = 1830; + this.state = 1012; this.createtablespacestmt(); } break; case 68: this.enterOuterAlt(localContext, 68); { - this.state = 1831; + this.state = 1013; this.createtransformstmt(); } break; case 69: this.enterOuterAlt(localContext, 69); { - this.state = 1832; + this.state = 1014; this.createtrigstmt(); } break; case 70: this.enterOuterAlt(localContext, 70); { - this.state = 1833; + this.state = 1015; this.createeventtrigstmt(); } break; case 71: this.enterOuterAlt(localContext, 71); { - this.state = 1834; + this.state = 1016; this.createrolestmt(); } break; case 72: this.enterOuterAlt(localContext, 72); { - this.state = 1835; + this.state = 1017; this.createuserstmt(); } break; case 73: this.enterOuterAlt(localContext, 73); { - this.state = 1836; + this.state = 1018; this.createusermappingstmt(); } break; case 74: this.enterOuterAlt(localContext, 74); { - this.state = 1837; + this.state = 1019; this.createdbstmt(); } break; case 75: this.enterOuterAlt(localContext, 75); { - this.state = 1838; + this.state = 1020; this.deallocatestmt(); } break; case 76: this.enterOuterAlt(localContext, 76); { - this.state = 1839; + this.state = 1021; this.declarecursorstmt(); } break; case 77: this.enterOuterAlt(localContext, 77); { - this.state = 1840; + this.state = 1022; this.definestmt(); } break; case 78: this.enterOuterAlt(localContext, 78); { - this.state = 1841; + this.state = 1023; this.deletestmt(); } break; case 79: this.enterOuterAlt(localContext, 79); { - this.state = 1842; + this.state = 1024; this.discardstmt(); } break; case 80: this.enterOuterAlt(localContext, 80); { - this.state = 1843; + this.state = 1025; this.dostmt(); } break; case 81: this.enterOuterAlt(localContext, 81); { - this.state = 1844; + this.state = 1026; this.dropstmt(); } break; case 82: this.enterOuterAlt(localContext, 82); { - this.state = 1845; + this.state = 1027; this.executestmt(); } break; case 83: this.enterOuterAlt(localContext, 83); { - this.state = 1846; + this.state = 1028; this.explainstmt(); } break; case 84: this.enterOuterAlt(localContext, 84); { - this.state = 1847; + this.state = 1029; this.fetchstmt(); } break; case 85: this.enterOuterAlt(localContext, 85); { - this.state = 1848; + this.state = 1030; this.grantstmt(); } break; case 86: this.enterOuterAlt(localContext, 86); { - this.state = 1849; + this.state = 1031; this.grantrolestmt(); } break; case 87: this.enterOuterAlt(localContext, 87); { - this.state = 1850; + this.state = 1032; this.mergestmt(); } break; case 88: this.enterOuterAlt(localContext, 88); { - this.state = 1851; + this.state = 1033; this.importforeignschemastmt(); } break; case 89: this.enterOuterAlt(localContext, 89); { - this.state = 1852; + this.state = 1034; this.indexstmt(); } break; case 90: this.enterOuterAlt(localContext, 90); { - this.state = 1853; + this.state = 1035; this.insertstmt(); } break; case 91: this.enterOuterAlt(localContext, 91); { - this.state = 1854; + this.state = 1036; this.listenstmt(); } break; case 92: this.enterOuterAlt(localContext, 92); { - this.state = 1855; + this.state = 1037; this.refreshmatviewstmt(); } break; case 93: this.enterOuterAlt(localContext, 93); { - this.state = 1856; + this.state = 1038; this.loadstmt(); } break; case 94: this.enterOuterAlt(localContext, 94); { - this.state = 1857; + this.state = 1039; this.lockstmt(); } break; case 95: this.enterOuterAlt(localContext, 95); { - this.state = 1858; + this.state = 1040; this.notifystmt(); } break; case 96: this.enterOuterAlt(localContext, 96); { - this.state = 1859; + this.state = 1041; this.preparestmt(); } break; case 97: this.enterOuterAlt(localContext, 97); { - this.state = 1860; + this.state = 1042; this.reassignownedstmt(); } break; case 98: this.enterOuterAlt(localContext, 98); { - this.state = 1861; + this.state = 1043; this.reindexstmt(); } break; case 99: this.enterOuterAlt(localContext, 99); { - this.state = 1862; + this.state = 1044; this.removeaggrstmt(); } break; case 100: this.enterOuterAlt(localContext, 100); { - this.state = 1863; + this.state = 1045; this.removefuncstmt(); } break; case 101: this.enterOuterAlt(localContext, 101); { - this.state = 1864; + this.state = 1046; this.removeoperstmt(); } break; case 102: this.enterOuterAlt(localContext, 102); { - this.state = 1865; + this.state = 1047; this.renamestmt(); } break; case 103: this.enterOuterAlt(localContext, 103); { - this.state = 1866; + this.state = 1048; this.revokestmt(); } break; case 104: this.enterOuterAlt(localContext, 104); { - this.state = 1867; + this.state = 1049; this.revokerolestmt(); } break; case 105: this.enterOuterAlt(localContext, 105); { - this.state = 1868; + this.state = 1050; this.rulestmt(); } break; case 106: this.enterOuterAlt(localContext, 106); { - this.state = 1869; + this.state = 1051; this.seclabelstmt(); } break; case 107: this.enterOuterAlt(localContext, 107); { - this.state = 1870; + this.state = 1052; this.selectstmt(); } break; case 108: this.enterOuterAlt(localContext, 108); { - this.state = 1871; + this.state = 1053; this.transactionstmt(); } break; case 109: this.enterOuterAlt(localContext, 109); { - this.state = 1872; + this.state = 1054; this.truncatestmt(); } break; case 110: this.enterOuterAlt(localContext, 110); { - this.state = 1873; + this.state = 1055; this.unlistenstmt(); } break; case 111: this.enterOuterAlt(localContext, 111); { - this.state = 1874; + this.state = 1056; this.updatestmt(); } break; case 112: this.enterOuterAlt(localContext, 112); { - this.state = 1875; + this.state = 1057; this.vacuumstmt(); } break; case 113: this.enterOuterAlt(localContext, 113); { - this.state = 1876; + this.state = 1058; this.variableresetstmt(); } break; case 114: this.enterOuterAlt(localContext, 114); { - this.state = 1877; + this.state = 1059; this.variablesetstmt(); } break; case 115: this.enterOuterAlt(localContext, 115); { - this.state = 1878; + this.state = 1060; this.variableshowstmt(); } break; case 116: this.enterOuterAlt(localContext, 116); { - this.state = 1879; + this.state = 1061; this.viewstmt(); } break; case 117: this.enterOuterAlt(localContext, 117); { - this.state = 1880; - this.plsqlconsolecommand(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public plsqlconsolecommand(): PlsqlconsolecommandContext { - let localContext = new PlsqlconsolecommandContext(this.context, this.state); - this.enterRule(localContext, 8, PostgreSqlParser.RULE_plsqlconsolecommand); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 1883; - this.match(PostgreSqlParser.MetaCommand); - this.state = 1885; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 582) { - { - this.state = 1884; - this.match(PostgreSqlParser.EndMetaCommand); + this.state = 1062; + this.match(PostgreSqlParser.MetaCommand); + this.state = 1064; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 582) { + { + this.state = 1063; + this.match(PostgreSqlParser.EndMetaCommand); + } } - } + } + break; } } catch (re) { @@ -2928,13 +2368,13 @@ export class PostgreSqlParser extends SQLParserBase { } public callstmt(): CallstmtContext { let localContext = new CallstmtContext(this.context, this.state); - this.enterRule(localContext, 10, PostgreSqlParser.RULE_callstmt); + this.enterRule(localContext, 6, PostgreSqlParser.RULE_callstmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 1887; + this.state = 1068; this.match(PostgreSqlParser.KW_CALL); - this.state = 1888; + this.state = 1069; this.func_application(); } } @@ -2954,88 +2394,40 @@ export class PostgreSqlParser extends SQLParserBase { } public createrolestmt(): CreaterolestmtContext { let localContext = new CreaterolestmtContext(this.context, this.state); - this.enterRule(localContext, 12, PostgreSqlParser.RULE_createrolestmt); + this.enterRule(localContext, 8, PostgreSqlParser.RULE_createrolestmt); try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1890; + this.state = 1071; this.match(PostgreSqlParser.KW_CREATE); - this.state = 1891; + this.state = 1072; this.match(PostgreSqlParser.KW_ROLE); - this.state = 1892; - this.roleid(); - this.state = 1894; + this.state = 1073; + this.rolespec(); + this.state = 1075; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 4, this.context) ) { case 1: { - this.state = 1893; - this.opt_with(); + this.state = 1074; + this.match(PostgreSqlParser.KW_WITH); } break; } - this.state = 1896; - this.optrolelist(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_with(): Opt_withContext { - let localContext = new Opt_withContext(this.context, this.state); - this.enterRule(localContext, 14, PostgreSqlParser.RULE_opt_with); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 1898; - this.match(PostgreSqlParser.KW_WITH); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public optrolelist(): OptrolelistContext { - let localContext = new OptrolelistContext(this.context, this.state); - this.enterRule(localContext, 16, PostgreSqlParser.RULE_optrolelist); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 1903; + this.state = 1080; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 5, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 1900; + this.state = 1077; this.createoptroleelem(); } } } - this.state = 1905; + this.state = 1082; this.errorHandler.sync(this); alternative = this.interpreter.adaptivePredict(this.tokenStream, 5, this.context); } @@ -3055,59 +2447,20 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alteroptrolelist(): AlteroptrolelistContext { - let localContext = new AlteroptrolelistContext(this.context, this.state); - this.enterRule(localContext, 18, PostgreSqlParser.RULE_alteroptrolelist); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 1909; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 6, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 1906; - this.alteroptroleelem(); - } - } - } - this.state = 1911; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 6, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public alteroptroleelem(): AlteroptroleelemContext { let localContext = new AlteroptroleelemContext(this.context, this.state); - this.enterRule(localContext, 20, PostgreSqlParser.RULE_alteroptroleelem); + this.enterRule(localContext, 10, PostgreSqlParser.RULE_alteroptroleelem); let _la: number; try { - this.state = 1947; + this.state = 1121; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 8, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_PASSWORD: this.enterOuterAlt(localContext, 1); { - this.state = 1912; + this.state = 1083; this.match(PostgreSqlParser.KW_PASSWORD); - this.state = 1915; + this.state = 1086; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.StringConstant: @@ -3115,13 +2468,13 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.BeginDollarStringConstant: case PostgreSqlParser.EscapeStringConstant: { - this.state = 1913; + this.state = 1084; this.sconst(); } break; case PostgreSqlParser.KW_NULL: { - this.state = 1914; + this.state = 1085; this.match(PostgreSqlParser.KW_NULL); } break; @@ -3130,10 +2483,11 @@ export class PostgreSqlParser extends SQLParserBase { } } break; - case 2: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_UNENCRYPTED: this.enterOuterAlt(localContext, 2); { - this.state = 1917; + this.state = 1088; _la = this.tokenStream.LA(1); if(!(_la === 195 || _la === 364)) { this.errorHandler.recoverInline(this); @@ -3142,202 +2496,270 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1918; + this.state = 1089; this.match(PostgreSqlParser.KW_PASSWORD); - this.state = 1919; + this.state = 1090; this.sconst(); } break; - case 3: + case PostgreSqlParser.KW_INHERIT: this.enterOuterAlt(localContext, 3); { - this.state = 1920; - _la = this.tokenStream.LA(1); - if(!(_la === 228 || _la === 229)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } + this.state = 1091; + this.match(PostgreSqlParser.KW_INHERIT); } break; - case 4: + case PostgreSqlParser.KW_NOINHERIT: this.enterOuterAlt(localContext, 4); { - this.state = 1921; - _la = this.tokenStream.LA(1); - if(!(_la === 236 || _la === 237)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } + this.state = 1092; + this.match(PostgreSqlParser.KW_NOINHERIT); } break; - case 5: + case PostgreSqlParser.KW_CREATEUSER: this.enterOuterAlt(localContext, 5); { - this.state = 1922; - _la = this.tokenStream.LA(1); - if(!(_la === 234 || _la === 235)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } + this.state = 1093; + this.match(PostgreSqlParser.KW_CREATEUSER); } break; - case 6: + case PostgreSqlParser.KW_NOCREATEUSER: this.enterOuterAlt(localContext, 6); { - this.state = 1923; - _la = this.tokenStream.LA(1); - if(!(_la === 232 || _la === 233)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } + this.state = 1094; + this.match(PostgreSqlParser.KW_NOCREATEUSER); } break; - case 7: + case PostgreSqlParser.KW_CREATEROLE: this.enterOuterAlt(localContext, 7); { - this.state = 1924; - _la = this.tokenStream.LA(1); - if(!(_la === 230 || _la === 231)) { - this.errorHandler.recoverInline(this); + this.state = 1095; + this.match(PostgreSqlParser.KW_CREATEROLE); } - else { - this.errorHandler.reportMatch(this); - this.consume(); + break; + case PostgreSqlParser.KW_NOCREATEROLE: + this.enterOuterAlt(localContext, 8); + { + this.state = 1096; + this.match(PostgreSqlParser.KW_NOCREATEROLE); } + break; + case PostgreSqlParser.KW_CREATEDB: + this.enterOuterAlt(localContext, 9); + { + this.state = 1097; + this.match(PostgreSqlParser.KW_CREATEDB); } break; - case 8: - this.enterOuterAlt(localContext, 8); + case PostgreSqlParser.KW_NOCREATEDB: + this.enterOuterAlt(localContext, 10); { - this.state = 1925; - _la = this.tokenStream.LA(1); - if(!(_la === 535 || _la === 536)) { - this.errorHandler.recoverInline(this); + this.state = 1098; + this.match(PostgreSqlParser.KW_NOCREATEDB); } - else { - this.errorHandler.reportMatch(this); - this.consume(); + break; + case PostgreSqlParser.KW_SUPERUSER: + this.enterOuterAlt(localContext, 11); + { + this.state = 1099; + this.match(PostgreSqlParser.KW_SUPERUSER); } + break; + case PostgreSqlParser.KW_NOSUPERUSER: + this.enterOuterAlt(localContext, 12); + { + this.state = 1100; + this.match(PostgreSqlParser.KW_NOSUPERUSER); } break; - case 9: - this.enterOuterAlt(localContext, 9); + case PostgreSqlParser.KW_LOGIN: + this.enterOuterAlt(localContext, 13); { - this.state = 1926; - _la = this.tokenStream.LA(1); - if(!(_la === 537 || _la === 538)) { - this.errorHandler.recoverInline(this); + this.state = 1101; + this.match(PostgreSqlParser.KW_LOGIN); } - else { - this.errorHandler.reportMatch(this); - this.consume(); + break; + case PostgreSqlParser.KW_NOLOGIN: + this.enterOuterAlt(localContext, 14); + { + this.state = 1102; + this.match(PostgreSqlParser.KW_NOLOGIN); } + break; + case PostgreSqlParser.KW_REPLICATION: + this.enterOuterAlt(localContext, 15); + { + this.state = 1103; + this.match(PostgreSqlParser.KW_REPLICATION); } break; - case 10: - this.enterOuterAlt(localContext, 10); + case PostgreSqlParser.KW_NOREPLICATION: + this.enterOuterAlt(localContext, 16); { - this.state = 1927; - _la = this.tokenStream.LA(1); - if(!(_la === 539 || _la === 540)) { - this.errorHandler.recoverInline(this); + this.state = 1104; + this.match(PostgreSqlParser.KW_NOREPLICATION); } - else { - this.errorHandler.reportMatch(this); - this.consume(); + break; + case PostgreSqlParser.KW_BYPASSRLS: + this.enterOuterAlt(localContext, 17); + { + this.state = 1105; + this.match(PostgreSqlParser.KW_BYPASSRLS); } + break; + case PostgreSqlParser.KW_NOBYPASSRLS: + this.enterOuterAlt(localContext, 18); + { + this.state = 1106; + this.match(PostgreSqlParser.KW_NOBYPASSRLS); } break; - case 11: - this.enterOuterAlt(localContext, 11); + case PostgreSqlParser.KW_CONNECTION: + this.enterOuterAlt(localContext, 19); { - this.state = 1928; + this.state = 1107; this.match(PostgreSqlParser.KW_CONNECTION); - this.state = 1929; + this.state = 1108; this.match(PostgreSqlParser.KW_LIMIT); - this.state = 1930; + this.state = 1109; this.signediconst(); } break; - case 12: - this.enterOuterAlt(localContext, 12); + case PostgreSqlParser.KW_VALID: + this.enterOuterAlt(localContext, 20); { - this.state = 1931; + this.state = 1110; this.match(PostgreSqlParser.KW_VALID); - this.state = 1932; + this.state = 1111; this.match(PostgreSqlParser.KW_UNTIL); - this.state = 1933; + this.state = 1112; this.sconst(); } break; - case 13: - this.enterOuterAlt(localContext, 13); + case PostgreSqlParser.KW_IN: + this.enterOuterAlt(localContext, 21); { - this.state = 1934; + this.state = 1113; this.match(PostgreSqlParser.KW_IN); - this.state = 1935; - this.match(PostgreSqlParser.KW_ROLE); - this.state = 1936; - this.name_list(); + this.state = 1114; + _la = this.tokenStream.LA(1); + if(!(_la === 66 || _la === 318)) { + this.errorHandler.recoverInline(this); } - break; - case 14: - this.enterOuterAlt(localContext, 14); - { - this.state = 1937; - this.match(PostgreSqlParser.KW_IN); - this.state = 1938; - this.match(PostgreSqlParser.KW_GROUP); - this.state = 1939; + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1115; this.name_list(); } break; - case 15: - this.enterOuterAlt(localContext, 15); + case PostgreSqlParser.KW_USER: + case PostgreSqlParser.KW_ROLE: + this.enterOuterAlt(localContext, 22); { - this.state = 1940; - this.match(PostgreSqlParser.KW_ROLE); - this.state = 1941; + this.state = 1116; + _la = this.tokenStream.LA(1); + if(!(_la === 99 || _la === 318)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1117; this.role_list(); } break; - case 16: - this.enterOuterAlt(localContext, 16); + case PostgreSqlParser.KW_ADMIN: + this.enterOuterAlt(localContext, 23); { - this.state = 1942; + this.state = 1118; this.match(PostgreSqlParser.KW_ADMIN); - this.state = 1943; + this.state = 1119; this.name_list(); } break; - case 17: - this.enterOuterAlt(localContext, 17); - { - this.state = 1944; - this.match(PostgreSqlParser.KW_USER); - this.state = 1945; - this.role_list(); - } - break; - case 18: - this.enterOuterAlt(localContext, 18); + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + this.enterOuterAlt(localContext, 24); { - this.state = 1946; + this.state = 1120; this.identifier(); } break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -3356,52 +2778,50 @@ export class PostgreSqlParser extends SQLParserBase { } public createoptroleelem(): CreateoptroleelemContext { let localContext = new CreateoptroleelemContext(this.context, this.state); - this.enterRule(localContext, 22, PostgreSqlParser.RULE_createoptroleelem); + this.enterRule(localContext, 12, PostgreSqlParser.RULE_createoptroleelem); let _la: number; try { - this.state = 1959; + this.state = 1131; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 9, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 8, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 1949; + this.state = 1123; this.alteroptroleelem(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 1950; + this.state = 1124; this.match(PostgreSqlParser.KW_SYSID); - this.state = 1951; - this.iconst(); + this.state = 1125; + this.match(PostgreSqlParser.Integral); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 1952; - this.match(PostgreSqlParser.KW_ADMIN); - this.state = 1953; + this.state = 1126; + _la = this.tokenStream.LA(1); + if(!(_la === 134 || _la === 318)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1127; this.role_list(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 1954; - this.match(PostgreSqlParser.KW_ROLE); - this.state = 1955; - this.role_list(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 1956; + this.state = 1128; this.match(PostgreSqlParser.KW_IN); - this.state = 1957; + this.state = 1129; _la = this.tokenStream.LA(1); if(!(_la === 66 || _la === 318)) { this.errorHandler.recoverInline(this); @@ -3410,7 +2830,7 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1958; + this.state = 1130; this.role_list(); } break; @@ -3432,28 +2852,43 @@ export class PostgreSqlParser extends SQLParserBase { } public createuserstmt(): CreateuserstmtContext { let localContext = new CreateuserstmtContext(this.context, this.state); - this.enterRule(localContext, 24, PostgreSqlParser.RULE_createuserstmt); + this.enterRule(localContext, 14, PostgreSqlParser.RULE_createuserstmt); try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1961; + this.state = 1133; this.match(PostgreSqlParser.KW_CREATE); - this.state = 1962; + this.state = 1134; this.match(PostgreSqlParser.KW_USER); - this.state = 1963; - this.roleid(); - this.state = 1965; + this.state = 1135; + this.rolespec(); + this.state = 1137; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 10, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 9, this.context) ) { case 1: { - this.state = 1964; - this.opt_with(); + this.state = 1136; + this.match(PostgreSqlParser.KW_WITH); } break; } - this.state = 1967; - this.optrolelist(); + this.state = 1142; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 10, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1139; + this.createoptroleelem(); + } + } + } + this.state = 1144; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 10, this.context); + } } } catch (re) { @@ -3472,14 +2907,15 @@ export class PostgreSqlParser extends SQLParserBase { } public alterrolestmt(): AlterrolestmtContext { let localContext = new AlterrolestmtContext(this.context, this.state); - this.enterRule(localContext, 26, PostgreSqlParser.RULE_alterrolestmt); + this.enterRule(localContext, 16, PostgreSqlParser.RULE_alterrolestmt); let _la: number; try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 1969; + this.state = 1145; this.match(PostgreSqlParser.KW_ALTER); - this.state = 1970; + this.state = 1146; _la = this.tokenStream.LA(1); if(!(_la === 99 || _la === 318)) { this.errorHandler.recoverInline(this); @@ -3488,63 +2924,34 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1971; + this.state = 1147; this.rolespec(); - this.state = 1973; + this.state = 1149; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 11, this.context) ) { case 1: { - this.state = 1972; - this.opt_with(); + this.state = 1148; + this.match(PostgreSqlParser.KW_WITH); } break; } - this.state = 1975; - this.alteroptrolelist(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_in_database(): Opt_in_databaseContext { - let localContext = new Opt_in_databaseContext(this.context, this.state); - this.enterRule(localContext, 28, PostgreSqlParser.RULE_opt_in_database); - try { - this.state = 1981; + this.state = 1154; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_SET: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_IN: - this.enterOuterAlt(localContext, 2); - { - this.state = 1978; - this.match(PostgreSqlParser.KW_IN); - this.state = 1979; - this.match(PostgreSqlParser.KW_DATABASE); - this.state = 1980; - this.database_name(); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 12, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1151; + this.alteroptroleelem(); + } + } } - break; - default: - throw new antlr.NoViableAltException(this); + this.state = 1156; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 12, this.context); + } } } catch (re) { @@ -3563,14 +2970,14 @@ export class PostgreSqlParser extends SQLParserBase { } public alterrolesetstmt(): AlterrolesetstmtContext { let localContext = new AlterrolesetstmtContext(this.context, this.state); - this.enterRule(localContext, 30, PostgreSqlParser.RULE_alterrolesetstmt); + this.enterRule(localContext, 18, PostgreSqlParser.RULE_alterrolesetstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1983; + this.state = 1157; this.match(PostgreSqlParser.KW_ALTER); - this.state = 1984; + this.state = 1158; _la = this.tokenStream.LA(1); if(!(_la === 99 || _la === 318)) { this.errorHandler.recoverInline(this); @@ -3579,12 +2986,12 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 1987; + this.state = 1161; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_ALL: { - this.state = 1985; + this.state = 1159; this.match(PostgreSqlParser.KW_ALL); } break; @@ -4013,16 +3420,20 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 1986; + this.state = 1160; this.rolespec(); } break; default: throw new antlr.NoViableAltException(this); } - this.state = 1989; - this.opt_in_database(); - this.state = 1990; + this.state = 1163; + this.match(PostgreSqlParser.KW_IN); + this.state = 1164; + this.match(PostgreSqlParser.KW_DATABASE); + this.state = 1165; + this.database_name(); + this.state = 1166; this.setresetclause(); } } @@ -4042,28 +3453,28 @@ export class PostgreSqlParser extends SQLParserBase { } public alterroutinestmt(): AlterroutinestmtContext { let localContext = new AlterroutinestmtContext(this.context, this.state); - this.enterRule(localContext, 32, PostgreSqlParser.RULE_alterroutinestmt); + this.enterRule(localContext, 20, PostgreSqlParser.RULE_alterroutinestmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 1992; + this.state = 1168; this.match(PostgreSqlParser.KW_ALTER); - this.state = 1993; + this.state = 1169; this.match(PostgreSqlParser.KW_ROUTINE); - this.state = 1994; + this.state = 1170; this.routine_name(); - this.state = 1996; + this.state = 1172; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2) { { - this.state = 1995; + this.state = 1171; this.func_args(); } } - this.state = 1998; + this.state = 1174; this.alter_routine_cluase(); } } @@ -4083,23 +3494,40 @@ export class PostgreSqlParser extends SQLParserBase { } public alter_routine_cluase(): Alter_routine_cluaseContext { let localContext = new Alter_routine_cluaseContext(this.context, this.state); - this.enterRule(localContext, 34, PostgreSqlParser.RULE_alter_routine_cluase); + this.enterRule(localContext, 22, PostgreSqlParser.RULE_alter_routine_cluase); let _la: number; try { - this.state = 2020; + let alternative: number; + this.state = 1202; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 17, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 18, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2000; - this.routine_action_list(); - this.state = 2002; + this.state = 1176; + this.routine_action(); + this.state = 1180; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 15, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1177; + this.routine_action(); + } + } + } + this.state = 1182; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 15, this.context); + } + this.state = 1184; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 15, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 16, this.context) ) { case 1: { - this.state = 2001; + this.state = 1183; this.match(PostgreSqlParser.KW_RESTRICT); } break; @@ -4109,57 +3537,57 @@ export class PostgreSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2004; + this.state = 1186; this.match(PostgreSqlParser.KW_RENAME); - this.state = 2005; + this.state = 1187; this.match(PostgreSqlParser.KW_TO); - this.state = 2006; + this.state = 1188; this.routine_name_create(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2007; + this.state = 1189; this.match(PostgreSqlParser.KW_OWNER); - this.state = 2008; + this.state = 1190; this.match(PostgreSqlParser.KW_TO); - this.state = 2009; + this.state = 1191; this.rolespec(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 2010; + this.state = 1192; this.match(PostgreSqlParser.KW_SET); - this.state = 2011; + this.state = 1193; this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 2012; + this.state = 1194; this.schema_name_create(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 2014; + this.state = 1196; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 269) { { - this.state = 2013; + this.state = 1195; this.match(PostgreSqlParser.KW_NO); } } - this.state = 2016; + this.state = 1198; this.match(PostgreSqlParser.KW_DEPENDS); - this.state = 2017; + this.state = 1199; this.match(PostgreSqlParser.KW_ON); - this.state = 2018; + this.state = 1200; this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 2019; - this.name(); + this.state = 1201; + this.colid(); } break; } @@ -4178,132 +3606,91 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public routine_action_list(): Routine_action_listContext { - let localContext = new Routine_action_listContext(this.context, this.state); - this.enterRule(localContext, 36, PostgreSqlParser.RULE_routine_action_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 2022; - this.routine_action(); - this.state = 2026; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 18, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 2023; - this.routine_action(); - } - } - } - this.state = 2028; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 18, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public routine_action(): Routine_actionContext { let localContext = new Routine_actionContext(this.context, this.state); - this.enterRule(localContext, 38, PostgreSqlParser.RULE_routine_action); + this.enterRule(localContext, 24, PostgreSqlParser.RULE_routine_action); let _la: number; try { - this.state = 2070; + this.state = 1246; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 24, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 25, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2029; + this.state = 1204; this.match(PostgreSqlParser.KW_IMMUTABLE); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2030; + this.state = 1205; this.match(PostgreSqlParser.KW_STABLE); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2031; + this.state = 1206; this.match(PostgreSqlParser.KW_VOLATILE); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 2033; + this.state = 1208; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 77) { { - this.state = 2032; + this.state = 1207; this.match(PostgreSqlParser.KW_NOT); } } - this.state = 2035; + this.state = 1210; this.match(PostgreSqlParser.KW_LEAKPROOF); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 2046; + this.state = 1221; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 22, this.context) ) { case 1: { - this.state = 2037; + this.state = 1212; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 205) { { - this.state = 2036; + this.state = 1211; this.match(PostgreSqlParser.KW_EXTERNAL); } } - this.state = 2039; + this.state = 1214; this.match(PostgreSqlParser.KW_SECURITY); - this.state = 2040; + this.state = 1215; this.match(PostgreSqlParser.KW_INVOKER); } break; case 2: { - this.state = 2042; + this.state = 1217; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 205) { { - this.state = 2041; + this.state = 1216; this.match(PostgreSqlParser.KW_EXTERNAL); } } - this.state = 2044; + this.state = 1219; this.match(PostgreSqlParser.KW_SECURITY); - this.state = 2045; + this.state = 1220; this.match(PostgreSqlParser.KW_DEFINER); } break; @@ -4313,9 +3700,9 @@ export class PostgreSqlParser extends SQLParserBase { case 6: this.enterOuterAlt(localContext, 6); { - this.state = 2048; + this.state = 1223; this.match(PostgreSqlParser.KW_PARALLEL); - this.state = 2049; + this.state = 1224; _la = this.tokenStream.LA(1); if(!(((((_la - 529)) & ~0x1F) === 0 && ((1 << (_la - 529)) & 7) !== 0))) { this.errorHandler.recoverInline(this); @@ -4329,29 +3716,29 @@ export class PostgreSqlParser extends SQLParserBase { case 7: this.enterOuterAlt(localContext, 7); { - this.state = 2050; + this.state = 1225; this.match(PostgreSqlParser.KW_COST); - this.state = 2051; - this.attr_name(); + this.state = 1226; + this.collabel(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 2052; + this.state = 1227; this.match(PostgreSqlParser.KW_ROWS); - this.state = 2053; - this.name(); + this.state = 1228; + this.colid(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 2054; + this.state = 1229; this.match(PostgreSqlParser.KW_SET); - this.state = 2055; - this.name(); - this.state = 2056; + this.state = 1230; + this.colid(); + this.state = 1231; _la = this.tokenStream.LA(1); if(!(_la === 10 || _la === 94)) { this.errorHandler.recoverInline(this); @@ -4360,18 +3747,18 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 2059; + this.state = 1234; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 23, this.context) ) { case 1: { - this.state = 2057; - this.name(); + this.state = 1232; + this.colid(); } break; case 2: { - this.state = 2058; + this.state = 1233; this.match(PostgreSqlParser.KW_DEFAULT); } break; @@ -4381,450 +3768,444 @@ export class PostgreSqlParser extends SQLParserBase { case 10: this.enterOuterAlt(localContext, 10); { - this.state = 2061; + this.state = 1236; this.match(PostgreSqlParser.KW_SET); - this.state = 2062; - this.name(); - this.state = 2063; + this.state = 1237; + this.colid(); + this.state = 1238; this.match(PostgreSqlParser.KW_FROM); - this.state = 2064; + this.state = 1239; this.match(PostgreSqlParser.KW_CURRENT); } break; case 11: this.enterOuterAlt(localContext, 11); { - this.state = 2066; - this.match(PostgreSqlParser.KW_RESET); - this.state = 2067; - this.name(); - } - break; - case 12: - this.enterOuterAlt(localContext, 12); - { - this.state = 2068; + this.state = 1241; this.match(PostgreSqlParser.KW_RESET); - this.state = 2069; - this.match(PostgreSqlParser.KW_ALL); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public creategroupstmt(): CreategroupstmtContext { - let localContext = new CreategroupstmtContext(this.context, this.state); - this.enterRule(localContext, 40, PostgreSqlParser.RULE_creategroupstmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2072; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 2073; - this.match(PostgreSqlParser.KW_GROUP); - this.state = 2074; - this.groupname(); - this.state = 2076; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 25, this.context) ) { - case 1: - { - this.state = 2075; - this.opt_with(); - } - break; - } - this.state = 2078; - this.optrolelist(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public altergroupstmt(): AltergroupstmtContext { - let localContext = new AltergroupstmtContext(this.context, this.state); - this.enterRule(localContext, 42, PostgreSqlParser.RULE_altergroupstmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2080; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2081; - this.match(PostgreSqlParser.KW_GROUP); - this.state = 2082; - this.rolespec(); - this.state = 2083; - this.add_drop(); - this.state = 2084; - this.match(PostgreSqlParser.KW_USER); - this.state = 2085; - this.role_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public add_drop(): Add_dropContext { - let localContext = new Add_dropContext(this.context, this.state); - this.enterRule(localContext, 44, PostgreSqlParser.RULE_add_drop); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2087; - _la = this.tokenStream.LA(1); - if(!(_la === 133 || _la === 191)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createschemastmt(): CreateschemastmtContext { - let localContext = new CreateschemastmtContext(this.context, this.state); - this.enterRule(localContext, 46, PostgreSqlParser.RULE_createschemastmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2089; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 2090; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 2092; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 26, this.context) ) { - case 1: - { - this.state = 2091; - this.opt_if_not_exists(); - } - break; - } - this.state = 2100; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 28, this.context) ) { - case 1: - { - this.state = 2095; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { - { - this.state = 2094; - this.schema_name_create(); - } - } - - this.state = 2097; - this.match(PostgreSqlParser.KW_AUTHORIZATION); - this.state = 2098; - this.rolespec(); - } - break; - case 2: - { - this.state = 2099; - this.schema_name_create(); - } - break; - } - this.state = 2102; - this.optschemaeltlist(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public schema_name_create(): Schema_name_createContext { - let localContext = new Schema_name_createContext(this.context, this.state); - this.enterRule(localContext, 48, PostgreSqlParser.RULE_schema_name_create); - let _la: number; - try { - localContext = new SchemaNameCreateContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 2104; - this.colid(); - this.state = 2106; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 11) { - { - this.state = 2105; - this.attrs(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public optschemaeltlist(): OptschemaeltlistContext { - let localContext = new OptschemaeltlistContext(this.context, this.state); - this.enterRule(localContext, 50, PostgreSqlParser.RULE_optschemaeltlist); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 2111; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 30, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 2108; - this.schema_stmt(); - } - } - } - this.state = 2113; + this.state = 1244; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 30, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public schema_stmt(): Schema_stmtContext { - let localContext = new Schema_stmtContext(this.context, this.state); - this.enterRule(localContext, 52, PostgreSqlParser.RULE_schema_stmt); - try { - this.state = 2120; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 31, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 2114; - this.createstmt(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 2115; - this.indexstmt(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 2116; - this.createseqstmt(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 2117; - this.createtrigstmt(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 2118; - this.grantstmt(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 2119; - this.viewstmt(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public variablesetstmt(): VariablesetstmtContext { - let localContext = new VariablesetstmtContext(this.context, this.state); - this.enterRule(localContext, 54, PostgreSqlParser.RULE_variablesetstmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2122; - this.match(PostgreSqlParser.KW_SET); - this.state = 2124; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 32, this.context) ) { - case 1: - { - this.state = 2123; - _la = this.tokenStream.LA(1); - if(!(_la === 254 || _la === 332)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - break; - } - this.state = 2126; - this.set_rest(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public set_rest(): Set_restContext { - let localContext = new Set_restContext(this.context, this.state); - this.enterRule(localContext, 56, PostgreSqlParser.RULE_set_rest); - try { - this.state = 2136; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 33, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 2128; - this.match(PostgreSqlParser.KW_TRANSACTION); - this.state = 2129; - this.transaction_mode_list(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 2130; - this.match(PostgreSqlParser.KW_SESSION); - this.state = 2131; - this.match(PostgreSqlParser.KW_CHARACTERISTICS); - this.state = 2132; - this.match(PostgreSqlParser.KW_AS); - this.state = 2133; - this.match(PostgreSqlParser.KW_TRANSACTION); - this.state = 2134; - this.transaction_mode_list(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 2135; - this.set_rest_more(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 1242; + this.colid(); + } + break; + case PostgreSqlParser.KW_ALL: + { + this.state = 1243; + this.match(PostgreSqlParser.KW_ALL); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; this.errorHandler.reportError(this, re); this.errorHandler.recover(this, re); } else { @@ -4836,20 +4217,387 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public generic_set(): Generic_setContext { - let localContext = new Generic_setContext(this.context, this.state); - this.enterRule(localContext, 58, PostgreSqlParser.RULE_generic_set); + public creategroupstmt(): CreategroupstmtContext { + let localContext = new CreategroupstmtContext(this.context, this.state); + this.enterRule(localContext, 26, PostgreSqlParser.RULE_creategroupstmt); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 1248; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 1249; + this.match(PostgreSqlParser.KW_GROUP); + this.state = 1250; + this.rolespec(); + this.state = 1252; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 26, this.context) ) { + case 1: + { + this.state = 1251; + this.match(PostgreSqlParser.KW_WITH); + } + break; + } + this.state = 1257; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 27, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1254; + this.createoptroleelem(); + } + } + } + this.state = 1259; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 27, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public altergroupstmt(): AltergroupstmtContext { + let localContext = new AltergroupstmtContext(this.context, this.state); + this.enterRule(localContext, 28, PostgreSqlParser.RULE_altergroupstmt); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1260; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1261; + this.match(PostgreSqlParser.KW_GROUP); + this.state = 1262; + this.rolespec(); + this.state = 1263; + _la = this.tokenStream.LA(1); + if(!(_la === 133 || _la === 191)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1264; + this.match(PostgreSqlParser.KW_USER); + this.state = 1265; + this.role_list(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public createschemastmt(): CreateschemastmtContext { + let localContext = new CreateschemastmtContext(this.context, this.state); + this.enterRule(localContext, 30, PostgreSqlParser.RULE_createschemastmt); let _la: number; try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 2140; + this.state = 1267; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 1268; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 1270; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_ALL: + switch (this.interpreter.adaptivePredict(this.tokenStream, 28, this.context) ) { + case 1: { - this.state = 2138; - this.match(PostgreSqlParser.KW_ALL); + this.state = 1269; + this.opt_if_not_exists(); + } + break; + } + this.state = 1278; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 30, this.context) ) { + case 1: + { + this.state = 1273; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { + { + this.state = 1272; + this.schema_name_create(); + } + } + + this.state = 1275; + this.match(PostgreSqlParser.KW_AUTHORIZATION); + this.state = 1276; + this.rolespec(); + } + break; + case 2: + { + this.state = 1277; + this.schema_name_create(); + } + break; + } + this.state = 1283; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 31, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1280; + this.schema_stmt(); + } + } + } + this.state = 1285; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 31, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public schema_name_create(): Schema_name_createContext { + let localContext = new Schema_name_createContext(this.context, this.state); + this.enterRule(localContext, 32, PostgreSqlParser.RULE_schema_name_create); + try { + localContext = new SchemaNameCreateContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 1286; + this.any_name(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public schema_stmt(): Schema_stmtContext { + let localContext = new Schema_stmtContext(this.context, this.state); + this.enterRule(localContext, 34, PostgreSqlParser.RULE_schema_stmt); + try { + this.state = 1294; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 32, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1288; + this.createstmt(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1289; + this.indexstmt(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1290; + this.createseqstmt(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 1291; + this.createtrigstmt(); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 1292; + this.grantstmt(); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 1293; + this.viewstmt(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public variablesetstmt(): VariablesetstmtContext { + let localContext = new VariablesetstmtContext(this.context, this.state); + this.enterRule(localContext, 36, PostgreSqlParser.RULE_variablesetstmt); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1296; + this.match(PostgreSqlParser.KW_SET); + this.state = 1298; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 33, this.context) ) { + case 1: + { + this.state = 1297; + _la = this.tokenStream.LA(1); + if(!(_la === 254 || _la === 332)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + this.state = 1300; + this.set_rest(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public set_rest(): Set_restContext { + let localContext = new Set_restContext(this.context, this.state); + this.enterRule(localContext, 38, PostgreSqlParser.RULE_set_rest); + try { + this.state = 1310; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 34, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 1302; + this.match(PostgreSqlParser.KW_TRANSACTION); + this.state = 1303; + this.transaction_mode_list(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 1304; + this.match(PostgreSqlParser.KW_SESSION); + this.state = 1305; + this.match(PostgreSqlParser.KW_CHARACTERISTICS); + this.state = 1306; + this.match(PostgreSqlParser.KW_AS); + this.state = 1307; + this.match(PostgreSqlParser.KW_TRANSACTION); + this.state = 1308; + this.transaction_mode_list(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1309; + this.set_rest_more(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public generic_set(): Generic_setContext { + let localContext = new Generic_setContext(this.context, this.state); + this.enterRule(localContext, 40, PostgreSqlParser.RULE_generic_set); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1314; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_ALL: + { + this.state = 1312; + this.match(PostgreSqlParser.KW_ALL); } break; case PostgreSqlParser.KW_AND: @@ -5252,19 +5000,19 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 2139; + this.state = 1313; this.var_name(); } break; default: throw new antlr.NoViableAltException(this); } - this.state = 2143; + this.state = 1317; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 10 || _la === 94) { { - this.state = 2142; + this.state = 1316; _la = this.tokenStream.LA(1); if(!(_la === 10 || _la === 94)) { this.errorHandler.recoverInline(this); @@ -5276,18 +5024,18 @@ export class PostgreSqlParser extends SQLParserBase { } } - this.state = 2147; + this.state = 1321; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 36, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 37, this.context) ) { case 1: { - this.state = 2145; + this.state = 1319; this.match(PostgreSqlParser.KW_DEFAULT); } break; case 2: { - this.state = 2146; + this.state = 1320; this.var_list(); } break; @@ -5310,52 +5058,58 @@ export class PostgreSqlParser extends SQLParserBase { } public set_rest_more(): Set_rest_moreContext { let localContext = new Set_rest_moreContext(this.context, this.state); - this.enterRule(localContext, 60, PostgreSqlParser.RULE_set_rest_more); + this.enterRule(localContext, 42, PostgreSqlParser.RULE_set_rest_more); try { - this.state = 2176; + this.state = 1351; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 38, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 39, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2149; + this.state = 1323; this.match(PostgreSqlParser.KW_TIME); - this.state = 2150; + this.state = 1324; this.match(PostgreSqlParser.KW_ZONE); - this.state = 2151; + this.state = 1325; this.zone_value(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2152; + this.state = 1326; this.match(PostgreSqlParser.KW_CATALOG); - this.state = 2153; + this.state = 1327; this.sconst(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2154; + this.state = 1328; this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 2155; + this.state = 1329; this.schema_name(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 2156; + this.state = 1330; this.match(PostgreSqlParser.KW_NAMES); - this.state = 2158; + this.state = 1333; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 37, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 38, this.context) ) { case 1: { - this.state = 2157; - this.opt_encoding(); + this.state = 1331; + this.sconst(); + } + break; + case 2: + { + this.state = 1332; + this.match(PostgreSqlParser.KW_DEFAULT); } break; } @@ -5364,60 +5118,60 @@ export class PostgreSqlParser extends SQLParserBase { case 5: this.enterOuterAlt(localContext, 5); { - this.state = 2160; + this.state = 1335; this.match(PostgreSqlParser.KW_ROLE); - this.state = 2161; + this.state = 1336; this.nonreservedword_or_sconst(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 2162; + this.state = 1337; this.match(PostgreSqlParser.KW_SESSION); - this.state = 2163; + this.state = 1338; this.match(PostgreSqlParser.KW_AUTHORIZATION); - this.state = 2164; + this.state = 1339; this.nonreservedword_or_sconst(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 2165; + this.state = 1340; this.match(PostgreSqlParser.KW_XML); - this.state = 2166; + this.state = 1341; this.match(PostgreSqlParser.KW_OPTION); - this.state = 2167; + this.state = 1342; this.document_or_content(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 2168; + this.state = 1343; this.match(PostgreSqlParser.KW_TRANSACTION); - this.state = 2169; + this.state = 1344; this.match(PostgreSqlParser.KW_SNAPSHOT); - this.state = 2170; + this.state = 1345; this.sconst(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 2171; + this.state = 1346; this.var_name(); - this.state = 2172; + this.state = 1347; this.match(PostgreSqlParser.KW_FROM); - this.state = 2173; + this.state = 1348; this.match(PostgreSqlParser.KW_CURRENT); } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 2175; + this.state = 1350; this.generic_set(); } break; @@ -5439,26 +5193,26 @@ export class PostgreSqlParser extends SQLParserBase { } public var_name(): Var_nameContext { let localContext = new Var_nameContext(this.context, this.state); - this.enterRule(localContext, 62, PostgreSqlParser.RULE_var_name); + this.enterRule(localContext, 44, PostgreSqlParser.RULE_var_name); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2178; + this.state = 1353; this.colid(); - this.state = 2183; + this.state = 1358; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 11) { { { - this.state = 2179; + this.state = 1354; this.match(PostgreSqlParser.DOT); - this.state = 2180; + this.state = 1355; this.colid(); } } - this.state = 2185; + this.state = 1360; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -5480,26 +5234,26 @@ export class PostgreSqlParser extends SQLParserBase { } public var_list(): Var_listContext { let localContext = new Var_listContext(this.context, this.state); - this.enterRule(localContext, 64, PostgreSqlParser.RULE_var_list); + this.enterRule(localContext, 46, PostgreSqlParser.RULE_var_list); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2186; + this.state = 1361; this.var_value(); - this.state = 2191; + this.state = 1366; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 2187; + this.state = 1362; this.match(PostgreSqlParser.COMMA); - this.state = 2188; + this.state = 1363; this.var_value(); } } - this.state = 2193; + this.state = 1368; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -5521,9 +5275,9 @@ export class PostgreSqlParser extends SQLParserBase { } public var_value(): Var_valueContext { let localContext = new Var_valueContext(this.context, this.state); - this.enterRule(localContext, 66, PostgreSqlParser.RULE_var_value); + this.enterRule(localContext, 48, PostgreSqlParser.RULE_var_value); try { - this.state = 2196; + this.state = 1371; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_AND: @@ -5951,7 +5705,7 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.EscapeStringConstant: this.enterOuterAlt(localContext, 1); { - this.state = 2194; + this.state = 1369; this.opt_boolean_or_string(); } break; @@ -5961,7 +5715,7 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.Numeric: this.enterOuterAlt(localContext, 2); { - this.state = 2195; + this.state = 1370; this.numericonly(); } break; @@ -5985,18 +5739,18 @@ export class PostgreSqlParser extends SQLParserBase { } public iso_level(): Iso_levelContext { let localContext = new Iso_levelContext(this.context, this.state); - this.enterRule(localContext, 68, PostgreSqlParser.RULE_iso_level); + this.enterRule(localContext, 50, PostgreSqlParser.RULE_iso_level); let _la: number; try { - this.state = 2203; + this.state = 1378; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_READ: this.enterOuterAlt(localContext, 1); { - this.state = 2198; + this.state = 1373; this.match(PostgreSqlParser.KW_READ); - this.state = 2199; + this.state = 1374; _la = this.tokenStream.LA(1); if(!(_la === 162 || _la === 363)) { this.errorHandler.recoverInline(this); @@ -6010,16 +5764,16 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_REPEATABLE: this.enterOuterAlt(localContext, 2); { - this.state = 2200; + this.state = 1375; this.match(PostgreSqlParser.KW_REPEATABLE); - this.state = 2201; + this.state = 1376; this.match(PostgreSqlParser.KW_READ); } break; case PostgreSqlParser.KW_SERIALIZABLE: this.enterOuterAlt(localContext, 3); { - this.state = 2202; + this.state = 1377; this.match(PostgreSqlParser.KW_SERIALIZABLE); } break; @@ -6043,37 +5797,51 @@ export class PostgreSqlParser extends SQLParserBase { } public opt_boolean_or_string_column(): Opt_boolean_or_string_columnContext { let localContext = new Opt_boolean_or_string_columnContext(this.context, this.state); - this.enterRule(localContext, 70, PostgreSqlParser.RULE_opt_boolean_or_string_column); + this.enterRule(localContext, 52, PostgreSqlParser.RULE_opt_boolean_or_string_column); try { - this.state = 2209; + this.state = 1386; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 43, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 44, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2205; + this.state = 1380; this.match(PostgreSqlParser.KW_TRUE); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2206; + this.state = 1381; this.match(PostgreSqlParser.KW_FALSE); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2207; + this.state = 1382; this.match(PostgreSqlParser.KW_ON); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 2208; - this.nonreservedword_or_sconst_column(); + this.state = 1383; + this.column_name(); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 1384; + this.type_func_name_keyword(); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 1385; + this.sconst(); } break; } @@ -6094,29 +5862,29 @@ export class PostgreSqlParser extends SQLParserBase { } public opt_boolean_or_string(): Opt_boolean_or_stringContext { let localContext = new Opt_boolean_or_stringContext(this.context, this.state); - this.enterRule(localContext, 72, PostgreSqlParser.RULE_opt_boolean_or_string); + this.enterRule(localContext, 54, PostgreSqlParser.RULE_opt_boolean_or_string); try { - this.state = 2215; + this.state = 1392; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_TRUE: this.enterOuterAlt(localContext, 1); { - this.state = 2211; + this.state = 1388; this.match(PostgreSqlParser.KW_TRUE); } break; case PostgreSqlParser.KW_FALSE: this.enterOuterAlt(localContext, 2); { - this.state = 2212; + this.state = 1389; this.match(PostgreSqlParser.KW_FALSE); } break; case PostgreSqlParser.KW_ON: this.enterOuterAlt(localContext, 3); { - this.state = 2213; + this.state = 1390; this.match(PostgreSqlParser.KW_ON); } break; @@ -6542,7 +6310,7 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.EscapeStringConstant: this.enterOuterAlt(localContext, 4); { - this.state = 2214; + this.state = 1391; this.nonreservedword_or_sconst(); } break; @@ -6566,77 +6334,73 @@ export class PostgreSqlParser extends SQLParserBase { } public zone_value(): Zone_valueContext { let localContext = new Zone_valueContext(this.context, this.state); - this.enterRule(localContext, 74, PostgreSqlParser.RULE_zone_value); + this.enterRule(localContext, 56, PostgreSqlParser.RULE_zone_value); try { - this.state = 2233; + this.state = 1408; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 46, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 47, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2217; + this.state = 1394; this.sconst(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2218; - this.identifier(); + this.state = 1395; + this.match(PostgreSqlParser.KW_DEFAULT); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2219; - this.constinterval(); - this.state = 2220; + this.state = 1396; + this.identifier(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 1397; + this.match(PostgreSqlParser.KW_INTERVAL); + this.state = 1398; this.sconst(); - this.state = 2222; + this.state = 1400; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 45, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 46, this.context) ) { case 1: { - this.state = 2221; + this.state = 1399; this.opt_interval(); } break; } } break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 2224; - this.constinterval(); - this.state = 2225; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 2226; - this.iconst(); - this.state = 2227; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 2228; - this.sconst(); - } - break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 2230; - this.numericonly(); + this.state = 1402; + this.match(PostgreSqlParser.KW_INTERVAL); + this.state = 1403; + this.opt_float(); + this.state = 1404; + this.sconst(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 2231; - this.match(PostgreSqlParser.KW_DEFAULT); + this.state = 1406; + this.numericonly(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 2232; + this.state = 1407; this.match(PostgreSqlParser.KW_LOCAL); } break; @@ -6656,32 +6420,27 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_encoding(): Opt_encodingContext { - let localContext = new Opt_encodingContext(this.context, this.state); - this.enterRule(localContext, 76, PostgreSqlParser.RULE_opt_encoding); + public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext { + let localContext = new Nonreservedword_or_sconstContext(this.context, this.state); + this.enterRule(localContext, 58, PostgreSqlParser.RULE_nonreservedword_or_sconst); try { - this.state = 2237; + this.state = 1412; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.EscapeStringConstant: + switch (this.interpreter.adaptivePredict(this.tokenStream, 48, this.context) ) { + case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2235; - this.sconst(); + this.state = 1410; + this.nonreservedword(); } break; - case PostgreSqlParser.KW_DEFAULT: + case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2236; - this.match(PostgreSqlParser.KW_DEFAULT); + this.state = 1411; + this.sconst(); } break; - default: - throw new antlr.NoViableAltException(this); } } catch (re) { @@ -6698,25 +6457,80 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public nonreservedword_or_sconst_column(): Nonreservedword_or_sconst_columnContext { - let localContext = new Nonreservedword_or_sconst_columnContext(this.context, this.state); - this.enterRule(localContext, 78, PostgreSqlParser.RULE_nonreservedword_or_sconst_column); + public variableresetstmt(): VariableresetstmtContext { + let localContext = new VariableresetstmtContext(this.context, this.state); + this.enterRule(localContext, 60, PostgreSqlParser.RULE_variableresetstmt); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 1414; + this.match(PostgreSqlParser.KW_RESET); + this.state = 1415; + this.reset_rest(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public reset_rest(): Reset_restContext { + let localContext = new Reset_restContext(this.context, this.state); + this.enterRule(localContext, 62, PostgreSqlParser.RULE_reset_rest); try { - this.state = 2241; + this.state = 1426; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 48, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 49, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2239; - this.nonreservedword_column(); + this.state = 1417; + this.match(PostgreSqlParser.KW_TIME); + this.state = 1418; + this.match(PostgreSqlParser.KW_ZONE); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2240; - this.sconst(); + this.state = 1419; + this.match(PostgreSqlParser.KW_TRANSACTION); + this.state = 1420; + this.match(PostgreSqlParser.KW_ISOLATION); + this.state = 1421; + this.match(PostgreSqlParser.KW_LEVEL); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 1422; + this.match(PostgreSqlParser.KW_SESSION); + this.state = 1423; + this.match(PostgreSqlParser.KW_AUTHORIZATION); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 1424; + this.match(PostgreSqlParser.KW_ALL); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 1425; + this.var_name(); } break; } @@ -6735,27 +6549,31 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext { - let localContext = new Nonreservedword_or_sconstContext(this.context, this.state); - this.enterRule(localContext, 80, PostgreSqlParser.RULE_nonreservedword_or_sconst); + public setresetclause(): SetresetclauseContext { + let localContext = new SetresetclauseContext(this.context, this.state); + this.enterRule(localContext, 64, PostgreSqlParser.RULE_setresetclause); try { - this.state = 2245; + this.state = 1431; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 49, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_SET: this.enterOuterAlt(localContext, 1); { - this.state = 2243; - this.nonreservedword(); + this.state = 1428; + this.match(PostgreSqlParser.KW_SET); + this.state = 1429; + this.set_rest(); } break; - case 2: + case PostgreSqlParser.KW_RESET: this.enterOuterAlt(localContext, 2); { - this.state = 2244; - this.sconst(); + this.state = 1430; + this.variableresetstmt(); } break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -6772,16 +6590,31 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public variableresetstmt(): VariableresetstmtContext { - let localContext = new VariableresetstmtContext(this.context, this.state); - this.enterRule(localContext, 82, PostgreSqlParser.RULE_variableresetstmt); + public functionsetresetclause(): FunctionsetresetclauseContext { + let localContext = new FunctionsetresetclauseContext(this.context, this.state); + this.enterRule(localContext, 66, PostgreSqlParser.RULE_functionsetresetclause); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2247; - this.match(PostgreSqlParser.KW_RESET); - this.state = 2248; - this.reset_rest(); + this.state = 1436; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_SET: + this.enterOuterAlt(localContext, 1); + { + this.state = 1433; + this.match(PostgreSqlParser.KW_SET); + this.state = 1434; + this.set_rest_more(); + } + break; + case PostgreSqlParser.KW_RESET: + this.enterOuterAlt(localContext, 2); + { + this.state = 1435; + this.variableresetstmt(); + } + break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -6798,50 +6631,57 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public reset_rest(): Reset_restContext { - let localContext = new Reset_restContext(this.context, this.state); - this.enterRule(localContext, 84, PostgreSqlParser.RULE_reset_rest); + public variableshowstmt(): VariableshowstmtContext { + let localContext = new VariableshowstmtContext(this.context, this.state); + this.enterRule(localContext, 68, PostgreSqlParser.RULE_variableshowstmt); try { - this.state = 2258; + this.enterOuterAlt(localContext, 1); + { + this.state = 1438; + this.match(PostgreSqlParser.KW_SHOW); + this.state = 1448; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 50, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 52, this.context) ) { case 1: - this.enterOuterAlt(localContext, 1); { - this.state = 2250; + this.state = 1439; + this.var_name(); + } + break; + case 2: + { + this.state = 1440; this.match(PostgreSqlParser.KW_TIME); - this.state = 2251; + this.state = 1441; this.match(PostgreSqlParser.KW_ZONE); } break; - case 2: - this.enterOuterAlt(localContext, 2); + case 3: { - this.state = 2252; + this.state = 1442; this.match(PostgreSqlParser.KW_TRANSACTION); - this.state = 2253; + this.state = 1443; this.match(PostgreSqlParser.KW_ISOLATION); - this.state = 2254; + this.state = 1444; this.match(PostgreSqlParser.KW_LEVEL); } break; - case 3: - this.enterOuterAlt(localContext, 3); + case 4: { - this.state = 2255; + this.state = 1445; this.match(PostgreSqlParser.KW_SESSION); - this.state = 2256; + this.state = 1446; this.match(PostgreSqlParser.KW_AUTHORIZATION); } break; - case 4: - this.enterOuterAlt(localContext, 4); + case 5: { - this.state = 2257; - this.generic_reset(); + this.state = 1447; + this.match(PostgreSqlParser.KW_ALL); } break; } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -6857,17 +6697,23 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public generic_reset(): Generic_resetContext { - let localContext = new Generic_resetContext(this.context, this.state); - this.enterRule(localContext, 86, PostgreSqlParser.RULE_generic_reset); + public constraintssetstmt(): ConstraintssetstmtContext { + let localContext = new ConstraintssetstmtContext(this.context, this.state); + this.enterRule(localContext, 70, PostgreSqlParser.RULE_constraintssetstmt); + let _la: number; try { - this.state = 2262; + this.enterOuterAlt(localContext, 1); + { + this.state = 1450; + this.match(PostgreSqlParser.KW_SET); + this.state = 1451; + this.match(PostgreSqlParser.KW_CONSTRAINTS); + this.state = 1454; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_ALL: - this.enterOuterAlt(localContext, 1); { - this.state = 2260; + this.state = 1452; this.match(PostgreSqlParser.KW_ALL); } break; @@ -7270,15 +7116,24 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLVARIABLENAME: case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 2); { - this.state = 2261; - this.var_name(); + this.state = 1453; + this.qualified_name_list(); } break; default: throw new antlr.NoViableAltException(this); } + this.state = 1456; + _la = this.tokenStream.LA(1); + if(!(_la === 180 || _la === 221)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -7294,31 +7149,14 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public setresetclause(): SetresetclauseContext { - let localContext = new SetresetclauseContext(this.context, this.state); - this.enterRule(localContext, 88, PostgreSqlParser.RULE_setresetclause); + public checkpointstmt(): CheckpointstmtContext { + let localContext = new CheckpointstmtContext(this.context, this.state); + this.enterRule(localContext, 72, PostgreSqlParser.RULE_checkpointstmt); try { - this.state = 2267; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_SET: - this.enterOuterAlt(localContext, 1); - { - this.state = 2264; - this.match(PostgreSqlParser.KW_SET); - this.state = 2265; - this.set_rest(); - } - break; - case PostgreSqlParser.KW_RESET: - this.enterOuterAlt(localContext, 2); - { - this.state = 2266; - this.variableresetstmt(); - } - break; - default: - throw new antlr.NoViableAltException(this); + this.enterOuterAlt(localContext, 1); + { + this.state = 1458; + this.match(PostgreSqlParser.KW_CHECKPOINT); } } catch (re) { @@ -7335,31 +7173,24 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public functionsetresetclause(): FunctionsetresetclauseContext { - let localContext = new FunctionsetresetclauseContext(this.context, this.state); - this.enterRule(localContext, 90, PostgreSqlParser.RULE_functionsetresetclause); + public discardstmt(): DiscardstmtContext { + let localContext = new DiscardstmtContext(this.context, this.state); + this.enterRule(localContext, 74, PostgreSqlParser.RULE_discardstmt); + let _la: number; try { - this.state = 2272; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_SET: - this.enterOuterAlt(localContext, 1); - { - this.state = 2269; - this.match(PostgreSqlParser.KW_SET); - this.state = 2270; - this.set_rest_more(); - } - break; - case PostgreSqlParser.KW_RESET: - this.enterOuterAlt(localContext, 2); - { - this.state = 2271; - this.variableresetstmt(); - } - break; - default: - throw new antlr.NoViableAltException(this); + this.enterOuterAlt(localContext, 1); + { + this.state = 1460; + this.match(PostgreSqlParser.KW_DISCARD); + this.state = 1461; + _la = this.tokenStream.LA(1); + if(!(_la === 30 || _la === 288 || ((((_la - 329)) & ~0x1F) === 0 && ((1 << (_la - 329)) & 41943041) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } } } catch (re) { @@ -7376,523 +7207,430 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public variableshowstmt(): VariableshowstmtContext { - let localContext = new VariableshowstmtContext(this.context, this.state); - this.enterRule(localContext, 92, PostgreSqlParser.RULE_variableshowstmt); + public altertablestmt(): AltertablestmtContext { + let localContext = new AltertablestmtContext(this.context, this.state); + this.enterRule(localContext, 76, PostgreSqlParser.RULE_altertablestmt); + let _la: number; try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2274; - this.match(PostgreSqlParser.KW_SHOW); - this.state = 2284; + this.state = 1584; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 54, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 72, this.context) ) { case 1: + this.enterOuterAlt(localContext, 1); { - this.state = 2275; - this.var_name(); + this.state = 1463; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1464; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 1466; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 54, this.context) ) { + case 1: + { + this.state = 1465; + this.opt_if_exists(); + } + break; + } + this.state = 1468; + this.relation_expr(); + this.state = 1471; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_NOT: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_VALIDATE: + { + this.state = 1469; + this.alter_table_cmds(); + } + break; + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + { + this.state = 1470; + this.partition_cmd(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } break; case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 2276; - this.match(PostgreSqlParser.KW_TIME); - this.state = 2277; - this.match(PostgreSqlParser.KW_ZONE); + this.state = 1473; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1474; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 1475; + this.match(PostgreSqlParser.KW_ALL); + this.state = 1476; + this.match(PostgreSqlParser.KW_IN); + this.state = 1477; + this.opttablespace(); + this.state = 1481; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 281) { + { + this.state = 1478; + this.match(PostgreSqlParser.KW_OWNED); + this.state = 1479; + this.match(PostgreSqlParser.KW_BY); + this.state = 1480; + this.role_list(); + } + } + + this.state = 1483; + this.match(PostgreSqlParser.KW_SET); + this.state = 1484; + this.match(PostgreSqlParser.KW_TABLESPACE); + this.state = 1485; + this.tablespace_name_create(); + this.state = 1487; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 57, this.context) ) { + case 1: + { + this.state = 1486; + this.match(PostgreSqlParser.KW_NOWAIT); + } + break; + } } break; case 3: + this.enterOuterAlt(localContext, 3); { - this.state = 2278; - this.match(PostgreSqlParser.KW_TRANSACTION); - this.state = 2279; - this.match(PostgreSqlParser.KW_ISOLATION); - this.state = 2280; - this.match(PostgreSqlParser.KW_LEVEL); + this.state = 1489; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1490; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 1492; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 58, this.context) ) { + case 1: + { + this.state = 1491; + this.opt_if_exists(); + } + break; + } + this.state = 1494; + this.table_name(); + this.state = 1495; + this.index_partition_cmd(); + this.state = 1500; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_FOR: + { + this.state = 1496; + this.match(PostgreSqlParser.KW_FOR); + this.state = 1497; + this.match(PostgreSqlParser.KW_VALUES); + this.state = 1498; + this.partition_bound_spec(); + } + break; + case PostgreSqlParser.KW_DEFAULT: + { + this.state = 1499; + this.match(PostgreSqlParser.KW_DEFAULT); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } break; case 4: + this.enterOuterAlt(localContext, 4); { - this.state = 2281; - this.match(PostgreSqlParser.KW_SESSION); - this.state = 2282; - this.match(PostgreSqlParser.KW_AUTHORIZATION); + this.state = 1502; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1503; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 1505; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 60, this.context) ) { + case 1: + { + this.state = 1504; + this.opt_if_exists(); + } + break; + } + this.state = 1507; + this.table_name(); + this.state = 1508; + this.match(PostgreSqlParser.KW_DETACH); + this.state = 1509; + this.match(PostgreSqlParser.KW_PARTITION); + this.state = 1510; + this.qualified_name(); + this.state = 1512; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 109 || _la === 532) { + { + this.state = 1511; + _la = this.tokenStream.LA(1); + if(!(_la === 109 || _la === 532)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + } break; case 5: + this.enterOuterAlt(localContext, 5); { - this.state = 2283; - this.match(PostgreSqlParser.KW_ALL); + this.state = 1514; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1515; + this.match(PostgreSqlParser.KW_INDEX); + this.state = 1517; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 62, this.context) ) { + case 1: + { + this.state = 1516; + this.opt_if_exists(); + } + break; + } + this.state = 1519; + this.qualified_name(); + this.state = 1522; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_NOT: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_VALIDATE: + { + this.state = 1520; + this.alter_table_cmds(); + } + break; + case PostgreSqlParser.KW_ATTACH: + { + this.state = 1521; + this.index_partition_cmd(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public constraintssetstmt(): ConstraintssetstmtContext { - let localContext = new ConstraintssetstmtContext(this.context, this.state); - this.enterRule(localContext, 94, PostgreSqlParser.RULE_constraintssetstmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2286; - this.match(PostgreSqlParser.KW_SET); - this.state = 2287; - this.match(PostgreSqlParser.KW_CONSTRAINTS); - this.state = 2288; - this.constraints_set_list(); - this.state = 2289; - this.constraints_set_mode(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public constraints_set_list(): Constraints_set_listContext { - let localContext = new Constraints_set_listContext(this.context, this.state); - this.enterRule(localContext, 96, PostgreSqlParser.RULE_constraints_set_list); - try { - this.state = 2293; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_ALL: - this.enterOuterAlt(localContext, 1); + case 6: + this.enterOuterAlt(localContext, 6); { - this.state = 2291; + this.state = 1524; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1525; + this.match(PostgreSqlParser.KW_INDEX); + this.state = 1526; this.match(PostgreSqlParser.KW_ALL); + this.state = 1527; + this.match(PostgreSqlParser.KW_IN); + this.state = 1528; + this.opttablespace(); + this.state = 1532; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 281) { + { + this.state = 1529; + this.match(PostgreSqlParser.KW_OWNED); + this.state = 1530; + this.match(PostgreSqlParser.KW_BY); + this.state = 1531; + this.role_list(); + } + } + + this.state = 1534; + this.match(PostgreSqlParser.KW_SET); + this.state = 1535; + this.opttablespace(); + this.state = 1537; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 65, this.context) ) { + case 1: + { + this.state = 1536; + this.match(PostgreSqlParser.KW_NOWAIT); + } + break; + } } break; - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 2); + case 7: + this.enterOuterAlt(localContext, 7); { - this.state = 2292; - this.qualified_name_list(); + this.state = 1539; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1540; + this.match(PostgreSqlParser.KW_SEQUENCE); + this.state = 1542; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 66, this.context) ) { + case 1: + { + this.state = 1541; + this.opt_if_exists(); + } + break; + } + this.state = 1544; + this.qualified_name(); + this.state = 1545; + this.alter_table_cmds(); + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 1547; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1549; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 259) { + { + this.state = 1548; + this.match(PostgreSqlParser.KW_MATERIALIZED); + } + } + + this.state = 1551; + this.match(PostgreSqlParser.KW_VIEW); + this.state = 1553; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 68, this.context) ) { + case 1: + { + this.state = 1552; + this.opt_if_exists(); + } + break; + } + this.state = 1555; + this.view_name(); + this.state = 1556; + this.alter_table_cmds(); + } + break; + case 9: + this.enterOuterAlt(localContext, 9); + { + this.state = 1558; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1559; + this.match(PostgreSqlParser.KW_MATERIALIZED); + this.state = 1560; + this.match(PostgreSqlParser.KW_VIEW); + this.state = 1561; + this.match(PostgreSqlParser.KW_ALL); + this.state = 1562; + this.match(PostgreSqlParser.KW_IN); + this.state = 1563; + this.opttablespace(); + this.state = 1567; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 281) { + { + this.state = 1564; + this.match(PostgreSqlParser.KW_OWNED); + this.state = 1565; + this.match(PostgreSqlParser.KW_BY); + this.state = 1566; + this.role_list(); + } + } + + this.state = 1569; + this.match(PostgreSqlParser.KW_SET); + this.state = 1570; + this.match(PostgreSqlParser.KW_TABLESPACE); + this.state = 1571; + this.tablespace_name_create(); + this.state = 1573; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 70, this.context) ) { + case 1: + { + this.state = 1572; + this.match(PostgreSqlParser.KW_NOWAIT); + } + break; + } + } + break; + case 10: + this.enterOuterAlt(localContext, 10); + { + this.state = 1575; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1576; + this.match(PostgreSqlParser.KW_FOREIGN); + this.state = 1577; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 1579; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 71, this.context) ) { + case 1: + { + this.state = 1578; + this.opt_if_exists(); + } + break; + } + this.state = 1581; + this.relation_expr(); + this.state = 1582; + this.alter_table_cmds(); } break; - default: - throw new antlr.NoViableAltException(this); } } catch (re) { @@ -7909,21 +7647,30 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public constraints_set_mode(): Constraints_set_modeContext { - let localContext = new Constraints_set_modeContext(this.context, this.state); - this.enterRule(localContext, 98, PostgreSqlParser.RULE_constraints_set_mode); + public alter_table_cmds(): Alter_table_cmdsContext { + let localContext = new Alter_table_cmdsContext(this.context, this.state); + this.enterRule(localContext, 78, PostgreSqlParser.RULE_alter_table_cmds); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2295; + this.state = 1586; + this.alter_table_cmd(); + this.state = 1591; + this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if(!(_la === 180 || _la === 221)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); + while (_la === 6) { + { + { + this.state = 1587; + this.match(PostgreSqlParser.COMMA); + this.state = 1588; + this.alter_table_cmd(); + } + } + this.state = 1593; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } } } @@ -7941,607 +7688,41 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public checkpointstmt(): CheckpointstmtContext { - let localContext = new CheckpointstmtContext(this.context, this.state); - this.enterRule(localContext, 100, PostgreSqlParser.RULE_checkpointstmt); + public partition_bound_spec(): Partition_bound_specContext { + let localContext = new Partition_bound_specContext(this.context, this.state); + this.enterRule(localContext, 80, PostgreSqlParser.RULE_partition_bound_spec); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2297; - this.match(PostgreSqlParser.KW_CHECKPOINT); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public discardstmt(): DiscardstmtContext { - let localContext = new DiscardstmtContext(this.context, this.state); - this.enterRule(localContext, 102, PostgreSqlParser.RULE_discardstmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2299; - this.match(PostgreSqlParser.KW_DISCARD); - this.state = 2300; - _la = this.tokenStream.LA(1); - if(!(_la === 30 || _la === 288 || ((((_la - 329)) & ~0x1F) === 0 && ((1 << (_la - 329)) & 41943041) !== 0))) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public altertablestmt(): AltertablestmtContext { - let localContext = new AltertablestmtContext(this.context, this.state); - this.enterRule(localContext, 104, PostgreSqlParser.RULE_altertablestmt); - let _la: number; - try { - this.state = 2435; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 74, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 2302; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2303; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 2305; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 56, this.context) ) { - case 1: - { - this.state = 2304; - this.opt_if_exists(); - } - break; - } - this.state = 2307; - this.relation_expr(); - this.state = 2310; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_NOT: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_VALIDATE: - { - this.state = 2308; - this.alter_table_cmds(); - } - break; - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - { - this.state = 2309; - this.partition_cmd(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 2312; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2313; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 2314; - this.match(PostgreSqlParser.KW_ALL); - this.state = 2315; - this.match(PostgreSqlParser.KW_IN); - this.state = 2316; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 2317; - this.tablespace_name(); - this.state = 2321; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 281) { - { - this.state = 2318; - this.match(PostgreSqlParser.KW_OWNED); - this.state = 2319; - this.match(PostgreSqlParser.KW_BY); - this.state = 2320; - this.role_list(); - } - } - - this.state = 2323; - this.match(PostgreSqlParser.KW_SET); - this.state = 2324; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 2325; - this.tablespace_name_create(); - this.state = 2327; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 59, this.context) ) { - case 1: - { - this.state = 2326; - this.opt_nowait(); - } - break; - } - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 2329; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2330; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 2332; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 60, this.context) ) { - case 1: - { - this.state = 2331; - this.opt_if_exists(); - } - break; - } - this.state = 2334; - this.table_name(); - this.state = 2335; - this.match(PostgreSqlParser.KW_ATTACH); - this.state = 2336; - this.match(PostgreSqlParser.KW_PARTITION); - this.state = 2337; - this.qualified_name(); - this.state = 2342; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_FOR: - { - this.state = 2338; - this.match(PostgreSqlParser.KW_FOR); - this.state = 2339; - this.match(PostgreSqlParser.KW_VALUES); - this.state = 2340; - this.partition_bound_spec(); - } - break; - case PostgreSqlParser.KW_DEFAULT: - { - this.state = 2341; - this.match(PostgreSqlParser.KW_DEFAULT); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 2344; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2345; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 2347; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 62, this.context) ) { - case 1: - { - this.state = 2346; - this.opt_if_exists(); - } - break; - } - this.state = 2349; - this.table_name(); - this.state = 2350; - this.match(PostgreSqlParser.KW_DETACH); - this.state = 2351; - this.match(PostgreSqlParser.KW_PARTITION); - this.state = 2352; - this.qualified_name(); - this.state = 2354; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 109 || _la === 532) { - { - this.state = 2353; - _la = this.tokenStream.LA(1); - if(!(_la === 109 || _la === 532)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 2356; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2357; - this.match(PostgreSqlParser.KW_INDEX); - this.state = 2359; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 64, this.context) ) { - case 1: - { - this.state = 2358; - this.opt_if_exists(); - } - break; - } - this.state = 2361; - this.qualified_name(); - this.state = 2364; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_NOT: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_VALIDATE: - { - this.state = 2362; - this.alter_table_cmds(); - } - break; - case PostgreSqlParser.KW_ATTACH: - { - this.state = 2363; - this.index_partition_cmd(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 2366; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2367; - this.match(PostgreSqlParser.KW_INDEX); - this.state = 2368; - this.match(PostgreSqlParser.KW_ALL); - this.state = 2369; - this.match(PostgreSqlParser.KW_IN); - this.state = 2370; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 2371; - this.tablespace_name(); - this.state = 2375; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 281) { - { - this.state = 2372; - this.match(PostgreSqlParser.KW_OWNED); - this.state = 2373; - this.match(PostgreSqlParser.KW_BY); - this.state = 2374; - this.role_list(); - } - } - - this.state = 2377; - this.match(PostgreSqlParser.KW_SET); - this.state = 2378; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 2379; - this.tablespace_name(); - this.state = 2381; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 67, this.context) ) { - case 1: - { - this.state = 2380; - this.opt_nowait(); - } - break; - } - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 2383; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2384; - this.match(PostgreSqlParser.KW_SEQUENCE); - this.state = 2386; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 68, this.context) ) { - case 1: - { - this.state = 2385; - this.opt_if_exists(); - } - break; - } - this.state = 2388; - this.qualified_name(); - this.state = 2389; - this.alter_table_cmds(); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 2391; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2392; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 2394; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 69, this.context) ) { - case 1: - { - this.state = 2393; - this.opt_if_exists(); - } - break; - } - this.state = 2396; - this.view_name(); - this.state = 2397; - this.alter_table_cmds(); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 2399; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2400; - this.match(PostgreSqlParser.KW_MATERIALIZED); - this.state = 2401; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 2403; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 70, this.context) ) { - case 1: - { - this.state = 2402; - this.opt_if_exists(); - } - break; - } - this.state = 2405; - this.view_name(); - this.state = 2406; - this.alter_table_cmds(); - } - break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 2408; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2409; - this.match(PostgreSqlParser.KW_MATERIALIZED); - this.state = 2410; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 2411; - this.match(PostgreSqlParser.KW_ALL); - this.state = 2412; - this.match(PostgreSqlParser.KW_IN); - this.state = 2413; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 2414; - this.tablespace_name(); - this.state = 2418; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 281) { - { - this.state = 2415; - this.match(PostgreSqlParser.KW_OWNED); - this.state = 2416; - this.match(PostgreSqlParser.KW_BY); - this.state = 2417; - this.role_list(); - } - } - - this.state = 2420; - this.match(PostgreSqlParser.KW_SET); - this.state = 2421; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 2422; - this.tablespace_name_create(); - this.state = 2424; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 72, this.context) ) { - case 1: - { - this.state = 2423; - this.opt_nowait(); - } - break; - } - } - break; - case 11: - this.enterOuterAlt(localContext, 11); - { - this.state = 2426; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2427; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 2428; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 2430; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 73, this.context) ) { - case 1: - { - this.state = 2429; - this.opt_if_exists(); - } - break; - } - this.state = 2432; - this.relation_expr(); - this.state = 2433; - this.alter_table_cmds(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alter_table_cmds(): Alter_table_cmdsContext { - let localContext = new Alter_table_cmdsContext(this.context, this.state); - this.enterRule(localContext, 106, PostgreSqlParser.RULE_alter_table_cmds); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2437; - this.alter_table_cmd(); - this.state = 2442; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 2438; - this.match(PostgreSqlParser.COMMA); - this.state = 2439; - this.alter_table_cmd(); - } - } - this.state = 2444; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public partition_bound_spec(): Partition_bound_specContext { - let localContext = new Partition_bound_specContext(this.context, this.state); - this.enterRule(localContext, 108, PostgreSqlParser.RULE_partition_bound_spec); - try { - this.state = 2454; + this.state = 1603; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_IN: this.enterOuterAlt(localContext, 1); { - this.state = 2445; + this.state = 1594; this.match(PostgreSqlParser.KW_IN); - this.state = 2446; - this.opt_type_modifiers(); + this.state = 1595; + this.execute_param_clause(); } break; case PostgreSqlParser.KW_FROM: this.enterOuterAlt(localContext, 2); { - this.state = 2447; + this.state = 1596; this.match(PostgreSqlParser.KW_FROM); - this.state = 2448; + this.state = 1597; this.partition_bound_cluase(); - this.state = 2449; + this.state = 1598; this.match(PostgreSqlParser.KW_TO); - this.state = 2450; + this.state = 1599; this.partition_bound_cluase(); } break; case PostgreSqlParser.KW_WITH: this.enterOuterAlt(localContext, 3); { - this.state = 2452; + this.state = 1601; this.match(PostgreSqlParser.KW_WITH); - this.state = 2453; + this.state = 1602; this.partition_with_cluase(); } break; @@ -8565,32 +7746,32 @@ export class PostgreSqlParser extends SQLParserBase { } public partition_bound_cluase(): Partition_bound_cluaseContext { let localContext = new Partition_bound_cluaseContext(this.context, this.state); - this.enterRule(localContext, 110, PostgreSqlParser.RULE_partition_bound_cluase); + this.enterRule(localContext, 82, PostgreSqlParser.RULE_partition_bound_cluase); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2456; + this.state = 1605; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 2457; + this.state = 1606; this.partition_bound_choose(); - this.state = 2462; + this.state = 1611; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 2458; + this.state = 1607; this.match(PostgreSqlParser.COMMA); - this.state = 2459; + this.state = 1608; this.partition_bound_choose(); } } - this.state = 2464; + this.state = 1613; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 2465; + this.state = 1614; this.match(PostgreSqlParser.CLOSE_PAREN); } } @@ -8610,29 +7791,29 @@ export class PostgreSqlParser extends SQLParserBase { } public partition_bound_choose(): Partition_bound_chooseContext { let localContext = new Partition_bound_chooseContext(this.context, this.state); - this.enterRule(localContext, 112, PostgreSqlParser.RULE_partition_bound_choose); + this.enterRule(localContext, 84, PostgreSqlParser.RULE_partition_bound_choose); try { - this.state = 2470; + this.state = 1619; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.OPEN_PAREN: this.enterOuterAlt(localContext, 1); { - this.state = 2467; - this.opt_type_modifiers(); + this.state = 1616; + this.execute_param_clause(); } break; case PostgreSqlParser.KW_MINVALUE: this.enterOuterAlt(localContext, 2); { - this.state = 2468; + this.state = 1617; this.match(PostgreSqlParser.KW_MINVALUE); } break; case PostgreSqlParser.KW_MAXVALUE: this.enterOuterAlt(localContext, 3); { - this.state = 2469; + this.state = 1618; this.match(PostgreSqlParser.KW_MAXVALUE); } break; @@ -8656,23 +7837,23 @@ export class PostgreSqlParser extends SQLParserBase { } public partition_with_cluase(): Partition_with_cluaseContext { let localContext = new Partition_with_cluaseContext(this.context, this.state); - this.enterRule(localContext, 114, PostgreSqlParser.RULE_partition_with_cluase); + this.enterRule(localContext, 86, PostgreSqlParser.RULE_partition_with_cluase); try { this.enterOuterAlt(localContext, 1); { - this.state = 2472; + this.state = 1621; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 2473; + this.state = 1622; this.match(PostgreSqlParser.KW_MODULUS); - this.state = 2474; + this.state = 1623; this.numericonly(); - this.state = 2475; + this.state = 1624; this.match(PostgreSqlParser.COMMA); - this.state = 2476; + this.state = 1625; this.match(PostgreSqlParser.KW_REMAINDER); - this.state = 2477; + this.state = 1626; this.numericonly(); - this.state = 2478; + this.state = 1627; this.match(PostgreSqlParser.CLOSE_PAREN); } } @@ -8692,32 +7873,28 @@ export class PostgreSqlParser extends SQLParserBase { } public partition_cmd(): Partition_cmdContext { let localContext = new Partition_cmdContext(this.context, this.state); - this.enterRule(localContext, 116, PostgreSqlParser.RULE_partition_cmd); + this.enterRule(localContext, 88, PostgreSqlParser.RULE_partition_cmd); try { - this.state = 2488; + this.state = 1635; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_ATTACH: this.enterOuterAlt(localContext, 1); { - this.state = 2480; - this.match(PostgreSqlParser.KW_ATTACH); - this.state = 2481; - this.match(PostgreSqlParser.KW_PARTITION); - this.state = 2482; - this.qualified_name(); - this.state = 2483; + this.state = 1629; + this.index_partition_cmd(); + this.state = 1630; this.partitionboundspec(); } break; case PostgreSqlParser.KW_DETACH: this.enterOuterAlt(localContext, 2); { - this.state = 2485; + this.state = 1632; this.match(PostgreSqlParser.KW_DETACH); - this.state = 2486; + this.state = 1633; this.match(PostgreSqlParser.KW_PARTITION); - this.state = 2487; + this.state = 1634; this.qualified_name(); } break; @@ -8741,15 +7918,15 @@ export class PostgreSqlParser extends SQLParserBase { } public index_partition_cmd(): Index_partition_cmdContext { let localContext = new Index_partition_cmdContext(this.context, this.state); - this.enterRule(localContext, 118, PostgreSqlParser.RULE_index_partition_cmd); + this.enterRule(localContext, 90, PostgreSqlParser.RULE_index_partition_cmd); try { this.enterOuterAlt(localContext, 1); { - this.state = 2490; + this.state = 1637; this.match(PostgreSqlParser.KW_ATTACH); - this.state = 2491; + this.state = 1638; this.match(PostgreSqlParser.KW_PARTITION); - this.state = 2492; + this.state = 1639; this.qualified_name(); } } @@ -8769,82 +7946,97 @@ export class PostgreSqlParser extends SQLParserBase { } public alter_table_cmd(): Alter_table_cmdContext { let localContext = new Alter_table_cmdContext(this.context, this.state); - this.enterRule(localContext, 120, PostgreSqlParser.RULE_alter_table_cmd); + this.enterRule(localContext, 92, PostgreSqlParser.RULE_alter_table_cmd); let _la: number; try { - this.state = 2711; + let alternative: number; + this.state = 1874; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 108, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 117, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2494; + this.state = 1641; this.match(PostgreSqlParser.KW_ADD); - this.state = 2497; + this.state = 1644; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 45) { { - this.state = 2495; + this.state = 1642; this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 2496; - this.name(); + this.state = 1643; + this.colid(); } } - this.state = 2499; + this.state = 1646; this.constraintelem(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2500; + this.state = 1647; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2501; + this.state = 1648; this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 2502; - this.name(); - this.state = 2503; - this.constraintattributespec(); + this.state = 1649; + this.colid(); + this.state = 1653; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 79, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 1650; + this.constraintattributeElem(); + } + } + } + this.state = 1655; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 79, this.context); + } } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2505; + this.state = 1656; this.match(PostgreSqlParser.KW_VALIDATE); - this.state = 2506; + this.state = 1657; this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 2507; - this.name(); + this.state = 1658; + this.colid(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 2508; + this.state = 1659; this.match(PostgreSqlParser.KW_DROP); - this.state = 2509; + this.state = 1660; this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 2511; + this.state = 1662; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 81, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 80, this.context) ) { case 1: { - this.state = 2510; + this.state = 1661; this.opt_if_exists(); } break; } - this.state = 2513; - this.name(); - this.state = 2515; + this.state = 1664; + this.colid(); + this.state = 1666; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 82, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 81, this.context) ) { case 1: { - this.state = 2514; + this.state = 1665; this.opt_drop_behavior(); } break; @@ -8854,42 +8046,38 @@ export class PostgreSqlParser extends SQLParserBase { case 5: this.enterOuterAlt(localContext, 5); { - this.state = 2517; + this.state = 1668; this.match(PostgreSqlParser.KW_SET); - this.state = 2518; + this.state = 1669; this.match(PostgreSqlParser.KW_WITHOUT); - this.state = 2519; - this.match(PostgreSqlParser.KW_OIDS); + this.state = 1670; + _la = this.tokenStream.LA(1); + if(!(_la === 158 || _la === 277)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 2520; + this.state = 1671; this.match(PostgreSqlParser.KW_CLUSTER); - this.state = 2521; + this.state = 1672; this.match(PostgreSqlParser.KW_ON); - this.state = 2522; - this.name(); + this.state = 1673; + this.colid(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 2523; + this.state = 1674; this.match(PostgreSqlParser.KW_SET); - this.state = 2524; - this.match(PostgreSqlParser.KW_WITHOUT); - this.state = 2525; - this.match(PostgreSqlParser.KW_CLUSTER); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 2526; - this.match(PostgreSqlParser.KW_SET); - this.state = 2527; + this.state = 1675; _la = this.tokenStream.LA(1); if(!(_la === 367 || _la === 439)) { this.errorHandler.recoverInline(this); @@ -8900,17 +8088,17 @@ export class PostgreSqlParser extends SQLParserBase { } } break; - case 9: - this.enterOuterAlt(localContext, 9); + case 8: + this.enterOuterAlt(localContext, 8); { - this.state = 2528; + this.state = 1676; this.match(PostgreSqlParser.KW_ENABLE); - this.state = 2530; + this.state = 1678; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 139 || _la === 312) { { - this.state = 2529; + this.state = 1677; _la = this.tokenStream.LA(1); if(!(_la === 139 || _la === 312)) { this.errorHandler.recoverInline(this); @@ -8922,29 +8110,29 @@ export class PostgreSqlParser extends SQLParserBase { } } - this.state = 2532; + this.state = 1680; this.match(PostgreSqlParser.KW_TRIGGER); } break; - case 10: - this.enterOuterAlt(localContext, 10); + case 9: + this.enterOuterAlt(localContext, 9); { - this.state = 2533; + this.state = 1681; this.match(PostgreSqlParser.KW_DISABLE); - this.state = 2534; + this.state = 1682; this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 2538; + this.state = 1686; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_ALL: { - this.state = 2535; + this.state = 1683; this.match(PostgreSqlParser.KW_ALL); } break; case PostgreSqlParser.KW_USER: { - this.state = 2536; + this.state = 1684; this.match(PostgreSqlParser.KW_USER); } break; @@ -9348,8 +8536,8 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 2537; - this.name(); + this.state = 1685; + this.colid(); } break; default: @@ -9357,12 +8545,12 @@ export class PostgreSqlParser extends SQLParserBase { } } break; - case 11: - this.enterOuterAlt(localContext, 11); + case 10: + this.enterOuterAlt(localContext, 10); { - this.state = 2540; + this.state = 1688; this.match(PostgreSqlParser.KW_ENABLE); - this.state = 2541; + this.state = 1689; _la = this.tokenStream.LA(1); if(!(_la === 139 || _la === 312)) { this.errorHandler.recoverInline(this); @@ -9371,272 +8559,293 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 2542; + this.state = 1690; this.match(PostgreSqlParser.KW_RULE); - this.state = 2543; - this.name(); + this.state = 1691; + this.colid(); } break; - case 12: - this.enterOuterAlt(localContext, 12); + case 11: + this.enterOuterAlt(localContext, 11); { - this.state = 2544; + this.state = 1692; this.match(PostgreSqlParser.KW_DISABLE); - this.state = 2545; + this.state = 1693; this.match(PostgreSqlParser.KW_RULE); - this.state = 2546; - this.name(); + this.state = 1694; + this.colid(); } break; - case 13: - this.enterOuterAlt(localContext, 13); + case 12: + this.enterOuterAlt(localContext, 12); { - this.state = 2548; + this.state = 1696; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 269) { { - this.state = 2547; + this.state = 1695; this.match(PostgreSqlParser.KW_NO); } } - this.state = 2550; + this.state = 1698; this.match(PostgreSqlParser.KW_INHERIT); - this.state = 2551; + this.state = 1699; this.qualified_name(); } break; - case 14: - this.enterOuterAlt(localContext, 14); + case 13: + this.enterOuterAlt(localContext, 13); { - this.state = 2552; + this.state = 1700; this.match(PostgreSqlParser.KW_OF); - this.state = 2553; + this.state = 1701; this.any_name(); } break; - case 15: - this.enterOuterAlt(localContext, 15); + case 14: + this.enterOuterAlt(localContext, 14); { - this.state = 2554; + this.state = 1702; this.match(PostgreSqlParser.KW_NOT); - this.state = 2555; + this.state = 1703; this.match(PostgreSqlParser.KW_OF); } break; - case 16: - this.enterOuterAlt(localContext, 16); + case 15: + this.enterOuterAlt(localContext, 15); { - this.state = 2556; + this.state = 1704; this.match(PostgreSqlParser.KW_OWNER); - this.state = 2557; + this.state = 1705; this.match(PostgreSqlParser.KW_TO); - this.state = 2558; + this.state = 1706; this.rolespec(); } break; - case 17: - this.enterOuterAlt(localContext, 17); + case 16: + this.enterOuterAlt(localContext, 16); { - this.state = 2559; + this.state = 1707; this.match(PostgreSqlParser.KW_SET); - this.state = 2560; + this.state = 1708; this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 2561; + this.state = 1709; this.tablespace_name_create(); } break; - case 18: - this.enterOuterAlt(localContext, 18); - { - this.state = 2562; - this.match(PostgreSqlParser.KW_SET); - this.state = 2563; - this.reloptions(); - } - break; - case 19: - this.enterOuterAlt(localContext, 19); - { - this.state = 2564; - this.match(PostgreSqlParser.KW_RESET); - this.state = 2565; - this.reloptions(); - } - break; - case 20: - this.enterOuterAlt(localContext, 20); + case 17: + this.enterOuterAlt(localContext, 17); { - this.state = 2566; + this.state = 1710; this.match(PostgreSqlParser.KW_REPLICA); - this.state = 2567; + this.state = 1711; this.match(PostgreSqlParser.KW_IDENTITY); - this.state = 2568; - this.replica_identity(); - } - break; - case 21: - this.enterOuterAlt(localContext, 21); - { - this.state = 2569; - this.match(PostgreSqlParser.KW_ENABLE); - this.state = 2570; - this.match(PostgreSqlParser.KW_ROW); - this.state = 2571; - this.match(PostgreSqlParser.KW_LEVEL); - this.state = 2572; - this.match(PostgreSqlParser.KW_SECURITY); + this.state = 1716; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_NOTHING: + { + this.state = 1712; + this.match(PostgreSqlParser.KW_NOTHING); + } + break; + case PostgreSqlParser.KW_FULL: + { + this.state = 1713; + this.match(PostgreSqlParser.KW_FULL); + } + break; + case PostgreSqlParser.KW_DEFAULT: + { + this.state = 1714; + this.match(PostgreSqlParser.KW_DEFAULT); + } + break; + case PostgreSqlParser.KW_USING: + { + this.state = 1715; + this.existingindex(); + } + break; + default: + throw new antlr.NoViableAltException(this); } - break; - case 22: - this.enterOuterAlt(localContext, 22); - { - this.state = 2573; - this.match(PostgreSqlParser.KW_DISABLE); - this.state = 2574; - this.match(PostgreSqlParser.KW_ROW); - this.state = 2575; - this.match(PostgreSqlParser.KW_LEVEL); - this.state = 2576; - this.match(PostgreSqlParser.KW_SECURITY); } break; - case 23: - this.enterOuterAlt(localContext, 23); + case 18: + this.enterOuterAlt(localContext, 18); { - this.state = 2577; - this.match(PostgreSqlParser.KW_FORCE); - this.state = 2578; - this.match(PostgreSqlParser.KW_ROW); - this.state = 2579; - this.match(PostgreSqlParser.KW_LEVEL); - this.state = 2580; - this.match(PostgreSqlParser.KW_SECURITY); + this.state = 1724; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_ENABLE: + { + this.state = 1718; + this.match(PostgreSqlParser.KW_ENABLE); + } + break; + case PostgreSqlParser.KW_DISABLE: + { + this.state = 1719; + this.match(PostgreSqlParser.KW_DISABLE); + } + break; + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_NO: + { + { + this.state = 1721; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269) { + { + this.state = 1720; + this.match(PostgreSqlParser.KW_NO); + } + } + + this.state = 1723; + this.match(PostgreSqlParser.KW_FORCE); + } + } + break; + default: + throw new antlr.NoViableAltException(this); } - break; - case 24: - this.enterOuterAlt(localContext, 24); - { - this.state = 2581; - this.match(PostgreSqlParser.KW_NO); - this.state = 2582; - this.match(PostgreSqlParser.KW_FORCE); - this.state = 2583; + this.state = 1726; this.match(PostgreSqlParser.KW_ROW); - this.state = 2584; + this.state = 1727; this.match(PostgreSqlParser.KW_LEVEL); - this.state = 2585; + this.state = 1728; this.match(PostgreSqlParser.KW_SECURITY); } break; - case 25: - this.enterOuterAlt(localContext, 25); + case 19: + this.enterOuterAlt(localContext, 19); { - this.state = 2586; + this.state = 1729; this.match(PostgreSqlParser.KW_DROP); - this.state = 2588; + this.state = 1731; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 86, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 88, this.context) ) { case 1: { - this.state = 2587; + this.state = 1730; this.match(PostgreSqlParser.KW_COLUMN); } break; } - this.state = 2591; + this.state = 1734; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 87, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 89, this.context) ) { case 1: { - this.state = 2590; + this.state = 1733; this.opt_if_exists(); } break; } - this.state = 2593; + this.state = 1736; this.column_name(); - this.state = 2595; + this.state = 1738; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 88, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 90, this.context) ) { case 1: { - this.state = 2594; + this.state = 1737; this.opt_drop_behavior(); } break; } } break; - case 26: - this.enterOuterAlt(localContext, 26); + case 20: + this.enterOuterAlt(localContext, 20); { - this.state = 2597; + this.state = 1740; this.match(PostgreSqlParser.KW_ADD); - this.state = 2599; + this.state = 1742; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 44) { { - this.state = 2598; + this.state = 1741; this.match(PostgreSqlParser.KW_COLUMN); } } - this.state = 2602; + this.state = 1745; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 90, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 92, this.context) ) { case 1: { - this.state = 2601; + this.state = 1744; this.opt_if_not_exists(); } break; } - this.state = 2604; + this.state = 1747; this.column_def(); } break; - case 27: - this.enterOuterAlt(localContext, 27); + case 21: + this.enterOuterAlt(localContext, 21); { - this.state = 2605; + this.state = 1748; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2607; + this.state = 1750; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 91, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 93, this.context) ) { case 1: { - this.state = 2606; + this.state = 1749; this.match(PostgreSqlParser.KW_COLUMN); } break; } - this.state = 2609; + this.state = 1752; this.column_name(); - this.state = 2610; - this.alter_column_default(); + this.state = 1755; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_SET: + { + this.state = 1753; + this.alter_column_default(); + } + break; + case PostgreSqlParser.KW_OPTIONS: + { + this.state = 1754; + this.alter_generic_options(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } break; - case 28: - this.enterOuterAlt(localContext, 28); + case 22: + this.enterOuterAlt(localContext, 22); { - this.state = 2612; + this.state = 1757; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2614; + this.state = 1759; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 92, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 95, this.context) ) { case 1: { - this.state = 2613; + this.state = 1758; this.match(PostgreSqlParser.KW_COLUMN); } break; } - this.state = 2616; + this.state = 1761; this.column_name(); - this.state = 2617; + this.state = 1762; _la = this.tokenStream.LA(1); if(!(_la === 191 || _la === 333)) { this.errorHandler.recoverInline(this); @@ -9645,88 +8854,96 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 2618; + this.state = 1763; this.match(PostgreSqlParser.KW_NOT); - this.state = 2619; + this.state = 1764; this.match(PostgreSqlParser.KW_NULL); } break; - case 29: - this.enterOuterAlt(localContext, 29); + case 23: + this.enterOuterAlt(localContext, 23); { - this.state = 2621; + this.state = 1766; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2623; + this.state = 1768; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 93, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 96, this.context) ) { case 1: { - this.state = 2622; + this.state = 1767; this.match(PostgreSqlParser.KW_COLUMN); } break; } - this.state = 2625; + this.state = 1770; this.column_name(); - this.state = 2626; + this.state = 1771; this.match(PostgreSqlParser.KW_DROP); - this.state = 2627; + this.state = 1772; this.match(PostgreSqlParser.KW_EXPRESSION); - this.state = 2629; + this.state = 1774; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 94, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 97, this.context) ) { case 1: { - this.state = 2628; + this.state = 1773; this.opt_if_exists(); } break; } } break; - case 30: - this.enterOuterAlt(localContext, 30); + case 24: + this.enterOuterAlt(localContext, 24); { - this.state = 2631; + this.state = 1776; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2633; + this.state = 1778; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 95, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 98, this.context) ) { case 1: { - this.state = 2632; + this.state = 1777; this.match(PostgreSqlParser.KW_COLUMN); } break; } - this.state = 2635; + this.state = 1780; this.column_name(); - this.state = 2636; + this.state = 1781; this.match(PostgreSqlParser.KW_SET); - this.state = 2637; + this.state = 1782; this.match(PostgreSqlParser.KW_STATISTICS); - this.state = 2638; + this.state = 1783; this.signediconst(); } break; - case 31: - this.enterOuterAlt(localContext, 31); + case 25: + this.enterOuterAlt(localContext, 25); { - this.state = 2640; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2642; + this.state = 1790; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 96, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 138) { { - this.state = 2641; - this.match(PostgreSqlParser.KW_COLUMN); + this.state = 1785; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 1787; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 99, this.context) ) { + case 1: + { + this.state = 1786; + this.match(PostgreSqlParser.KW_COLUMN); + } + break; + } + this.state = 1789; + this.column_name(); } - break; } - this.state = 2644; - this.column_name(); - this.state = 2645; + + this.state = 1792; _la = this.tokenStream.LA(1); if(!(_la === 313 || _la === 333)) { this.errorHandler.recoverInline(this); @@ -9735,206 +8952,286 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 2646; + this.state = 1793; this.reloptions(); } break; - case 32: - this.enterOuterAlt(localContext, 32); + case 26: + this.enterOuterAlt(localContext, 26); { - this.state = 2648; + this.state = 1794; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2650; + this.state = 1796; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 97, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 101, this.context) ) { case 1: { - this.state = 2649; + this.state = 1795; this.match(PostgreSqlParser.KW_COLUMN); } break; } - this.state = 2652; + this.state = 1798; this.column_name(); - this.state = 2653; + this.state = 1799; this.match(PostgreSqlParser.KW_SET); - this.state = 2654; + this.state = 1800; this.match(PostgreSqlParser.KW_STORAGE); - this.state = 2655; + this.state = 1801; this.colid(); } break; - case 33: - this.enterOuterAlt(localContext, 33); + case 27: + this.enterOuterAlt(localContext, 27); { - this.state = 2657; + this.state = 1803; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2659; + this.state = 1805; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 98, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 102, this.context) ) { case 1: { - this.state = 2658; + this.state = 1804; this.match(PostgreSqlParser.KW_COLUMN); } break; } - this.state = 2661; + this.state = 1807; this.column_name(); - this.state = 2662; + this.state = 1808; this.match(PostgreSqlParser.KW_ADD); - this.state = 2663; + this.state = 1809; this.match(PostgreSqlParser.KW_GENERATED); - this.state = 2664; + this.state = 1810; this.generated_when(); - this.state = 2665; + this.state = 1811; this.match(PostgreSqlParser.KW_AS); - this.state = 2666; + this.state = 1812; this.match(PostgreSqlParser.KW_IDENTITY); - this.state = 2668; + this.state = 1821; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 99, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 104, this.context) ) { case 1: { - this.state = 2667; - this.optparenthesizedseqoptlist(); + this.state = 1813; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 1815; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 1814; + this.seqoptelem(); + } + } + this.state = 1817; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 36 || _la === 148 || _la === 225 || ((((_la - 260)) & ~0x1F) === 0 && ((1 << (_la - 260)) & 2097669) !== 0) || ((((_la - 314)) & ~0x1F) === 0 && ((1 << (_la - 314)) & 67125249) !== 0)); + this.state = 1819; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; } } break; - case 34: - this.enterOuterAlt(localContext, 34); + case 28: + this.enterOuterAlt(localContext, 28); { - this.state = 2670; + this.state = 1823; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2672; + this.state = 1825; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 100, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 105, this.context) ) { case 1: { - this.state = 2671; + this.state = 1824; this.match(PostgreSqlParser.KW_COLUMN); } break; } - this.state = 2674; + this.state = 1827; this.column_name(); - this.state = 2675; - this.alter_identity_column_option_list(); + this.state = 1841; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + this.state = 1841; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_RESTART: + { + this.state = 1828; + this.match(PostgreSqlParser.KW_RESTART); + this.state = 1833; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 107, this.context) ) { + case 1: + { + this.state = 1830; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 105) { + { + this.state = 1829; + this.match(PostgreSqlParser.KW_WITH); + } + } + + this.state = 1832; + this.numericonly(); + } + break; + } + } + break; + case PostgreSqlParser.KW_SET: + { + this.state = 1835; + this.match(PostgreSqlParser.KW_SET); + this.state = 1839; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AS: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_START: + { + this.state = 1836; + this.seqoptelem(); + } + break; + case PostgreSqlParser.KW_GENERATED: + { + this.state = 1837; + this.match(PostgreSqlParser.KW_GENERATED); + this.state = 1838; + this.generated_when(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 1843; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 110, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); } break; - case 35: - this.enterOuterAlt(localContext, 35); + case 29: + this.enterOuterAlt(localContext, 29); { - this.state = 2677; + this.state = 1845; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2679; + this.state = 1847; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 101, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 111, this.context) ) { case 1: { - this.state = 2678; + this.state = 1846; this.match(PostgreSqlParser.KW_COLUMN); } break; } - this.state = 2681; + this.state = 1849; this.column_name(); - this.state = 2682; + this.state = 1850; this.match(PostgreSqlParser.KW_DROP); - this.state = 2683; + this.state = 1851; this.match(PostgreSqlParser.KW_IDENTITY); - this.state = 2685; + this.state = 1853; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 102, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 112, this.context) ) { case 1: { - this.state = 2684; + this.state = 1852; this.opt_if_exists(); } break; } } break; - case 36: - this.enterOuterAlt(localContext, 36); + case 30: + this.enterOuterAlt(localContext, 30); { - this.state = 2687; + this.state = 1855; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2689; + this.state = 1857; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 103, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 113, this.context) ) { case 1: { - this.state = 2688; + this.state = 1856; this.match(PostgreSqlParser.KW_COLUMN); } break; } - this.state = 2691; + this.state = 1859; this.column_name(); - this.state = 2693; + this.state = 1862; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 333) { { - this.state = 2692; - this.opt_set_data(); + this.state = 1860; + this.match(PostgreSqlParser.KW_SET); + this.state = 1861; + this.match(PostgreSqlParser.KW_DATA); } } - this.state = 2695; + this.state = 1864; this.match(PostgreSqlParser.KW_TYPE); - this.state = 2696; + this.state = 1865; this.typename(); - this.state = 2698; + this.state = 1867; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 105, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 115, this.context) ) { case 1: { - this.state = 2697; + this.state = 1866; this.opt_collate_clause(); } break; } - this.state = 2701; + this.state = 1871; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 2700; - this.alter_using(); + this.state = 1869; + this.match(PostgreSqlParser.KW_USING); + this.state = 1870; + this.expression(); } } } break; - case 37: - this.enterOuterAlt(localContext, 37); - { - this.state = 2703; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 2705; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 107, this.context) ) { - case 1: - { - this.state = 2704; - this.match(PostgreSqlParser.KW_COLUMN); - } - break; - } - this.state = 2707; - this.column_name(); - this.state = 2708; - this.alter_generic_options(); - } - break; - case 38: - this.enterOuterAlt(localContext, 38); + case 31: + this.enterOuterAlt(localContext, 31); { - this.state = 2710; + this.state = 1873; this.alter_generic_options(); } break; @@ -9956,28 +9253,28 @@ export class PostgreSqlParser extends SQLParserBase { } public alter_column_default(): Alter_column_defaultContext { let localContext = new Alter_column_defaultContext(this.context, this.state); - this.enterRule(localContext, 122, PostgreSqlParser.RULE_alter_column_default); + this.enterRule(localContext, 94, PostgreSqlParser.RULE_alter_column_default); try { - this.state = 2718; + this.state = 1881; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_SET: this.enterOuterAlt(localContext, 1); { - this.state = 2713; + this.state = 1876; this.match(PostgreSqlParser.KW_SET); - this.state = 2714; + this.state = 1877; this.match(PostgreSqlParser.KW_DEFAULT); - this.state = 2715; - this.a_expr(); + this.state = 1878; + this.expression(); } break; case PostgreSqlParser.KW_DROP: this.enterOuterAlt(localContext, 2); { - this.state = 2716; + this.state = 1879; this.match(PostgreSqlParser.KW_DROP); - this.state = 2717; + this.state = 1880; this.match(PostgreSqlParser.KW_DEFAULT); } break; @@ -10001,12 +9298,12 @@ export class PostgreSqlParser extends SQLParserBase { } public opt_drop_behavior(): Opt_drop_behaviorContext { let localContext = new Opt_drop_behaviorContext(this.context, this.state); - this.enterRule(localContext, 124, PostgreSqlParser.RULE_opt_drop_behavior); + this.enterRule(localContext, 96, PostgreSqlParser.RULE_opt_drop_behavior); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2720; + this.state = 1883; _la = this.tokenStream.LA(1); if(!(_la === 150 || _la === 315)) { this.errorHandler.recoverInline(this); @@ -10033,13 +9330,13 @@ export class PostgreSqlParser extends SQLParserBase { } public opt_collate_clause(): Opt_collate_clauseContext { let localContext = new Opt_collate_clauseContext(this.context, this.state); - this.enterRule(localContext, 126, PostgreSqlParser.RULE_opt_collate_clause); + this.enterRule(localContext, 98, PostgreSqlParser.RULE_opt_collate_clause); try { this.enterOuterAlt(localContext, 1); { - this.state = 2722; + this.state = 1885; this.match(PostgreSqlParser.KW_COLLATE); - this.state = 2723; + this.state = 1886; this.any_name(); } } @@ -10057,100 +9354,34 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alter_using(): Alter_usingContext { - let localContext = new Alter_usingContext(this.context, this.state); - this.enterRule(localContext, 128, PostgreSqlParser.RULE_alter_using); + public reloptions(): ReloptionsContext { + let localContext = new ReloptionsContext(this.context, this.state); + this.enterRule(localContext, 100, PostgreSqlParser.RULE_reloptions); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2725; - this.match(PostgreSqlParser.KW_USING); - this.state = 2726; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public replica_identity(): Replica_identityContext { - let localContext = new Replica_identityContext(this.context, this.state); - this.enterRule(localContext, 130, PostgreSqlParser.RULE_replica_identity); - try { - this.state = 2734; + this.state = 1888; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 1889; + this.reloption_elem(); + this.state = 1894; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_NOTHING: - this.enterOuterAlt(localContext, 1); - { - this.state = 2728; - this.match(PostgreSqlParser.KW_NOTHING); - } - break; - case PostgreSqlParser.KW_FULL: - this.enterOuterAlt(localContext, 2); + _la = this.tokenStream.LA(1); + while (_la === 6) { { - this.state = 2729; - this.match(PostgreSqlParser.KW_FULL); - } - break; - case PostgreSqlParser.KW_DEFAULT: - this.enterOuterAlt(localContext, 3); { - this.state = 2730; - this.match(PostgreSqlParser.KW_DEFAULT); + this.state = 1890; + this.match(PostgreSqlParser.COMMA); + this.state = 1891; + this.reloption_elem(); } - break; - case PostgreSqlParser.KW_USING: - this.enterOuterAlt(localContext, 4); - { - this.state = 2731; - this.match(PostgreSqlParser.KW_USING); - this.state = 2732; - this.match(PostgreSqlParser.KW_INDEX); - this.state = 2733; - this.name(); } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + this.state = 1896; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - } - finally { - this.exitRule(); - } - return localContext; - } - public reloptions(): ReloptionsContext { - let localContext = new ReloptionsContext(this.context, this.state); - this.enterRule(localContext, 132, PostgreSqlParser.RULE_reloptions); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2736; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 2737; - this.reloption_list(); - this.state = 2738; + this.state = 1897; this.match(PostgreSqlParser.CLOSE_PAREN); } } @@ -10170,13 +9401,13 @@ export class PostgreSqlParser extends SQLParserBase { } public opt_reloptions(): Opt_reloptionsContext { let localContext = new Opt_reloptionsContext(this.context, this.state); - this.enterRule(localContext, 134, PostgreSqlParser.RULE_opt_reloptions); + this.enterRule(localContext, 102, PostgreSqlParser.RULE_opt_reloptions); try { this.enterOuterAlt(localContext, 1); { - this.state = 2740; + this.state = 1899; this.match(PostgreSqlParser.KW_WITH); - this.state = 2741; + this.state = 1900; this.reloptions(); } } @@ -10194,85 +9425,31 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public reloption_list(): Reloption_listContext { - let localContext = new Reloption_listContext(this.context, this.state); - this.enterRule(localContext, 136, PostgreSqlParser.RULE_reloption_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2743; - this.reloption_elem(); - this.state = 2748; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 2744; - this.match(PostgreSqlParser.COMMA); - this.state = 2745; - this.reloption_elem(); - } - } - this.state = 2750; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public reloption_elem(): Reloption_elemContext { let localContext = new Reloption_elemContext(this.context, this.state); - this.enterRule(localContext, 138, PostgreSqlParser.RULE_reloption_elem); - let _la: number; + this.enterRule(localContext, 104, PostgreSqlParser.RULE_reloption_elem); try { this.enterOuterAlt(localContext, 1); { - this.state = 2751; + this.state = 1902; this.collabel(); - this.state = 2760; + this.state = 1907; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.EQUAL: { - this.state = 2752; + this.state = 1903; this.match(PostgreSqlParser.EQUAL); - this.state = 2753; + this.state = 1904; this.def_arg(); } break; case PostgreSqlParser.DOT: { - this.state = 2754; + this.state = 1905; this.match(PostgreSqlParser.DOT); - this.state = 2755; - this.collabel(); - this.state = 2758; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 10) { - { - this.state = 2756; - this.match(PostgreSqlParser.EQUAL); - this.state = 2757; - this.def_arg(); - } - } - + this.state = 1906; + this.def_elem(); } break; case PostgreSqlParser.CLOSE_PAREN: @@ -10297,209 +9474,87 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alter_identity_column_option_list(): Alter_identity_column_option_listContext { - let localContext = new Alter_identity_column_option_listContext(this.context, this.state); - this.enterRule(localContext, 140, PostgreSqlParser.RULE_alter_identity_column_option_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 2763; - this.errorHandler.sync(this); - alternative = 1; - do { - switch (alternative) { - case 1: - { - { - this.state = 2762; - this.alter_identity_column_option(); - } - } - break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 2765; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 114, this.context); - } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alter_identity_column_option(): Alter_identity_column_optionContext { - let localContext = new Alter_identity_column_optionContext(this.context, this.state); - this.enterRule(localContext, 142, PostgreSqlParser.RULE_alter_identity_column_option); - let _la: number; - try { - this.state = 2780; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_RESTART: - this.enterOuterAlt(localContext, 1); - { - this.state = 2767; - this.match(PostgreSqlParser.KW_RESTART); - this.state = 2772; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 116, this.context) ) { - case 1: - { - this.state = 2769; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 105) { - { - this.state = 2768; - this.opt_with(); - } - } - - this.state = 2771; - this.numericonly(); - } - break; - } - } - break; - case PostgreSqlParser.KW_SET: - this.enterOuterAlt(localContext, 2); - { - this.state = 2774; - this.match(PostgreSqlParser.KW_SET); - this.state = 2778; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AS: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_START: - { - this.state = 2775; - this.seqoptelem(); - } - break; - case PostgreSqlParser.KW_GENERATED: - { - this.state = 2776; - this.match(PostgreSqlParser.KW_GENERATED); - this.state = 2777; - this.generated_when(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public partitionboundspec(): PartitionboundspecContext { let localContext = new PartitionboundspecContext(this.context, this.state); - this.enterRule(localContext, 144, PostgreSqlParser.RULE_partitionboundspec); + this.enterRule(localContext, 106, PostgreSqlParser.RULE_partitionboundspec); + let _la: number; try { - this.state = 2808; + this.state = 1938; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 119, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 122, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2782; + this.state = 1909; this.match(PostgreSqlParser.KW_FOR); - this.state = 2783; + this.state = 1910; this.match(PostgreSqlParser.KW_VALUES); - this.state = 2784; + this.state = 1911; this.match(PostgreSqlParser.KW_WITH); - this.state = 2785; + this.state = 1912; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 2786; - this.hash_partbound(); - this.state = 2787; + this.state = 1913; + this.nonreservedword(); + this.state = 1914; + this.match(PostgreSqlParser.Integral); + this.state = 1921; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 1915; + this.match(PostgreSqlParser.COMMA); + { + this.state = 1916; + this.nonreservedword(); + this.state = 1917; + this.match(PostgreSqlParser.Integral); + } + } + } + this.state = 1923; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 1924; this.match(PostgreSqlParser.CLOSE_PAREN); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2789; + this.state = 1926; this.match(PostgreSqlParser.KW_FOR); - this.state = 2790; + this.state = 1927; this.match(PostgreSqlParser.KW_VALUES); - this.state = 2791; + this.state = 1928; this.match(PostgreSqlParser.KW_IN); - this.state = 2792; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 2793; - this.expr_list(); - this.state = 2794; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 1929; + this.execute_param_clause(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 2796; + this.state = 1930; this.match(PostgreSqlParser.KW_FOR); - this.state = 2797; + this.state = 1931; this.match(PostgreSqlParser.KW_VALUES); - this.state = 2798; + this.state = 1932; this.match(PostgreSqlParser.KW_FROM); - this.state = 2799; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 2800; - this.expr_list(); - this.state = 2801; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 2802; + this.state = 1933; + this.execute_param_clause(); + this.state = 1934; this.match(PostgreSqlParser.KW_TO); - this.state = 2803; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 2804; - this.expr_list(); - this.state = 2805; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 1935; + this.execute_param_clause(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 2807; + this.state = 1937; this.match(PostgreSqlParser.KW_DEFAULT); } break; @@ -10519,125 +9574,34 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public hash_partbound_elem(): Hash_partbound_elemContext { - let localContext = new Hash_partbound_elemContext(this.context, this.state); - this.enterRule(localContext, 146, PostgreSqlParser.RULE_hash_partbound_elem); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2810; - this.nonreservedword(); - this.state = 2811; - this.iconst(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public hash_partbound(): Hash_partboundContext { - let localContext = new Hash_partboundContext(this.context, this.state); - this.enterRule(localContext, 148, PostgreSqlParser.RULE_hash_partbound); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2813; - this.hash_partbound_elem(); - this.state = 2818; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 2814; - this.match(PostgreSqlParser.COMMA); - this.state = 2815; - this.hash_partbound_elem(); - } - } - this.state = 2820; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public altercompositetypestmt(): AltercompositetypestmtContext { let localContext = new AltercompositetypestmtContext(this.context, this.state); - this.enterRule(localContext, 150, PostgreSqlParser.RULE_altercompositetypestmt); + this.enterRule(localContext, 108, PostgreSqlParser.RULE_altercompositetypestmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2821; + this.state = 1940; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2822; + this.state = 1941; this.match(PostgreSqlParser.KW_TYPE); - this.state = 2823; + this.state = 1942; this.any_name(); - this.state = 2824; - this.alter_type_cmds(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alter_type_cmds(): Alter_type_cmdsContext { - let localContext = new Alter_type_cmdsContext(this.context, this.state); - this.enterRule(localContext, 152, PostgreSqlParser.RULE_alter_type_cmds); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2826; + this.state = 1943; this.alter_type_cmd(); - this.state = 2831; + this.state = 1948; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 2827; + this.state = 1944; this.match(PostgreSqlParser.COMMA); - this.state = 2828; + this.state = 1945; this.alter_type_cmd(); } } - this.state = 2833; + this.state = 1950; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -10659,27 +9623,27 @@ export class PostgreSqlParser extends SQLParserBase { } public alter_type_cmd(): Alter_type_cmdContext { let localContext = new Alter_type_cmdContext(this.context, this.state); - this.enterRule(localContext, 154, PostgreSqlParser.RULE_alter_type_cmd); + this.enterRule(localContext, 110, PostgreSqlParser.RULE_alter_type_cmd); let _la: number; try { - this.state = 2863; + this.state = 1981; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_ADD: this.enterOuterAlt(localContext, 1); { - this.state = 2834; + this.state = 1951; this.match(PostgreSqlParser.KW_ADD); - this.state = 2835; + this.state = 1952; this.match(PostgreSqlParser.KW_ATTRIBUTE); - this.state = 2836; + this.state = 1953; this.tablefuncelement(); - this.state = 2838; + this.state = 1955; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 122, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 124, this.context) ) { case 1: { - this.state = 2837; + this.state = 1954; this.opt_drop_behavior(); } break; @@ -10689,28 +9653,28 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_DROP: this.enterOuterAlt(localContext, 2); { - this.state = 2840; + this.state = 1957; this.match(PostgreSqlParser.KW_DROP); - this.state = 2841; + this.state = 1958; this.match(PostgreSqlParser.KW_ATTRIBUTE); - this.state = 2843; + this.state = 1960; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 123, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 125, this.context) ) { case 1: { - this.state = 2842; + this.state = 1959; this.opt_if_exists(); } break; } - this.state = 2845; + this.state = 1962; this.colid(); - this.state = 2847; + this.state = 1964; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 124, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 126, this.context) ) { case 1: { - this.state = 2846; + this.state = 1963; this.opt_drop_behavior(); } break; @@ -10720,42 +9684,44 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_ALTER: this.enterOuterAlt(localContext, 3); { - this.state = 2849; + this.state = 1966; this.match(PostgreSqlParser.KW_ALTER); - this.state = 2850; + this.state = 1967; this.match(PostgreSqlParser.KW_ATTRIBUTE); - this.state = 2851; + this.state = 1968; this.colid(); - this.state = 2853; + this.state = 1971; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 333) { { - this.state = 2852; - this.opt_set_data(); + this.state = 1969; + this.match(PostgreSqlParser.KW_SET); + this.state = 1970; + this.match(PostgreSqlParser.KW_DATA); } } - this.state = 2855; + this.state = 1973; this.match(PostgreSqlParser.KW_TYPE); - this.state = 2856; + this.state = 1974; this.typename(); - this.state = 2858; + this.state = 1976; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 126, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 128, this.context) ) { case 1: { - this.state = 2857; + this.state = 1975; this.opt_collate_clause(); } break; } - this.state = 2861; + this.state = 1979; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 127, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 129, this.context) ) { case 1: { - this.state = 2860; + this.state = 1978; this.opt_drop_behavior(); } break; @@ -10782,13 +9748,13 @@ export class PostgreSqlParser extends SQLParserBase { } public closeportalstmt(): CloseportalstmtContext { let localContext = new CloseportalstmtContext(this.context, this.state); - this.enterRule(localContext, 156, PostgreSqlParser.RULE_closeportalstmt); + this.enterRule(localContext, 112, PostgreSqlParser.RULE_closeportalstmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 2865; + this.state = 1983; this.match(PostgreSqlParser.KW_CLOSE); - this.state = 2868; + this.state = 1986; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_AND: @@ -11191,13 +10157,13 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 2866; - this.cursor_name(); + this.state = 1984; + this.colid(); } break; case PostgreSqlParser.KW_ALL: { - this.state = 2867; + this.state = 1985; this.match(PostgreSqlParser.KW_ALL); } break; @@ -11222,81 +10188,125 @@ export class PostgreSqlParser extends SQLParserBase { } public copystmt(): CopystmtContext { let localContext = new CopystmtContext(this.context, this.state); - this.enterRule(localContext, 158, PostgreSqlParser.RULE_copystmt); + this.enterRule(localContext, 114, PostgreSqlParser.RULE_copystmt); let _la: number; try { - this.state = 2907; + this.state = 2037; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 138, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 143, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2870; + this.state = 1988; this.match(PostgreSqlParser.KW_COPY); - this.state = 2872; + this.state = 1990; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 107) { { - this.state = 2871; - this.opt_binary(); + this.state = 1989; + this.match(PostgreSqlParser.KW_BINARY); } } - this.state = 2874; + this.state = 1992; this.table_name(); - this.state = 2876; + this.state = 1994; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2) { { - this.state = 2875; + this.state = 1993; this.opt_column_list(); } } - this.state = 2878; - this.copy_from(); - this.state = 2880; + this.state = 1996; + _la = this.tokenStream.LA(1); + if(!(_la === 64 || _la === 94)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 1998; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 297) { { - this.state = 2879; - this.opt_program(); + this.state = 1997; + this.match(PostgreSqlParser.KW_PROGRAM); } } - this.state = 2882; - this.copy_file_name(); - this.state = 2884; + this.state = 2003; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 2000; + this.sconst(); + } + break; + case PostgreSqlParser.KW_STDIN: + { + this.state = 2001; + this.match(PostgreSqlParser.KW_STDIN); + } + break; + case PostgreSqlParser.KW_STDOUT: + { + this.state = 2002; + this.match(PostgreSqlParser.KW_STDOUT); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 2010; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 133, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 137, this.context) ) { case 1: { - this.state = 2883; - this.copy_delimiter(); + this.state = 2006; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 100) { + { + this.state = 2005; + this.match(PostgreSqlParser.KW_USING); + } + } + + this.state = 2008; + this.match(PostgreSqlParser.KW_DELIMITERS); + this.state = 2009; + this.sconst(); } break; } - this.state = 2887; + this.state = 2013; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 134, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 138, this.context) ) { case 1: { - this.state = 2886; - this.opt_with(); + this.state = 2012; + this.match(PostgreSqlParser.KW_WITH); } break; } - this.state = 2889; + this.state = 2015; this.copy_options(); - this.state = 2891; + this.state = 2017; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 103) { { - this.state = 2890; + this.state = 2016; this.where_clause(); } } @@ -11306,39 +10316,64 @@ export class PostgreSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 2893; + this.state = 2019; this.match(PostgreSqlParser.KW_COPY); - this.state = 2894; + this.state = 2020; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 2895; + this.state = 2021; this.preparablestmt(); - this.state = 2896; + this.state = 2022; this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 2897; + this.state = 2023; this.match(PostgreSqlParser.KW_TO); - this.state = 2899; + this.state = 2025; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 297) { { - this.state = 2898; - this.opt_program(); + this.state = 2024; + this.match(PostgreSqlParser.KW_PROGRAM); } } - this.state = 2901; - this.copy_file_name(); - this.state = 2903; + this.state = 2030; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 137, this.context) ) { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 2027; + this.sconst(); + } + break; + case PostgreSqlParser.KW_STDIN: + { + this.state = 2028; + this.match(PostgreSqlParser.KW_STDIN); + } + break; + case PostgreSqlParser.KW_STDOUT: + { + this.state = 2029; + this.match(PostgreSqlParser.KW_STDOUT); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 2033; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 142, this.context) ) { case 1: { - this.state = 2902; - this.opt_with(); + this.state = 2032; + this.match(PostgreSqlParser.KW_WITH); } break; } - this.state = 2905; + this.state = 2035; this.copy_options(); } break; @@ -11358,356 +10393,162 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public copy_from(): Copy_fromContext { - let localContext = new Copy_fromContext(this.context, this.state); - this.enterRule(localContext, 160, PostgreSqlParser.RULE_copy_from); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2909; - _la = this.tokenStream.LA(1); - if(!(_la === 64 || _la === 94)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_program(): Opt_programContext { - let localContext = new Opt_programContext(this.context, this.state); - this.enterRule(localContext, 162, PostgreSqlParser.RULE_opt_program); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2911; - this.match(PostgreSqlParser.KW_PROGRAM); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public copy_file_name(): Copy_file_nameContext { - let localContext = new Copy_file_nameContext(this.context, this.state); - this.enterRule(localContext, 164, PostgreSqlParser.RULE_copy_file_name); - try { - this.state = 2916; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); - { - this.state = 2913; - this.sconst(); - } - break; - case PostgreSqlParser.KW_STDIN: - this.enterOuterAlt(localContext, 2); - { - this.state = 2914; - this.match(PostgreSqlParser.KW_STDIN); - } - break; - case PostgreSqlParser.KW_STDOUT: - this.enterOuterAlt(localContext, 3); - { - this.state = 2915; - this.match(PostgreSqlParser.KW_STDOUT); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public copy_options(): Copy_optionsContext { let localContext = new Copy_optionsContext(this.context, this.state); - this.enterRule(localContext, 166, PostgreSqlParser.RULE_copy_options); - try { - this.state = 2923; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 140, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 2918; - this.copy_opt_list(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 2919; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 2920; - this.copy_generic_opt_list(); - this.state = 2921; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public copy_opt_list(): Copy_opt_listContext { - let localContext = new Copy_opt_listContext(this.context, this.state); - this.enterRule(localContext, 168, PostgreSqlParser.RULE_copy_opt_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 2928; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 141, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 2925; - this.copy_opt_item(); - } - } - } - this.state = 2930; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 141, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public copy_opt_item(): Copy_opt_itemContext { - let localContext = new Copy_opt_itemContext(this.context, this.state); - this.enterRule(localContext, 170, PostgreSqlParser.RULE_copy_opt_item); + this.enterRule(localContext, 116, PostgreSqlParser.RULE_copy_options); let _la: number; try { - this.state = 2970; + let alternative: number; + this.state = 2078; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 146, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 150, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 2931; - this.match(PostgreSqlParser.KW_BINARY); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 2932; - this.match(PostgreSqlParser.KW_FREEZE); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 2933; - this.match(PostgreSqlParser.KW_DELIMITER); - this.state = 2935; + this.state = 2064; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 36) { - { - this.state = 2934; - this.opt_as(); - } - } + alternative = this.interpreter.adaptivePredict(this.tokenStream, 148, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + this.state = 2062; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 147, this.context) ) { + case 1: + { + this.state = 2039; + this.match(PostgreSqlParser.KW_BINARY); + } + break; + case 2: + { + this.state = 2040; + this.match(PostgreSqlParser.KW_FREEZE); + } + break; + case 3: + { + this.state = 2041; + _la = this.tokenStream.LA(1); + if(!(_la === 78 || _la === 183 || _la === 197 || _la === 298)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2043; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 36) { + { + this.state = 2042; + this.match(PostgreSqlParser.KW_AS); + } + } - this.state = 2937; - this.sconst(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 2938; - this.match(PostgreSqlParser.KW_NULL); - this.state = 2940; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 36) { - { - this.state = 2939; - this.opt_as(); - } - } + this.state = 2045; + this.sconst(); + } + break; + case 4: + { + this.state = 2046; + this.match(PostgreSqlParser.KW_CSV); + } + break; + case 5: + { + this.state = 2047; + this.match(PostgreSqlParser.KW_HEADER); + } + break; + case 6: + { + this.state = 2048; + this.match(PostgreSqlParser.KW_FORCE); + this.state = 2049; + this.match(PostgreSqlParser.KW_QUOTE); + this.state = 2052; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 145, this.context) ) { + case 1: + { + this.state = 2050; + this.column_list(); + } + break; + case 2: + { + this.state = 2051; + this.match(PostgreSqlParser.STAR); + } + break; + } + } + break; + case 7: + { + this.state = 2054; + this.match(PostgreSqlParser.KW_FORCE); + this.state = 2056; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { + { + this.state = 2055; + this.match(PostgreSqlParser.KW_NOT); + } + } - this.state = 2942; - this.sconst(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 2943; - this.match(PostgreSqlParser.KW_CSV); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 2944; - this.match(PostgreSqlParser.KW_HEADER); - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 2945; - this.match(PostgreSqlParser.KW_QUOTE); - this.state = 2947; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 36) { - { - this.state = 2946; - this.opt_as(); + this.state = 2058; + this.match(PostgreSqlParser.KW_NULL); + this.state = 2059; + this.column_list(); + } + break; + case 8: + { + this.state = 2060; + this.match(PostgreSqlParser.KW_ENCODING); + this.state = 2061; + this.sconst(); + } + break; + } + } } + this.state = 2066; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 148, this.context); } - - this.state = 2949; - this.sconst(); } break; - case 8: - this.enterOuterAlt(localContext, 8); + case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 2950; - this.match(PostgreSqlParser.KW_ESCAPE); - this.state = 2952; + this.state = 2067; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 2068; + this.copy_generic_opt_elem(); + this.state = 2073; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 36) { + while (_la === 6) { + { { - this.state = 2951; - this.opt_as(); + this.state = 2069; + this.match(PostgreSqlParser.COMMA); + this.state = 2070; + this.copy_generic_opt_elem(); } + } + this.state = 2075; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - - this.state = 2954; - this.sconst(); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 2955; - this.match(PostgreSqlParser.KW_FORCE); - this.state = 2956; - this.match(PostgreSqlParser.KW_QUOTE); - this.state = 2957; - this.column_list(); - } - break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 2958; - this.match(PostgreSqlParser.KW_FORCE); - this.state = 2959; - this.match(PostgreSqlParser.KW_QUOTE); - this.state = 2960; - this.match(PostgreSqlParser.STAR); - } - break; - case 11: - this.enterOuterAlt(localContext, 11); - { - this.state = 2961; - this.match(PostgreSqlParser.KW_FORCE); - this.state = 2962; - this.match(PostgreSqlParser.KW_NOT); - this.state = 2963; - this.match(PostgreSqlParser.KW_NULL); - this.state = 2964; - this.column_list(); - } - break; - case 12: - this.enterOuterAlt(localContext, 12); - { - this.state = 2965; - this.match(PostgreSqlParser.KW_FORCE); - this.state = 2966; - this.match(PostgreSqlParser.KW_NULL); - this.state = 2967; - this.column_list(); - } - break; - case 13: - this.enterOuterAlt(localContext, 13); - { - this.state = 2968; - this.match(PostgreSqlParser.KW_ENCODING); - this.state = 2969; - this.sconst(); + this.state = 2076; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; } @@ -11726,172 +10567,16 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_binary(): Opt_binaryContext { - let localContext = new Opt_binaryContext(this.context, this.state); - this.enterRule(localContext, 172, PostgreSqlParser.RULE_opt_binary); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2972; - this.match(PostgreSqlParser.KW_BINARY); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public copy_delimiter(): Copy_delimiterContext { - let localContext = new Copy_delimiterContext(this.context, this.state); - this.enterRule(localContext, 174, PostgreSqlParser.RULE_copy_delimiter); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2975; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 100) { - { - this.state = 2974; - this.opt_using(); - } - } - - this.state = 2977; - this.match(PostgreSqlParser.KW_DELIMITERS); - this.state = 2978; - this.sconst(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_using(): Opt_usingContext { - let localContext = new Opt_usingContext(this.context, this.state); - this.enterRule(localContext, 176, PostgreSqlParser.RULE_opt_using); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2980; - this.match(PostgreSqlParser.KW_USING); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public copy_generic_opt_list(): Copy_generic_opt_listContext { - let localContext = new Copy_generic_opt_listContext(this.context, this.state); - this.enterRule(localContext, 178, PostgreSqlParser.RULE_copy_generic_opt_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 2982; - this.copy_generic_opt_elem(); - this.state = 2987; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 2983; - this.match(PostgreSqlParser.COMMA); - this.state = 2984; - this.copy_generic_opt_elem(); - } - } - this.state = 2989; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public copy_generic_opt_elem(): Copy_generic_opt_elemContext { let localContext = new Copy_generic_opt_elemContext(this.context, this.state); - this.enterRule(localContext, 180, PostgreSqlParser.RULE_copy_generic_opt_elem); + this.enterRule(localContext, 118, PostgreSqlParser.RULE_copy_generic_opt_elem); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 2990; + this.state = 2080; this.collabel(); - this.state = 2992; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 12804) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 420484101) !== 0) || ((((_la - 80)) & ~0x1F) === 0 && ((1 << (_la - 80)) & 4227923969) !== 0) || ((((_la - 112)) & ~0x1F) === 0 && ((1 << (_la - 112)) & 4294967295) !== 0) || ((((_la - 144)) & ~0x1F) === 0 && ((1 << (_la - 144)) & 4294967295) !== 0) || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & 4294967295) !== 0) || ((((_la - 208)) & ~0x1F) === 0 && ((1 << (_la - 208)) & 3223322623) !== 0) || ((((_la - 240)) & ~0x1F) === 0 && ((1 << (_la - 240)) & 4294967295) !== 0) || ((((_la - 272)) & ~0x1F) === 0 && ((1 << (_la - 272)) & 4294967295) !== 0) || ((((_la - 304)) & ~0x1F) === 0 && ((1 << (_la - 304)) & 4294967295) !== 0) || ((((_la - 336)) & ~0x1F) === 0 && ((1 << (_la - 336)) & 4294967295) !== 0) || ((((_la - 368)) & ~0x1F) === 0 && ((1 << (_la - 368)) & 4294967295) !== 0) || ((((_la - 400)) & ~0x1F) === 0 && ((1 << (_la - 400)) & 4294967295) !== 0) || ((((_la - 432)) & ~0x1F) === 0 && ((1 << (_la - 432)) & 4290772991) !== 0) || ((((_la - 464)) & ~0x1F) === 0 && ((1 << (_la - 464)) & 4294967295) !== 0) || ((((_la - 496)) & ~0x1F) === 0 && ((1 << (_la - 496)) & 25165183) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 486582415) !== 0) || _la === 584) { - { - this.state = 2991; - this.copy_generic_opt_arg(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public copy_generic_opt_arg(): Copy_generic_opt_argContext { - let localContext = new Copy_generic_opt_argContext(this.context, this.state); - this.enterRule(localContext, 182, PostgreSqlParser.RULE_copy_generic_opt_arg); - try { - this.state = 3001; + this.state = 2095; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_AND: @@ -12317,9 +11002,8 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLVARIABLENAME: case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); { - this.state = 2994; + this.state = 2081; this.opt_boolean_or_string(); } break; @@ -12327,97 +11011,49 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.MINUS: case PostgreSqlParser.Integral: case PostgreSqlParser.Numeric: - this.enterOuterAlt(localContext, 2); { - this.state = 2995; + this.state = 2082; this.numericonly(); } break; case PostgreSqlParser.STAR: - this.enterOuterAlt(localContext, 3); { - this.state = 2996; + this.state = 2083; this.match(PostgreSqlParser.STAR); } break; case PostgreSqlParser.OPEN_PAREN: - this.enterOuterAlt(localContext, 4); { - this.state = 2997; + this.state = 2084; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 2998; - this.copy_generic_opt_arg_list(); - this.state = 2999; + this.state = 2085; + this.opt_boolean_or_string_column(); + this.state = 2090; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 2086; + this.match(PostgreSqlParser.COMMA); + this.state = 2087; + this.opt_boolean_or_string_column(); + } + } + this.state = 2092; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2093; this.match(PostgreSqlParser.CLOSE_PAREN); } break; + case PostgreSqlParser.CLOSE_PAREN: + case PostgreSqlParser.COMMA: + break; default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public copy_generic_opt_arg_list(): Copy_generic_opt_arg_listContext { - let localContext = new Copy_generic_opt_arg_listContext(this.context, this.state); - this.enterRule(localContext, 184, PostgreSqlParser.RULE_copy_generic_opt_arg_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3003; - this.copy_generic_opt_arg_list_item(); - this.state = 3008; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 3004; - this.match(PostgreSqlParser.COMMA); - this.state = 3005; - this.copy_generic_opt_arg_list_item(); - } - } - this.state = 3010; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + break; } - } - finally { - this.exitRule(); - } - return localContext; - } - public copy_generic_opt_arg_list_item(): Copy_generic_opt_arg_list_itemContext { - let localContext = new Copy_generic_opt_arg_list_itemContext(this.context, this.state); - this.enterRule(localContext, 186, PostgreSqlParser.RULE_copy_generic_opt_arg_list_item); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3011; - this.opt_boolean_or_string_column(); } } catch (re) { @@ -12436,113 +11072,113 @@ export class PostgreSqlParser extends SQLParserBase { } public createstmt(): CreatestmtContext { let localContext = new CreatestmtContext(this.context, this.state); - this.enterRule(localContext, 188, PostgreSqlParser.RULE_createstmt); + this.enterRule(localContext, 120, PostgreSqlParser.RULE_createstmt); let _la: number; try { localContext = new ColumnCreateTableContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 3013; + this.state = 2097; this.match(PostgreSqlParser.KW_CREATE); - this.state = 3015; + this.state = 2099; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 213 || _la === 254 || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & 32773) !== 0)) { { - this.state = 3014; + this.state = 2098; this.opttemp(); } } - this.state = 3017; + this.state = 2101; this.match(PostgreSqlParser.KW_TABLE); - this.state = 3019; + this.state = 2103; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 153, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 154, this.context) ) { case 1: { - this.state = 3018; + this.state = 2102; this.opt_if_not_exists(); } break; } - this.state = 3021; + this.state = 2105; this.table_name_create(); - this.state = 3087; + this.state = 2171; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.OPEN_PAREN: { - this.state = 3022; + this.state = 2106; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3024; + this.state = 2108; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 1360008709) !== 0) || ((((_la - 85)) & ~0x1F) === 0 && ((1 << (_la - 85)) & 2147491841) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & 4294966809) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & 4294967295) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & 4294967295) !== 0) || ((((_la - 216)) & ~0x1F) === 0 && ((1 << (_la - 216)) & 4290781183) !== 0) || ((((_la - 248)) & ~0x1F) === 0 && ((1 << (_la - 248)) & 4294967295) !== 0) || ((((_la - 280)) & ~0x1F) === 0 && ((1 << (_la - 280)) & 4294967295) !== 0) || ((((_la - 312)) & ~0x1F) === 0 && ((1 << (_la - 312)) & 4294967295) !== 0) || ((((_la - 344)) & ~0x1F) === 0 && ((1 << (_la - 344)) & 4294967295) !== 0) || ((((_la - 376)) & ~0x1F) === 0 && ((1 << (_la - 376)) & 4294967295) !== 0) || ((((_la - 408)) & ~0x1F) === 0 && ((1 << (_la - 408)) & 4294967295) !== 0) || ((((_la - 440)) & ~0x1F) === 0 && ((1 << (_la - 440)) & 4294950911) !== 0) || ((((_la - 473)) & ~0x1F) === 0 && ((1 << (_la - 473)) & 3221225471) !== 0) || ((((_la - 506)) & ~0x1F) === 0 && ((1 << (_la - 506)) & 24575) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { - this.state = 3023; - this.table_column_list(); + this.state = 2107; + this.tableelementlist(); } } - this.state = 3026; + this.state = 2110; this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 3028; + this.state = 2112; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 155, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 156, this.context) ) { case 1: { - this.state = 3027; + this.state = 2111; this.optinherit(); } break; } - this.state = 3031; + this.state = 2115; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 156, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 157, this.context) ) { case 1: { - this.state = 3030; - this.optpartitionspec(); + this.state = 2114; + this.partitionspec(); } break; } - this.state = 3034; + this.state = 2118; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 3033; + this.state = 2117; this.table_access_method_clause(); } } - this.state = 3037; + this.state = 2121; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 158, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 159, this.context) ) { case 1: { - this.state = 3036; + this.state = 2120; this.optwith(); } break; } - this.state = 3040; + this.state = 2124; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 80) { { - this.state = 3039; + this.state = 2123; this.oncommitoption(); } } - this.state = 3043; + this.state = 2127; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 160, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 161, this.context) ) { case 1: { - this.state = 3042; + this.state = 2126; this.opttablespace(); } break; @@ -12551,66 +11187,66 @@ export class PostgreSqlParser extends SQLParserBase { break; case PostgreSqlParser.KW_OF: { - this.state = 3045; + this.state = 2129; this.match(PostgreSqlParser.KW_OF); - this.state = 3046; + this.state = 2130; this.any_name(); - this.state = 3048; + this.state = 2132; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 161, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 162, this.context) ) { case 1: { - this.state = 3047; + this.state = 2131; this.opttypedtableelementlist(); } break; } - this.state = 3051; + this.state = 2135; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 162, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 163, this.context) ) { case 1: { - this.state = 3050; - this.optpartitionspec(); + this.state = 2134; + this.partitionspec(); } break; } - this.state = 3054; + this.state = 2138; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 3053; + this.state = 2137; this.table_access_method_clause(); } } - this.state = 3057; + this.state = 2141; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 164, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 165, this.context) ) { case 1: { - this.state = 3056; + this.state = 2140; this.optwith(); } break; } - this.state = 3060; + this.state = 2144; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 80) { { - this.state = 3059; + this.state = 2143; this.oncommitoption(); } } - this.state = 3063; + this.state = 2147; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 166, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 167, this.context) ) { case 1: { - this.state = 3062; + this.state = 2146; this.opttablespace(); } break; @@ -12619,70 +11255,70 @@ export class PostgreSqlParser extends SQLParserBase { break; case PostgreSqlParser.KW_PARTITION: { - this.state = 3065; + this.state = 2149; this.match(PostgreSqlParser.KW_PARTITION); - this.state = 3066; + this.state = 2150; this.match(PostgreSqlParser.KW_OF); - this.state = 3067; + this.state = 2151; this.qualified_name(); - this.state = 3069; + this.state = 2153; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2) { { - this.state = 3068; + this.state = 2152; this.opttypedtableelementlist(); } } - this.state = 3071; + this.state = 2155; this.partitionboundspec(); - this.state = 3073; + this.state = 2157; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 168, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 169, this.context) ) { case 1: { - this.state = 3072; - this.optpartitionspec(); + this.state = 2156; + this.partitionspec(); } break; } - this.state = 3076; + this.state = 2160; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 3075; + this.state = 2159; this.table_access_method_clause(); } } - this.state = 3079; + this.state = 2163; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 170, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 171, this.context) ) { case 1: { - this.state = 3078; + this.state = 2162; this.optwith(); } break; } - this.state = 3082; + this.state = 2166; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 80) { { - this.state = 3081; + this.state = 2165; this.oncommitoption(); } } - this.state = 3085; + this.state = 2169; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 172, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 173, this.context) ) { case 1: { - this.state = 3084; + this.state = 2168; this.opttablespace(); } break; @@ -12710,48 +11346,40 @@ export class PostgreSqlParser extends SQLParserBase { } public opttemp(): OpttempContext { let localContext = new OpttempContext(this.context, this.state); - this.enterRule(localContext, 190, PostgreSqlParser.RULE_opttemp); + this.enterRule(localContext, 122, PostgreSqlParser.RULE_opttemp); let _la: number; try { - this.state = 3096; + this.state = 2178; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_TEMPORARY: this.enterOuterAlt(localContext, 1); { - this.state = 3089; + this.state = 2173; this.match(PostgreSqlParser.KW_TEMPORARY); } break; case PostgreSqlParser.KW_TEMP: this.enterOuterAlt(localContext, 2); { - this.state = 3090; + this.state = 2174; this.match(PostgreSqlParser.KW_TEMP); } break; + case PostgreSqlParser.KW_GLOBAL: case PostgreSqlParser.KW_LOCAL: this.enterOuterAlt(localContext, 3); { - this.state = 3091; - this.match(PostgreSqlParser.KW_LOCAL); - this.state = 3092; + this.state = 2175; _la = this.tokenStream.LA(1); - if(!(_la === 352 || _la === 354)) { + if(!(_la === 213 || _la === 254)) { this.errorHandler.recoverInline(this); } else { this.errorHandler.reportMatch(this); this.consume(); } - } - break; - case PostgreSqlParser.KW_GLOBAL: - this.enterOuterAlt(localContext, 4); - { - this.state = 3093; - this.match(PostgreSqlParser.KW_GLOBAL); - this.state = 3094; + this.state = 2176; _la = this.tokenStream.LA(1); if(!(_la === 352 || _la === 354)) { this.errorHandler.recoverInline(this); @@ -12763,9 +11391,9 @@ export class PostgreSqlParser extends SQLParserBase { } break; case PostgreSqlParser.KW_UNLOGGED: - this.enterOuterAlt(localContext, 5); + this.enterOuterAlt(localContext, 4); { - this.state = 3095; + this.state = 2177; this.match(PostgreSqlParser.KW_UNLOGGED); } break; @@ -12787,107 +11415,35 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public table_column_list(): Table_column_listContext { - let localContext = new Table_column_listContext(this.context, this.state); - this.enterRule(localContext, 192, PostgreSqlParser.RULE_table_column_list); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3098; - this.tableelementlist(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opttableelementlist(): OpttableelementlistContext { - let localContext = new OpttableelementlistContext(this.context, this.state); - this.enterRule(localContext, 194, PostgreSqlParser.RULE_opttableelementlist); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3100; - this.tableelementlist(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public opttypedtableelementlist(): OpttypedtableelementlistContext { let localContext = new OpttypedtableelementlistContext(this.context, this.state); - this.enterRule(localContext, 196, PostgreSqlParser.RULE_opttypedtableelementlist); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3102; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3103; - this.typedtableelementlist(); - this.state = 3104; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public tableelementlist(): TableelementlistContext { - let localContext = new TableelementlistContext(this.context, this.state); - this.enterRule(localContext, 198, PostgreSqlParser.RULE_tableelementlist); + this.enterRule(localContext, 124, PostgreSqlParser.RULE_opttypedtableelementlist); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3106; - this.tableelement(); - this.state = 3111; + this.state = 2180; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 2181; + this.typedtableelement(); + this.state = 2186; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 3107; + this.state = 2182; this.match(PostgreSqlParser.COMMA); - this.state = 3108; - this.tableelement(); + this.state = 2183; + this.typedtableelement(); } } - this.state = 3113; + this.state = 2188; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } + this.state = 2189; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -12904,28 +11460,28 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public typedtableelementlist(): TypedtableelementlistContext { - let localContext = new TypedtableelementlistContext(this.context, this.state); - this.enterRule(localContext, 200, PostgreSqlParser.RULE_typedtableelementlist); + public tableelementlist(): TableelementlistContext { + let localContext = new TableelementlistContext(this.context, this.state); + this.enterRule(localContext, 126, PostgreSqlParser.RULE_tableelementlist); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3114; - this.typedtableelement(); - this.state = 3119; + this.state = 2191; + this.tableelement(); + this.state = 2196; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 3115; + this.state = 2192; this.match(PostgreSqlParser.COMMA); - this.state = 3116; - this.typedtableelement(); + this.state = 2193; + this.tableelement(); } } - this.state = 3121; + this.state = 2198; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -12947,30 +11503,68 @@ export class PostgreSqlParser extends SQLParserBase { } public tableelement(): TableelementContext { let localContext = new TableelementContext(this.context, this.state); - this.enterRule(localContext, 202, PostgreSqlParser.RULE_tableelement); + this.enterRule(localContext, 128, PostgreSqlParser.RULE_tableelement); + let _la: number; try { - this.state = 3125; + this.state = 2214; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 177, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 180, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 3122; + this.state = 2199; this.column_def(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 3123; - this.tablelikeclause(); + this.state = 2200; + this.match(PostgreSqlParser.KW_LIKE); + this.state = 2201; + this.qualified_name(); + this.state = 2206; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 200 || _la === 224) { + { + { + this.state = 2202; + _la = this.tokenStream.LA(1); + if(!(_la === 200 || _la === 224)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2203; + this.tablelikeoption(); + } + } + this.state = 2208; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 3124; - this.tableconstraint(); + this.state = 2211; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 45) { + { + this.state = 2209; + this.match(PostgreSqlParser.KW_CONSTRAINT); + this.state = 2210; + this.colid(); + } + } + + this.state = 2213; + this.constraintelem(); } break; } @@ -12991,23 +11585,62 @@ export class PostgreSqlParser extends SQLParserBase { } public typedtableelement(): TypedtableelementContext { let localContext = new TypedtableelementContext(this.context, this.state); - this.enterRule(localContext, 204, PostgreSqlParser.RULE_typedtableelement); + this.enterRule(localContext, 130, PostgreSqlParser.RULE_typedtableelement); + let _la: number; try { - this.state = 3129; + this.state = 2232; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 178, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 184, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 3127; - this.columnOptions(); + this.state = 2216; + this.column_name_create(); + this.state = 2219; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 105) { + { + this.state = 2217; + this.match(PostgreSqlParser.KW_WITH); + this.state = 2218; + this.match(PostgreSqlParser.KW_OPTIONS); + } + } + + this.state = 2224; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (((((_la - 42)) & ~0x1F) === 0 && ((1 << (_la - 42)) & 2059) !== 0) || ((((_la - 77)) & ~0x1F) === 0 && ((1 << (_la - 77)) & 2097923) !== 0) || _la === 438) { + { + { + this.state = 2221; + this.colconstraint(); + } + } + this.state = 2226; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 3128; - this.tableconstraint(); + this.state = 2229; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 45) { + { + this.state = 2227; + this.match(PostgreSqlParser.KW_CONSTRAINT); + this.state = 2228; + this.colid(); + } + } + + this.state = 2231; + this.constraintelem(); } break; } @@ -13028,160 +11661,125 @@ export class PostgreSqlParser extends SQLParserBase { } public column_def(): Column_defContext { let localContext = new Column_defContext(this.context, this.state); - this.enterRule(localContext, 206, PostgreSqlParser.RULE_column_def); + this.enterRule(localContext, 132, PostgreSqlParser.RULE_column_def); let _la: number; try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 3131; + this.state = 2234; this.column_name_create(); - this.state = 3132; + this.state = 2235; this.typename(); - this.state = 3134; + this.state = 2237; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 179, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 185, this.context) ) { case 1: { - this.state = 3133; + this.state = 2236; this.create_generic_options(); } break; } - this.state = 3137; + this.state = 2248; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 180, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 187, this.context) ) { case 1: { - this.state = 3136; - this.storageCluase(); + this.state = 2239; + this.match(PostgreSqlParser.KW_STORAGE); + this.state = 2246; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 186, this.context) ) { + case 1: + { + this.state = 2240; + this.match(PostgreSqlParser.KW_PLAIN); + } + break; + case 2: + { + this.state = 2241; + this.match(PostgreSqlParser.KW_EXTERNAL); + } + break; + case 3: + { + this.state = 2242; + this.match(PostgreSqlParser.KW_EXTENDED); + } + break; + case 4: + { + this.state = 2243; + this.match(PostgreSqlParser.KW_MAIN); + } + break; + case 5: + { + this.state = 2244; + this.match(PostgreSqlParser.KW_DEFAULT); + } + break; + case 6: + { + this.state = 2245; + this.colid(); + } + break; + } } break; } - this.state = 3140; + this.state = 2252; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 543) { { - this.state = 3139; - this.compressionCluase(); + this.state = 2250; + this.match(PostgreSqlParser.KW_COMPRESSION); + this.state = 2251; + this.colid(); } } - this.state = 3144; + this.state = 2255; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 182, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 189, this.context) ) { case 1: { - this.state = 3142; - this.match(PostgreSqlParser.KW_COLLATE); - this.state = 3143; - this.any_name(); + this.state = 2254; + this.opt_collate_clause(); } break; } - this.state = 3148; + this.state = 2259; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 183, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 190, this.context) ) { case 1: { - this.state = 3146; + this.state = 2257; this.match(PostgreSqlParser.KW_WITH); - this.state = 3147; + this.state = 2258; this.match(PostgreSqlParser.KW_OPTIONS); } break; } - this.state = 3150; - this.colquallist(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public compressionCluase(): CompressionCluaseContext { - let localContext = new CompressionCluaseContext(this.context, this.state); - this.enterRule(localContext, 208, PostgreSqlParser.RULE_compressionCluase); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3152; - this.match(PostgreSqlParser.KW_COMPRESSION); - this.state = 3153; - this.colid(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public storageCluase(): StorageCluaseContext { - let localContext = new StorageCluaseContext(this.context, this.state); - this.enterRule(localContext, 210, PostgreSqlParser.RULE_storageCluase); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3155; - this.match(PostgreSqlParser.KW_STORAGE); - this.state = 3162; + this.state = 2264; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 184, this.context) ) { - case 1: - { - this.state = 3156; - this.match(PostgreSqlParser.KW_PLAIN); - } - break; - case 2: - { - this.state = 3157; - this.match(PostgreSqlParser.KW_EXTERNAL); - } - break; - case 3: - { - this.state = 3158; - this.match(PostgreSqlParser.KW_EXTENDED); - } - break; - case 4: - { - this.state = 3159; - this.match(PostgreSqlParser.KW_MAIN); - } - break; - case 5: - { - this.state = 3160; - this.match(PostgreSqlParser.KW_DEFAULT); - } - break; - case 6: - { - this.state = 3161; - this.colid(); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 191, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2261; + this.colconstraint(); + } + } } - break; + this.state = 2266; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 191, this.context); } } } @@ -13199,68 +11797,66 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public columnOptions(): ColumnOptionsContext { - let localContext = new ColumnOptionsContext(this.context, this.state); - this.enterRule(localContext, 212, PostgreSqlParser.RULE_columnOptions); + public colconstraint(): ColconstraintContext { + let localContext = new ColconstraintContext(this.context, this.state); + this.enterRule(localContext, 134, PostgreSqlParser.RULE_colconstraint); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3164; - this.column_name_create(); - this.state = 3167; + this.state = 2269; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 105) { + if (_la === 45) { { - this.state = 3165; - this.match(PostgreSqlParser.KW_WITH); - this.state = 3166; - this.match(PostgreSqlParser.KW_OPTIONS); + this.state = 2267; + this.match(PostgreSqlParser.KW_CONSTRAINT); + this.state = 2268; + this.colid(); } } - this.state = 3169; - this.colquallist(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public colquallist(): ColquallistContext { - let localContext = new ColquallistContext(this.context, this.state); - this.enterRule(localContext, 214, PostgreSqlParser.RULE_colquallist); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 3174; + this.state = 2271; + this.colconstraintelem(); + this.state = 2276; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 186, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { + switch (this.interpreter.adaptivePredict(this.tokenStream, 194, this.context) ) { + case 1: + { + this.state = 2273; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { { - this.state = 3171; - this.colconstraint(); - } + this.state = 2272; + this.match(PostgreSqlParser.KW_NOT); } } - this.state = 3176; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 186, this.context); + + this.state = 2275; + this.match(PostgreSqlParser.KW_DEFERRABLE); + } + break; + } + this.state = 2280; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 69) { + { + this.state = 2278; + this.match(PostgreSqlParser.KW_INITIALLY); + this.state = 2279; + _la = this.tokenStream.LA(1); + if(!(_la === 180 || _la === 221)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } } + } } catch (re) { @@ -13277,250 +11873,223 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public colconstraint(): ColconstraintContext { - let localContext = new ColconstraintContext(this.context, this.state); - this.enterRule(localContext, 216, PostgreSqlParser.RULE_colconstraint); + public colconstraintelem(): ColconstraintelemContext { + let localContext = new ColconstraintelemContext(this.context, this.state); + this.enterRule(localContext, 136, PostgreSqlParser.RULE_colconstraintelem); let _la: number; try { - this.state = 3195; + this.state = 2362; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 192, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 213, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 3179; + this.state = 2283; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 45) { + if (_la === 77) { { - this.state = 3177; - this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 3178; - this.name(); + this.state = 2282; + this.match(PostgreSqlParser.KW_NOT); } } - this.state = 3181; - this.colconstraintelem(); - this.state = 3183; + this.state = 2285; + this.match(PostgreSqlParser.KW_NULL); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 2286; + this.match(PostgreSqlParser.KW_UNIQUE); + this.state = 2288; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 188, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 197, this.context) ) { case 1: { - this.state = 3182; - this.deferrable_trigger(); + this.state = 2287; + this.opt_definition(); } break; } - this.state = 3186; + this.state = 2291; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 69) { + if (_la === 100) { { - this.state = 3185; - this.initially_trigger(); + this.state = 2290; + this.optconstablespace(); } } } break; - case 2: - this.enterOuterAlt(localContext, 2); + case 3: + this.enterOuterAlt(localContext, 3); { - this.state = 3188; - this.colconstraintelem(); - this.state = 3190; + this.state = 2293; + this.match(PostgreSqlParser.KW_UNIQUE); + this.state = 2299; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 190, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 200, this.context) ) { case 1: { - this.state = 3189; - this.deferrable_trigger(); + this.state = 2294; + this.match(PostgreSqlParser.KW_NULLS); + this.state = 2296; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { + { + this.state = 2295; + this.match(PostgreSqlParser.KW_NOT); + } + } + + this.state = 2298; + this.match(PostgreSqlParser.KW_DISTINCT); } break; } - this.state = 3193; + { + this.state = 2303; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 69) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 201, this.context) ) { + case 1: { - this.state = 3192; - this.initially_trigger(); + this.state = 2301; + this.match(PostgreSqlParser.KW_INCLUDE); + this.state = 2302; + this.index_params(); } + break; } - + this.state = 2306; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 202, this.context) ) { + case 1: + { + this.state = 2305; + this.with_clause(); + } + break; } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public colconstraintelem(): ColconstraintelemContext { - let localContext = new ColconstraintelemContext(this.context, this.state); - this.enterRule(localContext, 218, PostgreSqlParser.RULE_colconstraintelem); - let _la: number; - try { - this.state = 3255; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 204, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 3197; - this.match(PostgreSqlParser.KW_NOT); - this.state = 3198; - this.match(PostgreSqlParser.KW_NULL); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 3199; - this.match(PostgreSqlParser.KW_NULL); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 3200; - this.match(PostgreSqlParser.KW_UNIQUE); - this.state = 3202; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 193, this.context) ) { - case 1: - { - this.state = 3201; - this.opt_definition(); - } - break; - } - this.state = 3205; + this.state = 2309; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 3204; + this.state = 2308; this.optconstablespace(); } } + } } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 3207; - this.match(PostgreSqlParser.KW_UNIQUE); - this.state = 3209; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 195, this.context) ) { - case 1: - { - this.state = 3208; - this.nulls_distinct(); - } - break; - } - this.state = 3211; - this.index_paramenters_create(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 3212; + this.state = 2311; this.match(PostgreSqlParser.KW_PRIMARY); - this.state = 3213; + this.state = 2312; this.match(PostgreSqlParser.KW_KEY); - this.state = 3215; + this.state = 2314; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 196, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 204, this.context) ) { case 1: { - this.state = 3214; + this.state = 2313; this.opt_definition(); } break; } - this.state = 3218; + this.state = 2317; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 3217; + this.state = 2316; this.optconstablespace(); } } } break; - case 6: - this.enterOuterAlt(localContext, 6); + case 5: + this.enterOuterAlt(localContext, 5); { - this.state = 3220; + this.state = 2319; this.match(PostgreSqlParser.KW_CHECK); - this.state = 3221; + this.state = 2320; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3222; - this.a_expr(); - this.state = 3223; + this.state = 2321; + this.expression(); + this.state = 2322; this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 3225; + this.state = 2325; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 198, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 206, this.context) ) { case 1: { - this.state = 3224; - this.opt_no_inherit(); + this.state = 2323; + this.match(PostgreSqlParser.KW_NO); + this.state = 2324; + this.match(PostgreSqlParser.KW_INHERIT); } break; } } break; - case 7: - this.enterOuterAlt(localContext, 7); + case 6: + this.enterOuterAlt(localContext, 6); { - this.state = 3227; + this.state = 2327; this.match(PostgreSqlParser.KW_DEFAULT); - this.state = 3228; - this.b_expr(0); + this.state = 2328; + this.primaryExpression(0); } break; - case 8: - this.enterOuterAlt(localContext, 8); + case 7: + this.enterOuterAlt(localContext, 7); { - this.state = 3229; + this.state = 2329; this.match(PostgreSqlParser.KW_GENERATED); - this.state = 3230; + this.state = 2330; this.generated_when(); - this.state = 3231; + this.state = 2331; this.match(PostgreSqlParser.KW_AS); - this.state = 3241; + this.state = 2348; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_IDENTITY: { - this.state = 3232; + this.state = 2332; this.match(PostgreSqlParser.KW_IDENTITY); - this.state = 3234; + this.state = 2341; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 199, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 208, this.context) ) { case 1: { - this.state = 3233; - this.optparenthesizedseqoptlist(); + this.state = 2333; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 2335; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 2334; + this.seqoptelem(); + } + } + this.state = 2337; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 36 || _la === 148 || _la === 225 || ((((_la - 260)) & ~0x1F) === 0 && ((1 << (_la - 260)) & 2097669) !== 0) || ((((_la - 314)) & ~0x1F) === 0 && ((1 << (_la - 314)) & 67125249) !== 0)); + this.state = 2339; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; } @@ -13528,13 +12097,13 @@ export class PostgreSqlParser extends SQLParserBase { break; case PostgreSqlParser.OPEN_PAREN: { - this.state = 3236; + this.state = 2343; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3237; - this.a_expr(); - this.state = 3238; + this.state = 2344; + this.expression(); + this.state = 2345; this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 3239; + this.state = 2346; this.match(PostgreSqlParser.KW_STORED); } break; @@ -13543,50 +12112,50 @@ export class PostgreSqlParser extends SQLParserBase { } } break; - case 9: - this.enterOuterAlt(localContext, 9); + case 8: + this.enterOuterAlt(localContext, 8); { - this.state = 3243; + this.state = 2350; this.match(PostgreSqlParser.KW_REFERENCES); - this.state = 3244; + this.state = 2351; this.qualified_name(); - this.state = 3246; + this.state = 2353; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 201, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 210, this.context) ) { case 1: { - this.state = 3245; + this.state = 2352; this.opt_column_list(); } break; } - this.state = 3249; + this.state = 2356; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 202, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 211, this.context) ) { case 1: { - this.state = 3248; + this.state = 2355; this.key_match(); } break; } - this.state = 3252; + this.state = 2359; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 80) { { - this.state = 3251; + this.state = 2358; this.key_actions(); } } } break; - case 10: - this.enterOuterAlt(localContext, 10); + case 9: + this.enterOuterAlt(localContext, 9); { - this.state = 3254; - this.opt_collate(); + this.state = 2361; + this.opt_collate_clause(); } break; } @@ -13605,63 +12174,26 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public nulls_distinct(): Nulls_distinctContext { - let localContext = new Nulls_distinctContext(this.context, this.state); - this.enterRule(localContext, 220, PostgreSqlParser.RULE_nulls_distinct); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3257; - this.match(PostgreSqlParser.KW_NULLS); - this.state = 3259; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 77) { - { - this.state = 3258; - this.match(PostgreSqlParser.KW_NOT); - } - } - - this.state = 3261; - this.match(PostgreSqlParser.KW_DISTINCT); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public generated_when(): Generated_whenContext { let localContext = new Generated_whenContext(this.context, this.state); - this.enterRule(localContext, 222, PostgreSqlParser.RULE_generated_when); + this.enterRule(localContext, 138, PostgreSqlParser.RULE_generated_when); try { - this.state = 3266; + this.state = 2367; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_ALWAYS: this.enterOuterAlt(localContext, 1); { - this.state = 3263; + this.state = 2364; this.match(PostgreSqlParser.KW_ALWAYS); } break; case PostgreSqlParser.KW_BY: this.enterOuterAlt(localContext, 2); { - this.state = 3264; + this.state = 2365; this.match(PostgreSqlParser.KW_BY); - this.state = 3265; + this.state = 2366; this.match(PostgreSqlParser.KW_DEFAULT); } break; @@ -13683,163 +12215,14 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public deferrable_trigger(): Deferrable_triggerContext { - let localContext = new Deferrable_triggerContext(this.context, this.state); - this.enterRule(localContext, 224, PostgreSqlParser.RULE_deferrable_trigger); - try { - this.state = 3271; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_DEFERRABLE: - this.enterOuterAlt(localContext, 1); - { - this.state = 3268; - this.match(PostgreSqlParser.KW_DEFERRABLE); - } - break; - case PostgreSqlParser.KW_NOT: - this.enterOuterAlt(localContext, 2); - { - this.state = 3269; - this.match(PostgreSqlParser.KW_NOT); - this.state = 3270; - this.match(PostgreSqlParser.KW_DEFERRABLE); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public initially_trigger(): Initially_triggerContext { - let localContext = new Initially_triggerContext(this.context, this.state); - this.enterRule(localContext, 226, PostgreSqlParser.RULE_initially_trigger); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3273; - this.match(PostgreSqlParser.KW_INITIALLY); - this.state = 3274; - _la = this.tokenStream.LA(1); - if(!(_la === 180 || _la === 221)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public tablelikeclause(): TablelikeclauseContext { - let localContext = new TablelikeclauseContext(this.context, this.state); - this.enterRule(localContext, 228, PostgreSqlParser.RULE_tablelikeclause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3276; - this.match(PostgreSqlParser.KW_LIKE); - this.state = 3277; - this.qualified_name(); - this.state = 3278; - this.tablelikeoptionlist(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public tablelikeoptionlist(): TablelikeoptionlistContext { - let localContext = new TablelikeoptionlistContext(this.context, this.state); - this.enterRule(localContext, 230, PostgreSqlParser.RULE_tablelikeoptionlist); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3284; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 200 || _la === 224) { - { - { - this.state = 3280; - _la = this.tokenStream.LA(1); - if(!(_la === 200 || _la === 224)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 3281; - this.tablelikeoption(); - } - } - this.state = 3286; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public tablelikeoption(): TablelikeoptionContext { let localContext = new TablelikeoptionContext(this.context, this.state); - this.enterRule(localContext, 232, PostgreSqlParser.RULE_tablelikeoption); + this.enterRule(localContext, 140, PostgreSqlParser.RULE_tablelikeoption); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3287; + this.state = 2369; _la = this.tokenStream.LA(1); if(!(_la === 30 || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 524321) !== 0) || _la === 219 || _la === 227 || _la === 342 || _la === 345 || _la === 438)) { this.errorHandler.recoverInline(this); @@ -13864,197 +12247,145 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public tableconstraint(): TableconstraintContext { - let localContext = new TableconstraintContext(this.context, this.state); - this.enterRule(localContext, 234, PostgreSqlParser.RULE_tableconstraint); - try { - this.state = 3294; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_CONSTRAINT: - this.enterOuterAlt(localContext, 1); - { - this.state = 3289; - this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 3290; - this.name(); - this.state = 3291; - this.constraintelem(); - } - break; - case PostgreSqlParser.KW_CHECK: - case PostgreSqlParser.KW_FOREIGN: - case PostgreSqlParser.KW_PRIMARY: - case PostgreSqlParser.KW_UNIQUE: - case PostgreSqlParser.KW_EXCLUDE: - this.enterOuterAlt(localContext, 2); - { - this.state = 3293; - this.constraintelem(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public constraintelem(): ConstraintelemContext { let localContext = new ConstraintelemContext(this.context, this.state); - this.enterRule(localContext, 236, PostgreSqlParser.RULE_constraintelem); + this.enterRule(localContext, 142, PostgreSqlParser.RULE_constraintelem); let _la: number; try { - this.state = 3382; + let alternative: number; + this.state = 2467; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_CHECK: this.enterOuterAlt(localContext, 1); { - this.state = 3296; + this.state = 2371; this.match(PostgreSqlParser.KW_CHECK); - this.state = 3297; + this.state = 2372; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3298; - this.a_expr(); - this.state = 3299; + this.state = 2373; + this.expression(); + this.state = 2374; this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 3300; - this.constraintattributespec(); + this.state = 2378; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 215, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2375; + this.constraintattributeElem(); + } + } + } + this.state = 2380; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 215, this.context); + } } break; + case PostgreSqlParser.KW_PRIMARY: case PostgreSqlParser.KW_UNIQUE: this.enterOuterAlt(localContext, 2); { - this.state = 3302; - this.match(PostgreSqlParser.KW_UNIQUE); - this.state = 3320; + this.state = 2384; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.OPEN_PAREN: + case PostgreSqlParser.KW_UNIQUE: { - this.state = 3303; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3304; - this.column_list(); - this.state = 3305; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 3307; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 210, this.context) ) { - case 1: - { - this.state = 3306; - this.opt_c_include(); - } - break; - } - this.state = 3310; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 211, this.context) ) { - case 1: - { - this.state = 3309; - this.opt_definition(); - } - break; - } - this.state = 3313; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 100) { - { - this.state = 3312; - this.optconstablespace(); - } - } - - this.state = 3315; - this.constraintattributespec(); + this.state = 2381; + this.match(PostgreSqlParser.KW_UNIQUE); } break; - case PostgreSqlParser.KW_USING: + case PostgreSqlParser.KW_PRIMARY: { - this.state = 3317; - this.existingindex(); - this.state = 3318; - this.constraintattributespec(); + { + this.state = 2382; + this.match(PostgreSqlParser.KW_PRIMARY); + this.state = 2383; + this.match(PostgreSqlParser.KW_KEY); + } } break; default: throw new antlr.NoViableAltException(this); } - } - break; - case PostgreSqlParser.KW_PRIMARY: - this.enterOuterAlt(localContext, 3); - { - this.state = 3322; - this.match(PostgreSqlParser.KW_PRIMARY); - this.state = 3323; - this.match(PostgreSqlParser.KW_KEY); - this.state = 3341; + this.state = 2409; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.OPEN_PAREN: { - this.state = 3324; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3325; - this.column_list(); - this.state = 3326; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 3328; + this.state = 2386; + this.opt_column_list(); + this.state = 2388; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 214, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 217, this.context) ) { case 1: { - this.state = 3327; + this.state = 2387; this.opt_c_include(); } break; } - this.state = 3331; + this.state = 2391; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 215, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 218, this.context) ) { case 1: { - this.state = 3330; + this.state = 2390; this.opt_definition(); } break; } - this.state = 3334; + this.state = 2394; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 3333; + this.state = 2393; this.optconstablespace(); } } - this.state = 3336; - this.constraintattributespec(); + this.state = 2399; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 220, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2396; + this.constraintattributeElem(); + } + } + } + this.state = 2401; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 220, this.context); + } } break; case PostgreSqlParser.KW_USING: { - this.state = 3338; + this.state = 2402; this.existingindex(); - this.state = 3339; - this.constraintattributespec(); + this.state = 2406; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 221, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2403; + this.constraintattributeElem(); + } + } + } + this.state = 2408; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 221, this.context); + } } break; default: @@ -14063,119 +12394,165 @@ export class PostgreSqlParser extends SQLParserBase { } break; case PostgreSqlParser.KW_EXCLUDE: - this.enterOuterAlt(localContext, 4); + this.enterOuterAlt(localContext, 3); { - this.state = 3343; + this.state = 2411; this.match(PostgreSqlParser.KW_EXCLUDE); - this.state = 3345; + this.state = 2413; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 3344; - this.access_method_clause(); + this.state = 2412; + this.table_access_method_clause(); } } - this.state = 3347; + this.state = 2415; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3348; - this.exclusionconstraintlist(); - this.state = 3349; + this.state = 2416; + this.exclusionconstraintelem(); + this.state = 2421; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 2417; + this.match(PostgreSqlParser.COMMA); + this.state = 2418; + this.exclusionconstraintelem(); + } + } + this.state = 2423; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2424; this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 3351; + this.state = 2426; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 219, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 225, this.context) ) { case 1: { - this.state = 3350; + this.state = 2425; this.opt_c_include(); } break; } - this.state = 3354; + this.state = 2429; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 220, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 226, this.context) ) { case 1: { - this.state = 3353; + this.state = 2428; this.opt_definition(); } break; } - this.state = 3357; + this.state = 2432; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 3356; + this.state = 2431; this.optconstablespace(); } } - this.state = 3360; + this.state = 2439; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 103) { { - this.state = 3359; - this.exclusionwhereclause(); + this.state = 2434; + this.match(PostgreSqlParser.KW_WHERE); + this.state = 2435; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 2436; + this.expression(); + this.state = 2437; + this.match(PostgreSqlParser.CLOSE_PAREN); } } - this.state = 3362; - this.constraintattributespec(); + this.state = 2444; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 229, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2441; + this.constraintattributeElem(); + } + } + } + this.state = 2446; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 229, this.context); + } } break; case PostgreSqlParser.KW_FOREIGN: - this.enterOuterAlt(localContext, 5); + this.enterOuterAlt(localContext, 4); { - this.state = 3364; + this.state = 2447; this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 3365; + this.state = 2448; this.match(PostgreSqlParser.KW_KEY); - this.state = 3366; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3367; - this.column_list(); - this.state = 3368; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 3369; + this.state = 2449; + this.opt_column_list(); + this.state = 2450; this.match(PostgreSqlParser.KW_REFERENCES); - this.state = 3370; + this.state = 2451; this.qualified_name(); - this.state = 3372; + this.state = 2453; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 223, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 230, this.context) ) { case 1: { - this.state = 3371; + this.state = 2452; this.opt_column_list(); } break; } - this.state = 3375; + this.state = 2456; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 224, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 231, this.context) ) { case 1: { - this.state = 3374; + this.state = 2455; this.key_match(); } break; } - this.state = 3378; + this.state = 2459; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 80) { { - this.state = 3377; + this.state = 2458; this.key_actions(); } } - this.state = 3380; - this.constraintattributespec(); + this.state = 2464; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 233, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 2461; + this.constraintattributeElem(); + } + } + } + this.state = 2466; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 233, this.context); + } } break; default: @@ -14196,43 +12573,17 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_no_inherit(): Opt_no_inheritContext { - let localContext = new Opt_no_inheritContext(this.context, this.state); - this.enterRule(localContext, 238, PostgreSqlParser.RULE_opt_no_inherit); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3384; - this.match(PostgreSqlParser.KW_NO); - this.state = 3385; - this.match(PostgreSqlParser.KW_INHERIT); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public opt_column_list(): Opt_column_listContext { let localContext = new Opt_column_listContext(this.context, this.state); - this.enterRule(localContext, 240, PostgreSqlParser.RULE_opt_column_list); + this.enterRule(localContext, 144, PostgreSqlParser.RULE_opt_column_list); try { this.enterOuterAlt(localContext, 1); { - this.state = 3387; + this.state = 2469; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3388; + this.state = 2470; this.column_list(); - this.state = 3389; + this.state = 2471; this.match(PostgreSqlParser.CLOSE_PAREN); } } @@ -14252,15 +12603,32 @@ export class PostgreSqlParser extends SQLParserBase { } public opt_column_list_create(): Opt_column_list_createContext { let localContext = new Opt_column_list_createContext(this.context, this.state); - this.enterRule(localContext, 242, PostgreSqlParser.RULE_opt_column_list_create); + this.enterRule(localContext, 146, PostgreSqlParser.RULE_opt_column_list_create); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3391; + this.state = 2473; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3392; - this.column_list_create(); - this.state = 3393; + this.state = 2474; + this.column_name_create(); + this.state = 2479; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 2475; + this.match(PostgreSqlParser.COMMA); + this.state = 2476; + this.column_name_create(); + } + } + this.state = 2481; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2482; this.match(PostgreSqlParser.CLOSE_PAREN); } } @@ -14280,30 +12648,30 @@ export class PostgreSqlParser extends SQLParserBase { } public column_list(): Column_listContext { let localContext = new Column_listContext(this.context, this.state); - this.enterRule(localContext, 244, PostgreSqlParser.RULE_column_list); + this.enterRule(localContext, 148, PostgreSqlParser.RULE_column_list); try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 3395; + this.state = 2484; this.column_name(); - this.state = 3400; + this.state = 2489; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 227, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 236, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { { { - this.state = 3396; + this.state = 2485; this.match(PostgreSqlParser.COMMA); - this.state = 3397; + this.state = 2486; this.column_name(); } } } - this.state = 3402; + this.state = 2491; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 227, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 236, this.context); } } } @@ -14321,61 +12689,16 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public column_list_create(): Column_list_createContext { - let localContext = new Column_list_createContext(this.context, this.state); - this.enterRule(localContext, 246, PostgreSqlParser.RULE_column_list_create); - let _la: number; + public opt_c_include(): Opt_c_includeContext { + let localContext = new Opt_c_includeContext(this.context, this.state); + this.enterRule(localContext, 150, PostgreSqlParser.RULE_opt_c_include); try { this.enterOuterAlt(localContext, 1); { - this.state = 3403; - this.column_name_create(); - this.state = 3408; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 3404; - this.match(PostgreSqlParser.COMMA); - this.state = 3405; - this.column_name_create(); - } - } - this.state = 3410; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_c_include(): Opt_c_includeContext { - let localContext = new Opt_c_includeContext(this.context, this.state); - this.enterRule(localContext, 248, PostgreSqlParser.RULE_opt_c_include); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3411; + this.state = 2492; this.match(PostgreSqlParser.KW_INCLUDE); - this.state = 3412; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3413; - this.column_list(); - this.state = 3414; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 2493; + this.opt_column_list(); } } catch (re) { @@ -14394,14 +12717,14 @@ export class PostgreSqlParser extends SQLParserBase { } public key_match(): Key_matchContext { let localContext = new Key_matchContext(this.context, this.state); - this.enterRule(localContext, 250, PostgreSqlParser.RULE_key_match); + this.enterRule(localContext, 152, PostgreSqlParser.RULE_key_match); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3416; + this.state = 2495; this.match(PostgreSqlParser.KW_MATCH); - this.state = 3417; + this.state = 2496; _la = this.tokenStream.LA(1); if(!(_la === 113 || _la === 284 || _la === 336)) { this.errorHandler.recoverInline(this); @@ -14426,75 +12749,34 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public exclusionconstraintlist(): ExclusionconstraintlistContext { - let localContext = new ExclusionconstraintlistContext(this.context, this.state); - this.enterRule(localContext, 252, PostgreSqlParser.RULE_exclusionconstraintlist); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3419; - this.exclusionconstraintelem(); - this.state = 3424; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 3420; - this.match(PostgreSqlParser.COMMA); - this.state = 3421; - this.exclusionconstraintelem(); - } - } - this.state = 3426; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public exclusionconstraintelem(): ExclusionconstraintelemContext { let localContext = new ExclusionconstraintelemContext(this.context, this.state); - this.enterRule(localContext, 254, PostgreSqlParser.RULE_exclusionconstraintelem); + this.enterRule(localContext, 154, PostgreSqlParser.RULE_exclusionconstraintelem); try { this.enterOuterAlt(localContext, 1); { - this.state = 3427; + this.state = 2498; this.index_elem(); - this.state = 3428; + this.state = 2499; this.match(PostgreSqlParser.KW_WITH); - this.state = 3435; + this.state = 2506; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 230, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 237, this.context) ) { case 1: { - this.state = 3429; + this.state = 2500; this.any_operator(); } break; case 2: { - this.state = 3430; + this.state = 2501; this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 3431; + this.state = 2502; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3432; + this.state = 2503; this.any_operator(); - this.state = 3433; + this.state = 2504; this.match(PostgreSqlParser.CLOSE_PAREN); } break; @@ -14515,73 +12797,46 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public exclusionwhereclause(): ExclusionwhereclauseContext { - let localContext = new ExclusionwhereclauseContext(this.context, this.state); - this.enterRule(localContext, 256, PostgreSqlParser.RULE_exclusionwhereclause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3437; - this.match(PostgreSqlParser.KW_WHERE); - this.state = 3438; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3439; - this.a_expr(); - this.state = 3440; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public key_actions(): Key_actionsContext { let localContext = new Key_actionsContext(this.context, this.state); - this.enterRule(localContext, 258, PostgreSqlParser.RULE_key_actions); + this.enterRule(localContext, 156, PostgreSqlParser.RULE_key_actions); + let _la: number; try { - this.state = 3450; + this.state = 2516; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 231, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 240, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 3442; + this.state = 2508; this.key_update(); + this.state = 2510; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 80) { + { + this.state = 2509; + this.key_delete(); + } + } + } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 3443; - this.key_delete(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 3444; - this.key_update(); - this.state = 3445; + this.state = 2512; this.key_delete(); + this.state = 2514; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 80) { + { + this.state = 2513; + this.key_update(); + } } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 3447; - this.key_delete(); - this.state = 3448; - this.key_update(); + } break; } @@ -14602,15 +12857,15 @@ export class PostgreSqlParser extends SQLParserBase { } public key_update(): Key_updateContext { let localContext = new Key_updateContext(this.context, this.state); - this.enterRule(localContext, 260, PostgreSqlParser.RULE_key_update); + this.enterRule(localContext, 158, PostgreSqlParser.RULE_key_update); try { this.enterOuterAlt(localContext, 1); { - this.state = 3452; + this.state = 2518; this.match(PostgreSqlParser.KW_ON); - this.state = 3453; + this.state = 2519; this.match(PostgreSqlParser.KW_UPDATE); - this.state = 3454; + this.state = 2520; this.key_action(); } } @@ -14630,15 +12885,15 @@ export class PostgreSqlParser extends SQLParserBase { } public key_delete(): Key_deleteContext { let localContext = new Key_deleteContext(this.context, this.state); - this.enterRule(localContext, 262, PostgreSqlParser.RULE_key_delete); + this.enterRule(localContext, 160, PostgreSqlParser.RULE_key_delete); try { this.enterOuterAlt(localContext, 1); { - this.state = 3456; + this.state = 2522; this.match(PostgreSqlParser.KW_ON); - this.state = 3457; + this.state = 2523; this.match(PostgreSqlParser.KW_DELETE); - this.state = 3458; + this.state = 2524; this.key_action(); } } @@ -14658,41 +12913,41 @@ export class PostgreSqlParser extends SQLParserBase { } public key_action(): Key_actionContext { let localContext = new Key_actionContext(this.context, this.state); - this.enterRule(localContext, 264, PostgreSqlParser.RULE_key_action); + this.enterRule(localContext, 162, PostgreSqlParser.RULE_key_action); let _la: number; try { - this.state = 3469; + this.state = 2535; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_NO: this.enterOuterAlt(localContext, 1); { - this.state = 3460; + this.state = 2526; this.match(PostgreSqlParser.KW_NO); - this.state = 3461; + this.state = 2527; this.match(PostgreSqlParser.KW_ACTION); } break; case PostgreSqlParser.KW_RESTRICT: this.enterOuterAlt(localContext, 2); { - this.state = 3462; + this.state = 2528; this.match(PostgreSqlParser.KW_RESTRICT); } break; case PostgreSqlParser.KW_CASCADE: this.enterOuterAlt(localContext, 3); { - this.state = 3463; + this.state = 2529; this.match(PostgreSqlParser.KW_CASCADE); } break; case PostgreSqlParser.KW_SET: this.enterOuterAlt(localContext, 4); { - this.state = 3464; + this.state = 2530; this.match(PostgreSqlParser.KW_SET); - this.state = 3465; + this.state = 2531; _la = this.tokenStream.LA(1); if(!(_la === 53 || _la === 78)) { this.errorHandler.recoverInline(this); @@ -14701,12 +12956,12 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 3467; + this.state = 2533; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 232, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 241, this.context) ) { case 1: { - this.state = 3466; + this.state = 2532; this.column_list(); } break; @@ -14733,17 +12988,17 @@ export class PostgreSqlParser extends SQLParserBase { } public optinherit(): OptinheritContext { let localContext = new OptinheritContext(this.context, this.state); - this.enterRule(localContext, 266, PostgreSqlParser.RULE_optinherit); + this.enterRule(localContext, 164, PostgreSqlParser.RULE_optinherit); try { this.enterOuterAlt(localContext, 1); { - this.state = 3471; + this.state = 2537; this.match(PostgreSqlParser.KW_INHERITS); - this.state = 3472; + this.state = 2538; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3473; + this.state = 2539; this.qualified_name_list(); - this.state = 3474; + this.state = 2540; this.match(PostgreSqlParser.CLOSE_PAREN); } } @@ -14761,89 +13016,41 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public optpartitionspec(): OptpartitionspecContext { - let localContext = new OptpartitionspecContext(this.context, this.state); - this.enterRule(localContext, 268, PostgreSqlParser.RULE_optpartitionspec); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3476; - this.partitionspec(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public partitionspec(): PartitionspecContext { let localContext = new PartitionspecContext(this.context, this.state); - this.enterRule(localContext, 270, PostgreSqlParser.RULE_partitionspec); + this.enterRule(localContext, 166, PostgreSqlParser.RULE_partitionspec); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3478; + this.state = 2542; this.match(PostgreSqlParser.KW_PARTITION); - this.state = 3479; + this.state = 2543; this.match(PostgreSqlParser.KW_BY); - this.state = 3480; + this.state = 2544; this.colid(); - this.state = 3481; + this.state = 2545; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3482; - this.part_params(); - this.state = 3483; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public part_params(): Part_paramsContext { - let localContext = new Part_paramsContext(this.context, this.state); - this.enterRule(localContext, 272, PostgreSqlParser.RULE_part_params); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3485; + this.state = 2546; this.part_elem(); - this.state = 3490; + this.state = 2551; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 3486; + this.state = 2547; this.match(PostgreSqlParser.COMMA); - this.state = 3487; + this.state = 2548; this.part_elem(); } } - this.state = 3492; + this.state = 2553; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } + this.state = 2554; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -14862,98 +13069,60 @@ export class PostgreSqlParser extends SQLParserBase { } public part_elem(): Part_elemContext { let localContext = new Part_elemContext(this.context, this.state); - this.enterRule(localContext, 274, PostgreSqlParser.RULE_part_elem); + this.enterRule(localContext, 168, PostgreSqlParser.RULE_part_elem); let _la: number; try { - this.state = 3516; + this.enterOuterAlt(localContext, 1); + { + this.state = 2562; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 241, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 244, this.context) ) { case 1: - this.enterOuterAlt(localContext, 1); { - this.state = 3493; + this.state = 2556; this.column_name(); - this.state = 3495; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 235, this.context) ) { - case 1: - { - this.state = 3494; - this.opt_collate(); - } - break; - } - this.state = 3498; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { - { - this.state = 3497; - this.opt_class(); - } - } - } break; case 2: - this.enterOuterAlt(localContext, 2); { - this.state = 3500; + this.state = 2557; this.func_expr_windowless(); - this.state = 3502; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 237, this.context) ) { - case 1: - { - this.state = 3501; - this.opt_collate(); - } - break; - } - this.state = 3505; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { - { - this.state = 3504; - this.opt_class(); - } - } - } break; case 3: - this.enterOuterAlt(localContext, 3); { - this.state = 3507; + { + this.state = 2558; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3508; - this.a_expr(); - this.state = 3509; + this.state = 2559; + this.expression(); + this.state = 2560; this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 3511; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 239, this.context) ) { - case 1: - { - this.state = 3510; - this.opt_collate(); - } - break; } - this.state = 3514; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { - { - this.state = 3513; - this.opt_class(); - } } - + break; + } + this.state = 2565; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 245, this.context) ) { + case 1: + { + this.state = 2564; + this.opt_collate_clause(); } break; } + this.state = 2568; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { + { + this.state = 2567; + this.any_name(); + } + } + + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -14971,14 +13140,14 @@ export class PostgreSqlParser extends SQLParserBase { } public table_access_method_clause(): Table_access_method_clauseContext { let localContext = new Table_access_method_clauseContext(this.context, this.state); - this.enterRule(localContext, 276, PostgreSqlParser.RULE_table_access_method_clause); + this.enterRule(localContext, 170, PostgreSqlParser.RULE_table_access_method_clause); try { this.enterOuterAlt(localContext, 1); { - this.state = 3518; + this.state = 2570; this.match(PostgreSqlParser.KW_USING); - this.state = 3519; - this.name(); + this.state = 2571; + this.colid(); } } catch (re) { @@ -14997,35 +13166,34 @@ export class PostgreSqlParser extends SQLParserBase { } public optwith(): OptwithContext { let localContext = new OptwithContext(this.context, this.state); - this.enterRule(localContext, 278, PostgreSqlParser.RULE_optwith); + this.enterRule(localContext, 172, PostgreSqlParser.RULE_optwith); + let _la: number; try { - this.state = 3527; + this.state = 2577; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 242, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 247, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 3521; + this.state = 2573; this.match(PostgreSqlParser.KW_WITH); - this.state = 3522; + this.state = 2574; this.reloptions(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 3523; - this.match(PostgreSqlParser.KW_WITHOUT); - this.state = 3524; - this.match(PostgreSqlParser.KW_OIDS); + this.state = 2575; + _la = this.tokenStream.LA(1); + if(!(_la === 105 || _la === 379)) { + this.errorHandler.recoverInline(this); } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 3525; - this.match(PostgreSqlParser.KW_WITH); - this.state = 3526; + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2576; this.match(PostgreSqlParser.KW_OIDS); } break; @@ -15047,36 +13215,36 @@ export class PostgreSqlParser extends SQLParserBase { } public oncommitoption(): OncommitoptionContext { let localContext = new OncommitoptionContext(this.context, this.state); - this.enterRule(localContext, 280, PostgreSqlParser.RULE_oncommitoption); + this.enterRule(localContext, 174, PostgreSqlParser.RULE_oncommitoption); try { this.enterOuterAlt(localContext, 1); { - this.state = 3529; + this.state = 2579; this.match(PostgreSqlParser.KW_ON); - this.state = 3530; + this.state = 2580; this.match(PostgreSqlParser.KW_COMMIT); - this.state = 3536; + this.state = 2586; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_DROP: { - this.state = 3531; + this.state = 2581; this.match(PostgreSqlParser.KW_DROP); } break; case PostgreSqlParser.KW_DELETE: { - this.state = 3532; + this.state = 2582; this.match(PostgreSqlParser.KW_DELETE); - this.state = 3533; + this.state = 2583; this.match(PostgreSqlParser.KW_ROWS); } break; case PostgreSqlParser.KW_PRESERVE: { - this.state = 3534; + this.state = 2584; this.match(PostgreSqlParser.KW_PRESERVE); - this.state = 3535; + this.state = 2585; this.match(PostgreSqlParser.KW_ROWS); } break; @@ -15101,13 +13269,13 @@ export class PostgreSqlParser extends SQLParserBase { } public opttablespace(): OpttablespaceContext { let localContext = new OpttablespaceContext(this.context, this.state); - this.enterRule(localContext, 282, PostgreSqlParser.RULE_opttablespace); + this.enterRule(localContext, 176, PostgreSqlParser.RULE_opttablespace); try { this.enterOuterAlt(localContext, 1); { - this.state = 3538; + this.state = 2588; this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 3539; + this.state = 2589; this.tablespace_name(); } } @@ -15125,73 +13293,18 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public index_paramenters_create(): Index_paramenters_createContext { - let localContext = new Index_paramenters_createContext(this.context, this.state); - this.enterRule(localContext, 284, PostgreSqlParser.RULE_index_paramenters_create); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3542; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 244, this.context) ) { - case 1: - { - this.state = 3541; - this.opt_include(); - } - break; - } - this.state = 3545; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 245, this.context) ) { - case 1: - { - this.state = 3544; - this.with_clause(); - } - break; - } - this.state = 3548; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 100) { - { - this.state = 3547; - this.optconstablespace(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public optconstablespace(): OptconstablespaceContext { let localContext = new OptconstablespaceContext(this.context, this.state); - this.enterRule(localContext, 286, PostgreSqlParser.RULE_optconstablespace); + this.enterRule(localContext, 178, PostgreSqlParser.RULE_optconstablespace); try { this.enterOuterAlt(localContext, 1); { - this.state = 3550; + this.state = 2591; this.match(PostgreSqlParser.KW_USING); - this.state = 3551; + this.state = 2592; this.match(PostgreSqlParser.KW_INDEX); - this.state = 3552; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 3553; - this.tablespace_name(); + this.state = 2593; + this.opttablespace(); } } catch (re) { @@ -15210,16 +13323,16 @@ export class PostgreSqlParser extends SQLParserBase { } public existingindex(): ExistingindexContext { let localContext = new ExistingindexContext(this.context, this.state); - this.enterRule(localContext, 288, PostgreSqlParser.RULE_existingindex); + this.enterRule(localContext, 180, PostgreSqlParser.RULE_existingindex); try { this.enterOuterAlt(localContext, 1); { - this.state = 3555; + this.state = 2595; this.match(PostgreSqlParser.KW_USING); - this.state = 3556; + this.state = 2596; this.match(PostgreSqlParser.KW_INDEX); - this.state = 3557; - this.name(); + this.state = 2597; + this.colid(); } } catch (re) { @@ -15238,67 +13351,81 @@ export class PostgreSqlParser extends SQLParserBase { } public createstatsstmt(): CreatestatsstmtContext { let localContext = new CreatestatsstmtContext(this.context, this.state); - this.enterRule(localContext, 290, PostgreSqlParser.RULE_createstatsstmt); + this.enterRule(localContext, 182, PostgreSqlParser.RULE_createstatsstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3559; + this.state = 2599; this.match(PostgreSqlParser.KW_CREATE); - this.state = 3560; + this.state = 2600; this.match(PostgreSqlParser.KW_STATISTICS); - this.state = 3565; + this.state = 2605; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { - this.state = 3562; + this.state = 2602; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 247, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 249, this.context) ) { case 1: { - this.state = 3561; + this.state = 2601; this.opt_if_not_exists(); } break; } - this.state = 3564; + this.state = 2604; this.any_name(); } } - this.state = 3568; + this.state = 2608; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2) { { - this.state = 3567; - this.opt_name_list(); + this.state = 2607; + this.opt_column_list(); } } - this.state = 3570; + this.state = 2610; this.match(PostgreSqlParser.KW_ON); - this.state = 3573; + this.state = 2620; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 250, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 253, this.context) ) { case 1: { - this.state = 3571; - this.column_expr_list(); + this.state = 2611; + this.column_expr(); + this.state = 2616; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 2612; + this.match(PostgreSqlParser.COMMA); + this.state = 2613; + this.column_expr(); + } + } + this.state = 2618; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } } break; case 2: { - this.state = 3572; + this.state = 2619; this.expr_list(); } break; } - this.state = 3575; - this.match(PostgreSqlParser.KW_FROM); - this.state = 3576; - this.from_list(); + this.state = 2622; + this.from_clause(); } } catch (re) { @@ -15317,31 +13444,31 @@ export class PostgreSqlParser extends SQLParserBase { } public alterstatsstmt(): AlterstatsstmtContext { let localContext = new AlterstatsstmtContext(this.context, this.state); - this.enterRule(localContext, 292, PostgreSqlParser.RULE_alterstatsstmt); + this.enterRule(localContext, 184, PostgreSqlParser.RULE_alterstatsstmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 3578; + this.state = 2624; this.match(PostgreSqlParser.KW_ALTER); - this.state = 3579; + this.state = 2625; this.match(PostgreSqlParser.KW_STATISTICS); - this.state = 3581; + this.state = 2627; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 251, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 254, this.context) ) { case 1: { - this.state = 3580; + this.state = 2626; this.opt_if_exists(); } break; } - this.state = 3583; + this.state = 2629; this.any_name(); - this.state = 3584; + this.state = 2630; this.match(PostgreSqlParser.KW_SET); - this.state = 3585; + this.state = 2631; this.match(PostgreSqlParser.KW_STATISTICS); - this.state = 3586; + this.state = 2632; this.signediconst(); } } @@ -15361,48 +13488,48 @@ export class PostgreSqlParser extends SQLParserBase { } public createasstmt(): CreateasstmtContext { let localContext = new CreateasstmtContext(this.context, this.state); - this.enterRule(localContext, 294, PostgreSqlParser.RULE_createasstmt); + this.enterRule(localContext, 186, PostgreSqlParser.RULE_createasstmt); let _la: number; try { localContext = new QueryCreateTableContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 3588; + this.state = 2634; this.match(PostgreSqlParser.KW_CREATE); - this.state = 3590; + this.state = 2636; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 213 || _la === 254 || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & 32773) !== 0)) { { - this.state = 3589; + this.state = 2635; this.opttemp(); } } - this.state = 3592; + this.state = 2638; this.match(PostgreSqlParser.KW_TABLE); - this.state = 3594; + this.state = 2640; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 253, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 256, this.context) ) { case 1: { - this.state = 3593; + this.state = 2639; this.opt_if_not_exists(); } break; } - this.state = 3596; + this.state = 2642; this.create_as_target(); - this.state = 3597; + this.state = 2643; this.match(PostgreSqlParser.KW_AS); - this.state = 3598; + this.state = 2644; this.selectstmt(); - this.state = 3600; + this.state = 2646; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 254, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 257, this.context) ) { case 1: { - this.state = 3599; + this.state = 2645; this.opt_with_data(); } break; @@ -15425,59 +13552,59 @@ export class PostgreSqlParser extends SQLParserBase { } public create_as_target(): Create_as_targetContext { let localContext = new Create_as_targetContext(this.context, this.state); - this.enterRule(localContext, 296, PostgreSqlParser.RULE_create_as_target); + this.enterRule(localContext, 188, PostgreSqlParser.RULE_create_as_target); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3602; + this.state = 2648; this.table_name_create(); - this.state = 3604; + this.state = 2650; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2) { { - this.state = 3603; + this.state = 2649; this.opt_column_list_create(); } } - this.state = 3607; + this.state = 2653; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 3606; + this.state = 2652; this.table_access_method_clause(); } } - this.state = 3610; + this.state = 2656; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 105 || _la === 379) { { - this.state = 3609; + this.state = 2655; this.optwith(); } } - this.state = 3613; + this.state = 2659; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 80) { { - this.state = 3612; + this.state = 2658; this.oncommitoption(); } } - this.state = 3616; + this.state = 2662; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 351) { { - this.state = 3615; + this.state = 2661; this.opttablespace(); } } @@ -15500,26 +13627,26 @@ export class PostgreSqlParser extends SQLParserBase { } public opt_with_data(): Opt_with_dataContext { let localContext = new Opt_with_dataContext(this.context, this.state); - this.enterRule(localContext, 298, PostgreSqlParser.RULE_opt_with_data); + this.enterRule(localContext, 190, PostgreSqlParser.RULE_opt_with_data); try { this.enterOuterAlt(localContext, 1); { - this.state = 3618; + this.state = 2664; this.match(PostgreSqlParser.KW_WITH); - this.state = 3622; + this.state = 2668; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_DATA: { - this.state = 3619; + this.state = 2665; this.match(PostgreSqlParser.KW_DATA); } break; case PostgreSqlParser.KW_NO: { - this.state = 3620; + this.state = 2666; this.match(PostgreSqlParser.KW_NO); - this.state = 3621; + this.state = 2667; this.match(PostgreSqlParser.KW_DATA); } break; @@ -15544,143 +13671,94 @@ export class PostgreSqlParser extends SQLParserBase { } public creatematviewstmt(): CreatematviewstmtContext { let localContext = new CreatematviewstmtContext(this.context, this.state); - this.enterRule(localContext, 300, PostgreSqlParser.RULE_creatematviewstmt); + this.enterRule(localContext, 192, PostgreSqlParser.RULE_creatematviewstmt); let _la: number; try { localContext = new CreateMaterializedViewContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 3624; + this.state = 2670; this.match(PostgreSqlParser.KW_CREATE); - this.state = 3626; + this.state = 2672; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 367) { { - this.state = 3625; - this.optnolog(); + this.state = 2671; + this.match(PostgreSqlParser.KW_UNLOGGED); } } - this.state = 3628; + this.state = 2674; this.match(PostgreSqlParser.KW_MATERIALIZED); - this.state = 3629; + this.state = 2675; this.match(PostgreSqlParser.KW_VIEW); - this.state = 3631; + this.state = 2677; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 262, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 265, this.context) ) { case 1: { - this.state = 3630; + this.state = 2676; this.opt_if_not_exists(); } break; } - this.state = 3633; - this.create_mv_target(); - this.state = 3634; - this.match(PostgreSqlParser.KW_AS); - this.state = 3635; - this.selectstmt(); - this.state = 3637; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 263, this.context) ) { - case 1: - { - this.state = 3636; - this.opt_with_data(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public create_mv_target(): Create_mv_targetContext { - let localContext = new Create_mv_targetContext(this.context, this.state); - this.enterRule(localContext, 302, PostgreSqlParser.RULE_create_mv_target); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3639; + this.state = 2679; this.view_name_create(); - this.state = 3641; + this.state = 2681; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 2) { { - this.state = 3640; + this.state = 2680; this.opt_column_list_create(); } } - this.state = 3644; + this.state = 2684; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 3643; + this.state = 2683; this.table_access_method_clause(); } } - this.state = 3647; + this.state = 2687; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 105) { { - this.state = 3646; + this.state = 2686; this.opt_reloptions(); } } - this.state = 3650; + this.state = 2690; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 351) { { - this.state = 3649; + this.state = 2689; this.opttablespace(); } } + this.state = 2692; + this.match(PostgreSqlParser.KW_AS); + this.state = 2693; + this.selectstmt(); + this.state = 2695; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 270, this.context) ) { + case 1: + { + this.state = 2694; + this.opt_with_data(); + } + break; } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public optnolog(): OptnologContext { - let localContext = new OptnologContext(this.context, this.state); - this.enterRule(localContext, 304, PostgreSqlParser.RULE_optnolog); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3652; - this.match(PostgreSqlParser.KW_UNLOGGED); } } catch (re) { @@ -15699,35 +13777,35 @@ export class PostgreSqlParser extends SQLParserBase { } public refreshmatviewstmt(): RefreshmatviewstmtContext { let localContext = new RefreshmatviewstmtContext(this.context, this.state); - this.enterRule(localContext, 306, PostgreSqlParser.RULE_refreshmatviewstmt); + this.enterRule(localContext, 194, PostgreSqlParser.RULE_refreshmatviewstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3654; + this.state = 2697; this.match(PostgreSqlParser.KW_REFRESH); - this.state = 3655; + this.state = 2698; this.match(PostgreSqlParser.KW_MATERIALIZED); - this.state = 3656; + this.state = 2699; this.match(PostgreSqlParser.KW_VIEW); - this.state = 3658; + this.state = 2701; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 109) { { - this.state = 3657; - this.opt_concurrently(); + this.state = 2700; + this.match(PostgreSqlParser.KW_CONCURRENTLY); } } - this.state = 3660; + this.state = 2703; this.view_name(); - this.state = 3662; + this.state = 2705; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 269, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 272, this.context) ) { case 1: { - this.state = 3661; + this.state = 2704; this.opt_with_data(); } break; @@ -15750,44 +13828,63 @@ export class PostgreSqlParser extends SQLParserBase { } public createseqstmt(): CreateseqstmtContext { let localContext = new CreateseqstmtContext(this.context, this.state); - this.enterRule(localContext, 308, PostgreSqlParser.RULE_createseqstmt); + this.enterRule(localContext, 196, PostgreSqlParser.RULE_createseqstmt); let _la: number; try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 3664; + this.state = 2707; this.match(PostgreSqlParser.KW_CREATE); - this.state = 3666; + this.state = 2709; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 213 || _la === 254 || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & 32773) !== 0)) { { - this.state = 3665; + this.state = 2708; this.opttemp(); } } - this.state = 3668; + this.state = 2711; this.match(PostgreSqlParser.KW_SEQUENCE); - this.state = 3670; + this.state = 2713; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 271, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 274, this.context) ) { case 1: { - this.state = 3669; + this.state = 2712; this.opt_if_not_exists(); } break; } - this.state = 3672; + this.state = 2715; this.qualified_name(); - this.state = 3674; + this.state = 2721; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 272, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 276, this.context) ) { case 1: { - this.state = 3673; - this.optseqoptlist(); + this.state = 2717; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 2716; + this.seqoptelem(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 2719; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 275, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); } break; } @@ -15809,104 +13906,28 @@ export class PostgreSqlParser extends SQLParserBase { } public alterseqstmt(): AlterseqstmtContext { let localContext = new AlterseqstmtContext(this.context, this.state); - this.enterRule(localContext, 310, PostgreSqlParser.RULE_alterseqstmt); + this.enterRule(localContext, 198, PostgreSqlParser.RULE_alterseqstmt); try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 3676; + this.state = 2723; this.match(PostgreSqlParser.KW_ALTER); - this.state = 3677; + this.state = 2724; this.match(PostgreSqlParser.KW_SEQUENCE); - this.state = 3679; + this.state = 2726; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 273, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 277, this.context) ) { case 1: { - this.state = 3678; + this.state = 2725; this.opt_if_exists(); } break; } - this.state = 3681; + this.state = 2728; this.qualified_name(); - this.state = 3682; - this.seqoptlist(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public optseqoptlist(): OptseqoptlistContext { - let localContext = new OptseqoptlistContext(this.context, this.state); - this.enterRule(localContext, 312, PostgreSqlParser.RULE_optseqoptlist); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3684; - this.seqoptlist(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public optparenthesizedseqoptlist(): OptparenthesizedseqoptlistContext { - let localContext = new OptparenthesizedseqoptlistContext(this.context, this.state); - this.enterRule(localContext, 314, PostgreSqlParser.RULE_optparenthesizedseqoptlist); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3686; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3687; - this.seqoptlist(); - this.state = 3688; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public seqoptlist(): SeqoptlistContext { - let localContext = new SeqoptlistContext(this.context, this.state); - this.enterRule(localContext, 316, PostgreSqlParser.RULE_seqoptlist); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 3691; + this.state = 2730; this.errorHandler.sync(this); alternative = 1; do { @@ -15914,7 +13935,7 @@ export class PostgreSqlParser extends SQLParserBase { case 1: { { - this.state = 3690; + this.state = 2729; this.seqoptelem(); } } @@ -15922,9 +13943,9 @@ export class PostgreSqlParser extends SQLParserBase { default: throw new antlr.NoViableAltException(this); } - this.state = 3693; + this.state = 2732; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 274, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 278, this.context); } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); } } @@ -15944,80 +13965,80 @@ export class PostgreSqlParser extends SQLParserBase { } public seqoptelem(): SeqoptelemContext { let localContext = new SeqoptelemContext(this.context, this.state); - this.enterRule(localContext, 318, PostgreSqlParser.RULE_seqoptelem); + this.enterRule(localContext, 200, PostgreSqlParser.RULE_seqoptelem); let _la: number; try { - this.state = 3729; + this.state = 2767; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_AS: this.enterOuterAlt(localContext, 1); { - this.state = 3695; + this.state = 2734; this.match(PostgreSqlParser.KW_AS); - this.state = 3696; + this.state = 2735; this.simpletypename(); } break; case PostgreSqlParser.KW_CACHE: this.enterOuterAlt(localContext, 2); { - this.state = 3697; + this.state = 2736; this.match(PostgreSqlParser.KW_CACHE); - this.state = 3698; - this.numericonly(); + this.state = 2738; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 12 || _la === 13 || _la === 571 || _la === 573) { + { + this.state = 2737; + this.numericonly(); + } } - break; - case PostgreSqlParser.KW_CYCLE: - this.enterOuterAlt(localContext, 3); - { - this.state = 3699; - this.match(PostgreSqlParser.KW_CYCLE); + } break; case PostgreSqlParser.KW_INCREMENT: - this.enterOuterAlt(localContext, 4); + this.enterOuterAlt(localContext, 3); { - this.state = 3700; + this.state = 2740; this.match(PostgreSqlParser.KW_INCREMENT); - this.state = 3702; + this.state = 2742; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 147) { { - this.state = 3701; - this.opt_by(); + this.state = 2741; + this.match(PostgreSqlParser.KW_BY); } } - this.state = 3704; + this.state = 2744; this.numericonly(); } break; case PostgreSqlParser.KW_MAXVALUE: - this.enterOuterAlt(localContext, 5); - { - this.state = 3705; - this.match(PostgreSqlParser.KW_MAXVALUE); - this.state = 3706; - this.numericonly(); - } - break; case PostgreSqlParser.KW_MINVALUE: - this.enterOuterAlt(localContext, 6); + this.enterOuterAlt(localContext, 4); { - this.state = 3707; - this.match(PostgreSqlParser.KW_MINVALUE); - this.state = 3708; + this.state = 2745; + _la = this.tokenStream.LA(1); + if(!(_la === 260 || _la === 262)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2746; this.numericonly(); } break; case PostgreSqlParser.KW_NO: - this.enterOuterAlt(localContext, 7); + this.enterOuterAlt(localContext, 5); { - this.state = 3709; + this.state = 2747; this.match(PostgreSqlParser.KW_NO); - this.state = 3710; + this.state = 2748; _la = this.tokenStream.LA(1); if(!(_la === 173 || _la === 260 || _la === 262)) { this.errorHandler.recoverInline(this); @@ -16029,67 +14050,67 @@ export class PostgreSqlParser extends SQLParserBase { } break; case PostgreSqlParser.KW_OWNED: - this.enterOuterAlt(localContext, 8); + this.enterOuterAlt(localContext, 6); { - this.state = 3711; + this.state = 2749; this.match(PostgreSqlParser.KW_OWNED); - this.state = 3712; + this.state = 2750; this.match(PostgreSqlParser.KW_BY); - this.state = 3713; + this.state = 2751; this.column_name(); } break; case PostgreSqlParser.KW_SEQUENCE: - this.enterOuterAlt(localContext, 9); + this.enterOuterAlt(localContext, 7); { - this.state = 3714; + this.state = 2752; this.match(PostgreSqlParser.KW_SEQUENCE); - this.state = 3715; + this.state = 2753; this.match(PostgreSqlParser.KW_NAME); - this.state = 3716; + this.state = 2754; this.any_name(); } break; case PostgreSqlParser.KW_START: - this.enterOuterAlt(localContext, 10); + this.enterOuterAlt(localContext, 8); { - this.state = 3717; + this.state = 2755; this.match(PostgreSqlParser.KW_START); - this.state = 3719; + this.state = 2757; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 105) { { - this.state = 3718; - this.opt_with(); + this.state = 2756; + this.match(PostgreSqlParser.KW_WITH); } } - this.state = 3721; + this.state = 2759; this.numericonly(); } break; case PostgreSqlParser.KW_RESTART: - this.enterOuterAlt(localContext, 11); + this.enterOuterAlt(localContext, 9); { - this.state = 3722; + this.state = 2760; this.match(PostgreSqlParser.KW_RESTART); - this.state = 3724; + this.state = 2762; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 277, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 282, this.context) ) { case 1: { - this.state = 3723; - this.opt_with(); + this.state = 2761; + this.match(PostgreSqlParser.KW_WITH); } break; } - this.state = 3727; + this.state = 2765; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 12 || _la === 13 || _la === 571 || _la === 573) { { - this.state = 3726; + this.state = 2764; this.numericonly(); } } @@ -16114,66 +14135,42 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_by(): Opt_byContext { - let localContext = new Opt_byContext(this.context, this.state); - this.enterRule(localContext, 320, PostgreSqlParser.RULE_opt_by); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3731; - this.match(PostgreSqlParser.KW_BY); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public numericonly(): NumericonlyContext { let localContext = new NumericonlyContext(this.context, this.state); - this.enterRule(localContext, 322, PostgreSqlParser.RULE_numericonly); + this.enterRule(localContext, 202, PostgreSqlParser.RULE_numericonly); + let _la: number; try { - this.state = 3739; + this.state = 2774; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 280, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 286, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 3733; - this.fconst(); + this.state = 2770; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 12 || _la === 13) { + { + this.state = 2769; + _la = this.tokenStream.LA(1); + if(!(_la === 12 || _la === 13)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 2772; + this.match(PostgreSqlParser.Numeric); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 3734; - this.match(PostgreSqlParser.PLUS); - this.state = 3735; - this.fconst(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 3736; - this.match(PostgreSqlParser.MINUS); - this.state = 3737; - this.fconst(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 3738; + this.state = 2773; this.signediconst(); } break; @@ -16193,116 +14190,87 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public numericonly_list(): Numericonly_listContext { - let localContext = new Numericonly_listContext(this.context, this.state); - this.enterRule(localContext, 324, PostgreSqlParser.RULE_numericonly_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3741; - this.numericonly(); - this.state = 3746; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 3742; - this.match(PostgreSqlParser.COMMA); - this.state = 3743; - this.numericonly(); - } - } - this.state = 3748; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public createplangstmt(): CreateplangstmtContext { let localContext = new CreateplangstmtContext(this.context, this.state); - this.enterRule(localContext, 326, PostgreSqlParser.RULE_createplangstmt); + this.enterRule(localContext, 204, PostgreSqlParser.RULE_createplangstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3749; + this.state = 2776; this.match(PostgreSqlParser.KW_CREATE); - this.state = 3751; + this.state = 2778; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 82) { { - this.state = 3750; + this.state = 2777; this.opt_or_replace(); } } - this.state = 3754; + this.state = 2781; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 359) { { - this.state = 3753; - this.opt_trusted(); + this.state = 2780; + this.match(PostgreSqlParser.KW_TRUSTED); } } - this.state = 3757; + this.state = 2784; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 295) { { - this.state = 3756; - this.opt_procedural(); + this.state = 2783; + this.match(PostgreSqlParser.KW_PROCEDURAL); } } - this.state = 3759; + this.state = 2786; this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 3760; - this.name(); - this.state = 3769; + this.state = 2787; + this.colid(); + this.state = 2800; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 287, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 292, this.context) ) { case 1: { - this.state = 3761; + this.state = 2788; this.match(PostgreSqlParser.KW_HANDLER); - this.state = 3762; - this.handler_name(); - this.state = 3764; + this.state = 2789; + this.any_name(); + this.state = 2792; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 285, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 290, this.context) ) { case 1: { - this.state = 3763; - this.opt_inline_handler(); + this.state = 2790; + this.match(PostgreSqlParser.KW_INLINE); + this.state = 2791; + this.any_name(); } break; } - this.state = 3767; + this.state = 2798; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 286, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 291, this.context) ) { case 1: { - this.state = 3766; - this.opt_validator(); + this.state = 2794; + this.match(PostgreSqlParser.KW_VALIDATOR); + this.state = 2795; + this.any_name(); + } + break; + case 2: + { + this.state = 2796; + this.match(PostgreSqlParser.KW_NO); + this.state = 2797; + this.match(PostgreSqlParser.KW_VALIDATOR); } break; } @@ -16325,49 +14293,43 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_trusted(): Opt_trustedContext { - let localContext = new Opt_trustedContext(this.context, this.state); - this.enterRule(localContext, 328, PostgreSqlParser.RULE_opt_trusted); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3771; - this.match(PostgreSqlParser.KW_TRUSTED); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public handler_name(): Handler_nameContext { - let localContext = new Handler_nameContext(this.context, this.state); - this.enterRule(localContext, 330, PostgreSqlParser.RULE_handler_name); + public createtablespacestmt(): CreatetablespacestmtContext { + let localContext = new CreatetablespacestmtContext(this.context, this.state); + this.enterRule(localContext, 206, PostgreSqlParser.RULE_createtablespacestmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3773; - this.name(); - this.state = 3775; + this.state = 2802; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 2803; + this.opttablespace(); + this.state = 2806; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 11) { + if (_la === 282) { { - this.state = 3774; - this.attrs(); + this.state = 2804; + this.match(PostgreSqlParser.KW_OWNER); + this.state = 2805; + this.rolespec(); } } + this.state = 2808; + this.match(PostgreSqlParser.KW_LOCATION); + this.state = 2809; + this.sconst(); + this.state = 2811; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 294, this.context) ) { + case 1: + { + this.state = 2810; + this.opt_reloptions(); + } + break; + } } } catch (re) { @@ -16384,83 +14346,88 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_inline_handler(): Opt_inline_handlerContext { - let localContext = new Opt_inline_handlerContext(this.context, this.state); - this.enterRule(localContext, 332, PostgreSqlParser.RULE_opt_inline_handler); + public createextensionstmt(): CreateextensionstmtContext { + let localContext = new CreateextensionstmtContext(this.context, this.state); + this.enterRule(localContext, 208, PostgreSqlParser.RULE_createextensionstmt); + let _la: number; try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 3777; - this.match(PostgreSqlParser.KW_INLINE); - this.state = 3778; - this.handler_name(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public validator_clause(): Validator_clauseContext { - let localContext = new Validator_clauseContext(this.context, this.state); - this.enterRule(localContext, 334, PostgreSqlParser.RULE_validator_clause); - try { - this.state = 3784; + this.state = 2813; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 2814; + this.match(PostgreSqlParser.KW_EXTENSION); + this.state = 2816; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_VALIDATOR: - this.enterOuterAlt(localContext, 1); + switch (this.interpreter.adaptivePredict(this.tokenStream, 295, this.context) ) { + case 1: { - this.state = 3780; - this.match(PostgreSqlParser.KW_VALIDATOR); - this.state = 3781; - this.handler_name(); + this.state = 2815; + this.opt_if_not_exists(); } break; - case PostgreSqlParser.KW_NO: - this.enterOuterAlt(localContext, 2); + } + this.state = 2818; + this.colid(); + this.state = 2820; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 296, this.context) ) { + case 1: { - this.state = 3782; - this.match(PostgreSqlParser.KW_NO); - this.state = 3783; - this.match(PostgreSqlParser.KW_VALIDATOR); + this.state = 2819; + this.match(PostgreSqlParser.KW_WITH); } break; - default: - throw new antlr.NoViableAltException(this); } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + this.state = 2829; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 298, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + this.state = 2827; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_SCHEMA: + { + this.state = 2822; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 2823; + this.schema_name(); + } + break; + case PostgreSqlParser.KW_FROM: + case PostgreSqlParser.KW_VERSION: + { + this.state = 2824; + _la = this.tokenStream.LA(1); + if(!(_la === 64 || _la === 375)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2825; + this.nonreservedword_or_sconst(); + } + break; + case PostgreSqlParser.KW_CASCADE: + { + this.state = 2826; + this.match(PostgreSqlParser.KW_CASCADE); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + this.state = 2831; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 298, this.context); } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_validator(): Opt_validatorContext { - let localContext = new Opt_validatorContext(this.context, this.state); - this.enterRule(localContext, 336, PostgreSqlParser.RULE_opt_validator); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3786; - this.validator_clause(); } } catch (re) { @@ -16477,14 +14444,37 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_procedural(): Opt_proceduralContext { - let localContext = new Opt_proceduralContext(this.context, this.state); - this.enterRule(localContext, 338, PostgreSqlParser.RULE_opt_procedural); + public alterextensionstmt(): AlterextensionstmtContext { + let localContext = new AlterextensionstmtContext(this.context, this.state); + this.enterRule(localContext, 210, PostgreSqlParser.RULE_alterextensionstmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3788; - this.match(PostgreSqlParser.KW_PROCEDURAL); + this.state = 2832; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 2833; + this.match(PostgreSqlParser.KW_EXTENSION); + this.state = 2834; + this.colid(); + this.state = 2835; + this.match(PostgreSqlParser.KW_UPDATE); + this.state = 2840; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 94) { + { + { + this.state = 2836; + this.match(PostgreSqlParser.KW_TO); + this.state = 2837; + this.nonreservedword_or_sconst(); + } + } + this.state = 2842; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } } } catch (re) { @@ -16501,40 +14491,145 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public createtablespacestmt(): CreatetablespacestmtContext { - let localContext = new CreatetablespacestmtContext(this.context, this.state); - this.enterRule(localContext, 340, PostgreSqlParser.RULE_createtablespacestmt); + public alterextensioncontentsstmt(): AlterextensioncontentsstmtContext { + let localContext = new AlterextensioncontentsstmtContext(this.context, this.state); + this.enterRule(localContext, 212, PostgreSqlParser.RULE_alterextensioncontentsstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3790; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 3791; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 3792; - this.tablespace_name(); - this.state = 3794; - this.errorHandler.sync(this); + this.state = 2843; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 2844; + this.match(PostgreSqlParser.KW_EXTENSION); + this.state = 2845; + this.colid(); + this.state = 2846; _la = this.tokenStream.LA(1); - if (_la === 282) { - { - this.state = 3793; - this.opttablespaceowner(); - } + if(!(_la === 133 || _la === 191)) { + this.errorHandler.recoverInline(this); } - - this.state = 3796; - this.match(PostgreSqlParser.KW_LOCATION); - this.state = 3797; - this.sconst(); - this.state = 3799; + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2879; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 291, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 300, this.context) ) { case 1: { - this.state = 3798; - this.opt_reloptions(); + this.state = 2847; + this.match(PostgreSqlParser.KW_TRANSFORM); + this.state = 2848; + this.match(PostgreSqlParser.KW_FOR); + this.state = 2849; + this.typename(); + this.state = 2850; + this.match(PostgreSqlParser.KW_LANGUAGE); + this.state = 2851; + this.colid(); + } + break; + case 2: + { + this.state = 2853; + this.match(PostgreSqlParser.KW_ROUTINE); + this.state = 2854; + this.routine_with_argtypes(); + } + break; + case 3: + { + this.state = 2855; + this.match(PostgreSqlParser.KW_PROCEDURE); + this.state = 2856; + this.procedure_with_argtypes(); + } + break; + case 4: + { + this.state = 2857; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 2858; + _la = this.tokenStream.LA(1); + if(!(_la === 156 || _la === 206)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2859; + this.any_name(); + this.state = 2860; + this.table_access_method_clause(); + } + break; + case 5: + { + this.state = 2862; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 2863; + this.operator_with_argtypes(); + } + break; + case 6: + { + this.state = 2864; + this.match(PostgreSqlParser.KW_FUNCTION); + this.state = 2865; + this.function_with_argtypes(); + } + break; + case 7: + { + this.state = 2866; + _la = this.tokenStream.LA(1); + if(!(_la === 189 || _la === 360)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2867; + this.typename(); + } + break; + case 8: + { + this.state = 2868; + this.match(PostgreSqlParser.KW_CAST); + this.state = 2869; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 2870; + this.typename(); + this.state = 2871; + this.match(PostgreSqlParser.KW_AS); + this.state = 2872; + this.typename(); + this.state = 2873; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case 9: + { + this.state = 2875; + this.match(PostgreSqlParser.KW_AGGREGATE); + this.state = 2876; + this.aggregate_with_argtypes(); + } + break; + case 10: + { + this.state = 2877; + this.object_type_name(); + } + break; + case 11: + { + this.state = 2878; + this.object_type_any_name(); } break; } @@ -16554,66 +14649,61 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opttablespaceowner(): OpttablespaceownerContext { - let localContext = new OpttablespaceownerContext(this.context, this.state); - this.enterRule(localContext, 342, PostgreSqlParser.RULE_opttablespaceowner); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3801; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 3802; - this.rolespec(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createextensionstmt(): CreateextensionstmtContext { - let localContext = new CreateextensionstmtContext(this.context, this.state); - this.enterRule(localContext, 344, PostgreSqlParser.RULE_createextensionstmt); + public createfdwstmt(): CreatefdwstmtContext { + let localContext = new CreatefdwstmtContext(this.context, this.state); + this.enterRule(localContext, 214, PostgreSqlParser.RULE_createfdwstmt); try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 3804; + this.state = 2881; this.match(PostgreSqlParser.KW_CREATE); - this.state = 3805; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3807; + this.state = 2882; + this.match(PostgreSqlParser.KW_FOREIGN); + this.state = 2883; + this.match(PostgreSqlParser.KW_DATA); + this.state = 2884; + this.match(PostgreSqlParser.KW_WRAPPER); + this.state = 2885; + this.colid(); + this.state = 2891; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 292, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 302, this.context) ) { case 1: { - this.state = 3806; - this.opt_if_not_exists(); + this.state = 2887; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 2886; + this.fdw_option(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 2889; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 301, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); } break; } - this.state = 3809; - this.name(); - this.state = 3811; + this.state = 2894; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 293, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 303, this.context) ) { case 1: { - this.state = 3810; - this.opt_with(); + this.state = 2893; + this.create_generic_options(); } break; } - this.state = 3813; - this.create_extension_opt_list(); } } catch (re) { @@ -16630,29 +14720,57 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public create_extension_opt_list(): Create_extension_opt_listContext { - let localContext = new Create_extension_opt_listContext(this.context, this.state); - this.enterRule(localContext, 346, PostgreSqlParser.RULE_create_extension_opt_list); + public fdw_option(): Fdw_optionContext { + let localContext = new Fdw_optionContext(this.context, this.state); + this.enterRule(localContext, 216, PostgreSqlParser.RULE_fdw_option); + let _la: number; try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 3818; + this.state = 2902; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 294, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_VALIDATOR: + this.enterOuterAlt(localContext, 1); + { + this.state = 2896; + _la = this.tokenStream.LA(1); + if(!(_la === 215 || _la === 373)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2898; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 304, this.context) ) { + case 1: { - this.state = 3815; - this.create_extension_opt_item(); - } + this.state = 2897; + this.any_name(); } + break; } - this.state = 3820; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 294, this.context); - } + } + break; + case PostgreSqlParser.KW_NO: + this.enterOuterAlt(localContext, 2); + { + this.state = 2900; + this.match(PostgreSqlParser.KW_NO); + this.state = 2901; + _la = this.tokenStream.LA(1); + if(!(_la === 215 || _la === 373)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -16669,49 +14787,80 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public create_extension_opt_item(): Create_extension_opt_itemContext { - let localContext = new Create_extension_opt_itemContext(this.context, this.state); - this.enterRule(localContext, 348, PostgreSqlParser.RULE_create_extension_opt_item); + public alterfdwstmt(): AlterfdwstmtContext { + let localContext = new AlterfdwstmtContext(this.context, this.state); + this.enterRule(localContext, 218, PostgreSqlParser.RULE_alterfdwstmt); + let _la: number; try { - this.state = 3828; + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 2904; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 2905; + this.match(PostgreSqlParser.KW_FOREIGN); + this.state = 2906; + this.match(PostgreSqlParser.KW_DATA); + this.state = 2907; + this.match(PostgreSqlParser.KW_WRAPPER); + this.state = 2908; + this.colid(); + this.state = 2922; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_SCHEMA: - this.enterOuterAlt(localContext, 1); - { - this.state = 3821; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 3822; - this.schema_name(); - } - break; - case PostgreSqlParser.KW_VERSION: - this.enterOuterAlt(localContext, 2); + switch (this.interpreter.adaptivePredict(this.tokenStream, 309, this.context) ) { + case 1: { - this.state = 3823; - this.match(PostgreSqlParser.KW_VERSION); - this.state = 3824; - this.nonreservedword_or_sconst(); + this.state = 2914; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 215 || _la === 269 || _la === 373) { + { + this.state = 2910; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 2909; + this.fdw_option(); + } + } + this.state = 2912; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 215 || _la === 269 || _la === 373); + } } - break; - case PostgreSqlParser.KW_FROM: - this.enterOuterAlt(localContext, 3); - { - this.state = 3825; - this.match(PostgreSqlParser.KW_FROM); - this.state = 3826; - this.nonreservedword_or_sconst(); + + this.state = 2916; + this.alter_generic_options(); } break; - case PostgreSqlParser.KW_CASCADE: - this.enterOuterAlt(localContext, 4); + case 2: { - this.state = 3827; - this.match(PostgreSqlParser.KW_CASCADE); + this.state = 2918; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 2917; + this.fdw_option(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 2920; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 308, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); } break; - default: - throw new antlr.NoViableAltException(this); + } } } catch (re) { @@ -16728,22 +14877,37 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alterextensionstmt(): AlterextensionstmtContext { - let localContext = new AlterextensionstmtContext(this.context, this.state); - this.enterRule(localContext, 350, PostgreSqlParser.RULE_alterextensionstmt); + public create_generic_options(): Create_generic_optionsContext { + let localContext = new Create_generic_optionsContext(this.context, this.state); + this.enterRule(localContext, 220, PostgreSqlParser.RULE_create_generic_options); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3830; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3831; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3832; - this.name(); - this.state = 3833; - this.match(PostgreSqlParser.KW_UPDATE); - this.state = 3834; - this.alter_extension_opt_list(); + this.state = 2924; + this.match(PostgreSqlParser.KW_OPTIONS); + this.state = 2925; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 2926; + this.generic_option_elem(); + this.state = 2931; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 2927; + this.match(PostgreSqlParser.COMMA); + this.state = 2928; + this.generic_option_elem(); + } + } + this.state = 2933; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 2934; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -16760,27 +14924,37 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alter_extension_opt_list(): Alter_extension_opt_listContext { - let localContext = new Alter_extension_opt_listContext(this.context, this.state); - this.enterRule(localContext, 352, PostgreSqlParser.RULE_alter_extension_opt_list); + public alter_generic_options(): Alter_generic_optionsContext { + let localContext = new Alter_generic_optionsContext(this.context, this.state); + this.enterRule(localContext, 222, PostgreSqlParser.RULE_alter_generic_options); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3839; + this.state = 2936; + this.match(PostgreSqlParser.KW_OPTIONS); + this.state = 2937; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 2938; + this.alter_generic_option_elem(); + this.state = 2943; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - while (_la === 94) { + while (_la === 6) { { { - this.state = 3836; - this.alter_extension_opt_item(); + this.state = 2939; + this.match(PostgreSqlParser.COMMA); + this.state = 2940; + this.alter_generic_option_elem(); } } - this.state = 3841; + this.state = 2945; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } + this.state = 2946; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -16797,16 +14971,24 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alter_extension_opt_item(): Alter_extension_opt_itemContext { - let localContext = new Alter_extension_opt_itemContext(this.context, this.state); - this.enterRule(localContext, 354, PostgreSqlParser.RULE_alter_extension_opt_item); + public alter_generic_option_elem(): Alter_generic_option_elemContext { + let localContext = new Alter_generic_option_elemContext(this.context, this.state); + this.enterRule(localContext, 224, PostgreSqlParser.RULE_alter_generic_option_elem); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3842; - this.match(PostgreSqlParser.KW_TO); - this.state = 3843; - this.nonreservedword_or_sconst(); + this.state = 2948; + _la = this.tokenStream.LA(1); + if(!(_la === 133 || _la === 191 || _la === 333)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 2949; + this.generic_option_elem(); } } catch (re) { @@ -16823,256 +15005,16 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alterextensioncontentsstmt(): AlterextensioncontentsstmtContext { - let localContext = new AlterextensioncontentsstmtContext(this.context, this.state); - this.enterRule(localContext, 356, PostgreSqlParser.RULE_alterextensioncontentsstmt); + public generic_option_elem(): Generic_option_elemContext { + let localContext = new Generic_option_elemContext(this.context, this.state); + this.enterRule(localContext, 226, PostgreSqlParser.RULE_generic_option_elem); try { - this.state = 3947; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 297, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 3845; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3846; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3847; - this.name(); - this.state = 3848; - this.add_drop(); - this.state = 3849; - this.object_type_name(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 3851; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3852; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3853; - this.name(); - this.state = 3854; - this.add_drop(); - this.state = 3855; - this.object_type_any_name(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 3857; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3858; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3859; - this.name(); - this.state = 3860; - this.add_drop(); - this.state = 3861; - this.match(PostgreSqlParser.KW_AGGREGATE); - this.state = 3862; - this.aggregate_with_argtypes(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 3864; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3865; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3866; - this.name(); - this.state = 3867; - this.add_drop(); - this.state = 3868; - this.match(PostgreSqlParser.KW_CAST); - this.state = 3869; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3870; - this.typename(); - this.state = 3871; - this.match(PostgreSqlParser.KW_AS); - this.state = 3872; - this.typename(); - this.state = 3873; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 3875; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3876; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3877; - this.name(); - this.state = 3878; - this.add_drop(); - this.state = 3879; - this.match(PostgreSqlParser.KW_DOMAIN); - this.state = 3880; - this.typename(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 3882; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3883; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3884; - this.name(); - this.state = 3885; - this.add_drop(); - this.state = 3886; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 3887; - this.function_with_argtypes(); - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 3889; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3890; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3891; - this.name(); - this.state = 3892; - this.add_drop(); - this.state = 3893; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 3894; - this.operator_with_argtypes(); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 3896; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3897; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3898; - this.name(); - this.state = 3899; - this.add_drop(); - this.state = 3900; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 3901; - this.match(PostgreSqlParser.KW_CLASS); - this.state = 3902; - this.any_name(); - this.state = 3903; - this.match(PostgreSqlParser.KW_USING); - this.state = 3904; - this.name(); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 3906; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3907; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3908; - this.name(); - this.state = 3909; - this.add_drop(); - this.state = 3910; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 3911; - this.match(PostgreSqlParser.KW_FAMILY); - this.state = 3912; - this.any_name(); - this.state = 3913; - this.match(PostgreSqlParser.KW_USING); - this.state = 3914; - this.name(); - } - break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 3916; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3917; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3918; - this.name(); - this.state = 3919; - this.add_drop(); - this.state = 3920; - this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 3921; - this.procedure_with_argtypes(); - } - break; - case 11: - this.enterOuterAlt(localContext, 11); - { - this.state = 3923; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3924; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3925; - this.name(); - this.state = 3926; - this.add_drop(); - this.state = 3927; - this.match(PostgreSqlParser.KW_ROUTINE); - this.state = 3928; - this.routine_with_argtypes(); - } - break; - case 12: - this.enterOuterAlt(localContext, 12); - { - this.state = 3930; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3931; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3932; - this.name(); - this.state = 3933; - this.add_drop(); - this.state = 3934; - this.match(PostgreSqlParser.KW_TRANSFORM); - this.state = 3935; - this.match(PostgreSqlParser.KW_FOR); - this.state = 3936; - this.typename(); - this.state = 3937; - this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 3938; - this.name(); - } - break; - case 13: - this.enterOuterAlt(localContext, 13); - { - this.state = 3940; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3941; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 3942; - this.name(); - this.state = 3943; - this.add_drop(); - this.state = 3944; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 3945; - this.typename(); - } - break; + this.enterOuterAlt(localContext, 1); + { + this.state = 2951; + this.collabel(); + this.state = 2952; + this.sconst(); } } catch (re) { @@ -17089,38 +15031,65 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public createfdwstmt(): CreatefdwstmtContext { - let localContext = new CreatefdwstmtContext(this.context, this.state); - this.enterRule(localContext, 358, PostgreSqlParser.RULE_createfdwstmt); + public createforeignserverstmt(): CreateforeignserverstmtContext { + let localContext = new CreateforeignserverstmtContext(this.context, this.state); + this.enterRule(localContext, 228, PostgreSqlParser.RULE_createforeignserverstmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 3949; + this.state = 2954; this.match(PostgreSqlParser.KW_CREATE); - this.state = 3950; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 3951; - this.match(PostgreSqlParser.KW_DATA); - this.state = 3952; - this.match(PostgreSqlParser.KW_WRAPPER); - this.state = 3953; - this.name(); - this.state = 3955; + this.state = 2955; + this.match(PostgreSqlParser.KW_SERVER); + this.state = 2957; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 298, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 312, this.context) ) { case 1: { - this.state = 3954; - this.opt_fdw_options(); + this.state = 2956; + this.opt_if_not_exists(); } break; } - this.state = 3958; + this.state = 2959; + this.colid(); + this.state = 2962; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 360) { + { + this.state = 2960; + this.match(PostgreSqlParser.KW_TYPE); + this.state = 2961; + this.sconst(); + } + } + + this.state = 2965; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 375) { + { + this.state = 2964; + this.foreign_server_version(); + } + } + + this.state = 2967; + this.match(PostgreSqlParser.KW_FOREIGN); + this.state = 2968; + this.match(PostgreSqlParser.KW_DATA); + this.state = 2969; + this.match(PostgreSqlParser.KW_WRAPPER); + this.state = 2970; + this.colid(); + this.state = 2972; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 299, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 315, this.context) ) { case 1: { - this.state = 3957; + this.state = 2971; this.create_generic_options(); } break; @@ -17141,49 +15110,35 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public fdw_option(): Fdw_optionContext { - let localContext = new Fdw_optionContext(this.context, this.state); - this.enterRule(localContext, 360, PostgreSqlParser.RULE_fdw_option); + public foreign_server_version(): Foreign_server_versionContext { + let localContext = new Foreign_server_versionContext(this.context, this.state); + this.enterRule(localContext, 230, PostgreSqlParser.RULE_foreign_server_version); try { - this.state = 3968; + this.enterOuterAlt(localContext, 1); + { + this.state = 2974; + this.match(PostgreSqlParser.KW_VERSION); + this.state = 2977; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 300, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 3960; - this.match(PostgreSqlParser.KW_HANDLER); - this.state = 3961; - this.handler_name(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 3962; - this.match(PostgreSqlParser.KW_NO); - this.state = 3963; - this.match(PostgreSqlParser.KW_HANDLER); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.EscapeStringConstant: { - this.state = 3964; - this.match(PostgreSqlParser.KW_VALIDATOR); - this.state = 3965; - this.handler_name(); + this.state = 2975; + this.sconst(); } break; - case 4: - this.enterOuterAlt(localContext, 4); + case PostgreSqlParser.KW_NULL: { - this.state = 3966; - this.match(PostgreSqlParser.KW_NO); - this.state = 3967; - this.match(PostgreSqlParser.KW_VALIDATOR); + this.state = 2976; + this.match(PostgreSqlParser.KW_NULL); } break; + default: + throw new antlr.NoViableAltException(this); + } } } catch (re) { @@ -17200,57 +15155,46 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public fdw_options(): Fdw_optionsContext { - let localContext = new Fdw_optionsContext(this.context, this.state); - this.enterRule(localContext, 362, PostgreSqlParser.RULE_fdw_options); + public alterforeignserverstmt(): AlterforeignserverstmtContext { + let localContext = new AlterforeignserverstmtContext(this.context, this.state); + this.enterRule(localContext, 232, PostgreSqlParser.RULE_alterforeignserverstmt); try { - let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 3971; + this.state = 2979; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 2980; + this.match(PostgreSqlParser.KW_SERVER); + this.state = 2981; + this.colid(); + this.state = 2987; this.errorHandler.sync(this); - alternative = 1; - do { - switch (alternative) { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_OPTIONS: + { + this.state = 2982; + this.alter_generic_options(); + } + break; + case PostgreSqlParser.KW_VERSION: + { + this.state = 2983; + this.foreign_server_version(); + this.state = 2985; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 317, this.context) ) { case 1: { - { - this.state = 3970; - this.fdw_option(); - } + this.state = 2984; + this.alter_generic_options(); } break; - default: - throw new antlr.NoViableAltException(this); } - this.state = 3973; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 301, this.context); - } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + } + break; + default: + throw new antlr.NoViableAltException(this); } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_fdw_options(): Opt_fdw_optionsContext { - let localContext = new Opt_fdw_optionsContext(this.context, this.state); - this.enterRule(localContext, 364, PostgreSqlParser.RULE_opt_fdw_options); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3975; - this.fdw_options(); } } catch (re) { @@ -17267,255 +15211,130 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alterfdwstmt(): AlterfdwstmtContext { - let localContext = new AlterfdwstmtContext(this.context, this.state); - this.enterRule(localContext, 366, PostgreSqlParser.RULE_alterfdwstmt); + public createforeigntablestmt(): CreateforeigntablestmtContext { + let localContext = new CreateforeigntablestmtContext(this.context, this.state); + this.enterRule(localContext, 234, PostgreSqlParser.RULE_createforeigntablestmt); let _la: number; try { - this.state = 3994; + this.state = 3028; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 303, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 326, this.context) ) { case 1: + localContext = new CreateForeignTableContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 3977; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3978; + this.state = 2989; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 2990; this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 3979; - this.match(PostgreSqlParser.KW_DATA); - this.state = 3980; - this.match(PostgreSqlParser.KW_WRAPPER); - this.state = 3981; - this.name(); - this.state = 3983; + this.state = 2991; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 2993; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 319, this.context) ) { + case 1: + { + this.state = 2992; + this.opt_if_not_exists(); + } + break; + } + this.state = 2995; + this.table_name_create(); + this.state = 2996; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 2998; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 215 || _la === 269 || _la === 373) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 1360008709) !== 0) || ((((_la - 85)) & ~0x1F) === 0 && ((1 << (_la - 85)) & 2147491841) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & 4294966809) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & 4294967295) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & 4294967295) !== 0) || ((((_la - 216)) & ~0x1F) === 0 && ((1 << (_la - 216)) & 4290781183) !== 0) || ((((_la - 248)) & ~0x1F) === 0 && ((1 << (_la - 248)) & 4294967295) !== 0) || ((((_la - 280)) & ~0x1F) === 0 && ((1 << (_la - 280)) & 4294967295) !== 0) || ((((_la - 312)) & ~0x1F) === 0 && ((1 << (_la - 312)) & 4294967295) !== 0) || ((((_la - 344)) & ~0x1F) === 0 && ((1 << (_la - 344)) & 4294967295) !== 0) || ((((_la - 376)) & ~0x1F) === 0 && ((1 << (_la - 376)) & 4294967295) !== 0) || ((((_la - 408)) & ~0x1F) === 0 && ((1 << (_la - 408)) & 4294967295) !== 0) || ((((_la - 440)) & ~0x1F) === 0 && ((1 << (_la - 440)) & 4294950911) !== 0) || ((((_la - 473)) & ~0x1F) === 0 && ((1 << (_la - 473)) & 3221225471) !== 0) || ((((_la - 506)) & ~0x1F) === 0 && ((1 << (_la - 506)) & 24575) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { - this.state = 3982; - this.opt_fdw_options(); + this.state = 2997; + this.tableelementlist(); } } - this.state = 3985; - this.alter_generic_options(); + this.state = 3000; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 3002; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 238) { + { + this.state = 3001; + this.optinherit(); + } + } + + this.state = 3004; + this.match(PostgreSqlParser.KW_SERVER); + this.state = 3005; + this.colid(); + this.state = 3007; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 322, this.context) ) { + case 1: + { + this.state = 3006; + this.create_generic_options(); + } + break; + } } break; case 2: + localContext = new CreatePartitionForeignTableContext(localContext); this.enterOuterAlt(localContext, 2); { - this.state = 3987; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 3988; + this.state = 3009; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 3010; this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 3989; - this.match(PostgreSqlParser.KW_DATA); - this.state = 3990; - this.match(PostgreSqlParser.KW_WRAPPER); - this.state = 3991; - this.name(); - this.state = 3992; - this.fdw_options(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public create_generic_options(): Create_generic_optionsContext { - let localContext = new Create_generic_optionsContext(this.context, this.state); - this.enterRule(localContext, 368, PostgreSqlParser.RULE_create_generic_options); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 3996; - this.match(PostgreSqlParser.KW_OPTIONS); - this.state = 3997; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 3998; - this.generic_option_list(); - this.state = 3999; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public generic_option_list(): Generic_option_listContext { - let localContext = new Generic_option_listContext(this.context, this.state); - this.enterRule(localContext, 370, PostgreSqlParser.RULE_generic_option_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4001; - this.generic_option_elem(); - this.state = 4006; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 4002; - this.match(PostgreSqlParser.COMMA); - this.state = 4003; - this.generic_option_elem(); - } - } - this.state = 4008; + this.state = 3011; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 3013; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alter_generic_options(): Alter_generic_optionsContext { - let localContext = new Alter_generic_optionsContext(this.context, this.state); - this.enterRule(localContext, 372, PostgreSqlParser.RULE_alter_generic_options); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4009; - this.match(PostgreSqlParser.KW_OPTIONS); - this.state = 4010; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4011; - this.alter_generic_option_list(); - this.state = 4012; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alter_generic_option_list(): Alter_generic_option_listContext { - let localContext = new Alter_generic_option_listContext(this.context, this.state); - this.enterRule(localContext, 374, PostgreSqlParser.RULE_alter_generic_option_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4014; - this.alter_generic_option_elem(); - this.state = 4019; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 4015; - this.match(PostgreSqlParser.COMMA); - this.state = 4016; - this.alter_generic_option_elem(); - } + switch (this.interpreter.adaptivePredict(this.tokenStream, 323, this.context) ) { + case 1: + { + this.state = 3012; + this.opt_if_not_exists(); + } + break; } - this.state = 4021; + this.state = 3015; + this.table_name_create(); + this.state = 3016; + this.match(PostgreSqlParser.KW_PARTITION); + this.state = 3017; + this.match(PostgreSqlParser.KW_OF); + this.state = 3018; + this.table_name(); + this.state = 3020; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alter_generic_option_elem(): Alter_generic_option_elemContext { - let localContext = new Alter_generic_option_elemContext(this.context, this.state); - this.enterRule(localContext, 376, PostgreSqlParser.RULE_alter_generic_option_elem); - try { - this.state = 4029; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 306, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 4022; - this.generic_option_elem(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 4023; - this.match(PostgreSqlParser.KW_SET); - this.state = 4024; - this.generic_option_elem(); + if (_la === 2) { + { + this.state = 3019; + this.opttypedtableelementlist(); + } } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 4025; - this.match(PostgreSqlParser.KW_ADD); - this.state = 4026; - this.generic_option_elem(); + + this.state = 3022; + this.partitionboundspec(); + this.state = 3023; + this.match(PostgreSqlParser.KW_SERVER); + this.state = 3024; + this.colid(); + this.state = 3026; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 325, this.context) ) { + case 1: + { + this.state = 3025; + this.create_generic_options(); + } + break; } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 4027; - this.match(PostgreSqlParser.KW_DROP); - this.state = 4028; - this.generic_option_elem(); } break; } @@ -17534,137 +15353,71 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public generic_option_elem(): Generic_option_elemContext { - let localContext = new Generic_option_elemContext(this.context, this.state); - this.enterRule(localContext, 378, PostgreSqlParser.RULE_generic_option_elem); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4031; - this.generic_option_name(); - this.state = 4032; - this.generic_option_arg(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public generic_option_name(): Generic_option_nameContext { - let localContext = new Generic_option_nameContext(this.context, this.state); - this.enterRule(localContext, 380, PostgreSqlParser.RULE_generic_option_name); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4034; - this.collabel(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public generic_option_arg(): Generic_option_argContext { - let localContext = new Generic_option_argContext(this.context, this.state); - this.enterRule(localContext, 382, PostgreSqlParser.RULE_generic_option_arg); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4036; - this.sconst(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createforeignserverstmt(): CreateforeignserverstmtContext { - let localContext = new CreateforeignserverstmtContext(this.context, this.state); - this.enterRule(localContext, 384, PostgreSqlParser.RULE_createforeignserverstmt); + public importforeignschemastmt(): ImportforeignschemastmtContext { + let localContext = new ImportforeignschemastmtContext(this.context, this.state); + this.enterRule(localContext, 236, PostgreSqlParser.RULE_importforeignschemastmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4038; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4039; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 4041; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 307, this.context) ) { - case 1: - { - this.state = 4040; - this.opt_if_not_exists(); - } - break; - } - this.state = 4043; - this.name(); - this.state = 4045; + this.state = 3030; + this.match(PostgreSqlParser.KW_IMPORT); + this.state = 3031; + this.match(PostgreSqlParser.KW_FOREIGN); + this.state = 3032; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 3033; + this.schema_name(); + this.state = 3043; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 360) { + if (_la === 59 || _la === 74) { { - this.state = 4044; - this.opt_type(); + this.state = 3037; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_LIMIT: + { + this.state = 3034; + this.match(PostgreSqlParser.KW_LIMIT); + this.state = 3035; + this.match(PostgreSqlParser.KW_TO); + } + break; + case PostgreSqlParser.KW_EXCEPT: + { + this.state = 3036; + this.match(PostgreSqlParser.KW_EXCEPT); + } + break; + default: + throw new antlr.NoViableAltException(this); } - } - - this.state = 4048; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 375) { - { - this.state = 4047; - this.opt_foreign_server_version(); + this.state = 3039; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 3040; + this.relation_expr_list(); + this.state = 3041; + this.match(PostgreSqlParser.CLOSE_PAREN); } } - this.state = 4050; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 4051; - this.match(PostgreSqlParser.KW_DATA); - this.state = 4052; - this.match(PostgreSqlParser.KW_WRAPPER); - this.state = 4053; - this.name(); - this.state = 4055; + this.state = 3045; + this.match(PostgreSqlParser.KW_FROM); + this.state = 3046; + this.match(PostgreSqlParser.KW_SERVER); + this.state = 3047; + this.colid(); + this.state = 3048; + this.match(PostgreSqlParser.KW_INTO); + this.state = 3049; + this.colid(); + this.state = 3051; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 310, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 329, this.context) ) { case 1: { - this.state = 4054; + this.state = 3050; this.create_generic_options(); } break; @@ -17685,493 +15438,32 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_type(): Opt_typeContext { - let localContext = new Opt_typeContext(this.context, this.state); - this.enterRule(localContext, 386, PostgreSqlParser.RULE_opt_type); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4057; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 4058; - this.sconst(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public foreign_server_version(): Foreign_server_versionContext { - let localContext = new Foreign_server_versionContext(this.context, this.state); - this.enterRule(localContext, 388, PostgreSqlParser.RULE_foreign_server_version); + public createusermappingstmt(): CreateusermappingstmtContext { + let localContext = new CreateusermappingstmtContext(this.context, this.state); + this.enterRule(localContext, 238, PostgreSqlParser.RULE_createusermappingstmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4060; - this.match(PostgreSqlParser.KW_VERSION); - this.state = 4063; + this.state = 3053; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 3054; + this.match(PostgreSqlParser.KW_USER); + this.state = 3055; + this.match(PostgreSqlParser.KW_MAPPING); + this.state = 3057; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.EscapeStringConstant: - { - this.state = 4061; - this.sconst(); - } - break; - case PostgreSqlParser.KW_NULL: + _la = this.tokenStream.LA(1); + if (_la === 220) { { - this.state = 4062; - this.match(PostgreSqlParser.KW_NULL); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_foreign_server_version(): Opt_foreign_server_versionContext { - let localContext = new Opt_foreign_server_versionContext(this.context, this.state); - this.enterRule(localContext, 390, PostgreSqlParser.RULE_opt_foreign_server_version); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4065; - this.foreign_server_version(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alterforeignserverstmt(): AlterforeignserverstmtContext { - let localContext = new AlterforeignserverstmtContext(this.context, this.state); - this.enterRule(localContext, 392, PostgreSqlParser.RULE_alterforeignserverstmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4067; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 4068; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 4069; - this.name(); - this.state = 4075; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_OPTIONS: - { - this.state = 4070; - this.alter_generic_options(); - } - break; - case PostgreSqlParser.KW_VERSION: - { - this.state = 4071; - this.foreign_server_version(); - this.state = 4073; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 312, this.context) ) { - case 1: - { - this.state = 4072; - this.alter_generic_options(); - } - break; - } - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createforeigntablestmt(): CreateforeigntablestmtContext { - let localContext = new CreateforeigntablestmtContext(this.context, this.state); - this.enterRule(localContext, 394, PostgreSqlParser.RULE_createforeigntablestmt); - let _la: number; - try { - this.state = 4116; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 321, this.context) ) { - case 1: - localContext = new CreateForeignTableContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 4077; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4078; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 4079; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 4081; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 314, this.context) ) { - case 1: - { - this.state = 4080; - this.opt_if_not_exists(); - } - break; - } - this.state = 4083; - this.table_name_create(); - this.state = 4084; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4086; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 1360008709) !== 0) || ((((_la - 85)) & ~0x1F) === 0 && ((1 << (_la - 85)) & 2147491841) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & 4294966809) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & 4294967295) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & 4294967295) !== 0) || ((((_la - 216)) & ~0x1F) === 0 && ((1 << (_la - 216)) & 4290781183) !== 0) || ((((_la - 248)) & ~0x1F) === 0 && ((1 << (_la - 248)) & 4294967295) !== 0) || ((((_la - 280)) & ~0x1F) === 0 && ((1 << (_la - 280)) & 4294967295) !== 0) || ((((_la - 312)) & ~0x1F) === 0 && ((1 << (_la - 312)) & 4294967295) !== 0) || ((((_la - 344)) & ~0x1F) === 0 && ((1 << (_la - 344)) & 4294967295) !== 0) || ((((_la - 376)) & ~0x1F) === 0 && ((1 << (_la - 376)) & 4294967295) !== 0) || ((((_la - 408)) & ~0x1F) === 0 && ((1 << (_la - 408)) & 4294967295) !== 0) || ((((_la - 440)) & ~0x1F) === 0 && ((1 << (_la - 440)) & 4294950911) !== 0) || ((((_la - 473)) & ~0x1F) === 0 && ((1 << (_la - 473)) & 3221225471) !== 0) || ((((_la - 506)) & ~0x1F) === 0 && ((1 << (_la - 506)) & 24575) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { - { - this.state = 4085; - this.opttableelementlist(); - } - } - - this.state = 4088; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 4090; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 238) { - { - this.state = 4089; - this.optinherit(); - } - } - - this.state = 4092; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 4093; - this.name(); - this.state = 4095; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 317, this.context) ) { - case 1: - { - this.state = 4094; - this.create_generic_options(); - } - break; - } - } - break; - case 2: - localContext = new CreatePartitionForeignTableContext(localContext); - this.enterOuterAlt(localContext, 2); - { - this.state = 4097; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4098; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 4099; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 4101; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 318, this.context) ) { - case 1: - { - this.state = 4100; - this.opt_if_not_exists(); - } - break; - } - this.state = 4103; - this.table_name_create(); - this.state = 4104; - this.match(PostgreSqlParser.KW_PARTITION); - this.state = 4105; - this.match(PostgreSqlParser.KW_OF); - this.state = 4106; - this.table_name(); - this.state = 4108; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2) { - { - this.state = 4107; - this.opttypedtableelementlist(); - } - } - - this.state = 4110; - this.partitionboundspec(); - this.state = 4111; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 4112; - this.name(); - this.state = 4114; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 320, this.context) ) { - case 1: - { - this.state = 4113; - this.create_generic_options(); - } - break; - } - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public importforeignschemastmt(): ImportforeignschemastmtContext { - let localContext = new ImportforeignschemastmtContext(this.context, this.state); - this.enterRule(localContext, 396, PostgreSqlParser.RULE_importforeignschemastmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4118; - this.match(PostgreSqlParser.KW_IMPORT); - this.state = 4119; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 4120; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 4121; - this.schema_name(); - this.state = 4123; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 59 || _la === 74) { - { - this.state = 4122; - this.import_qualification(); - } - } - - this.state = 4125; - this.match(PostgreSqlParser.KW_FROM); - this.state = 4126; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 4127; - this.name(); - this.state = 4128; - this.match(PostgreSqlParser.KW_INTO); - this.state = 4129; - this.name(); - this.state = 4131; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 323, this.context) ) { - case 1: - { - this.state = 4130; - this.create_generic_options(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public import_qualification_type(): Import_qualification_typeContext { - let localContext = new Import_qualification_typeContext(this.context, this.state); - this.enterRule(localContext, 398, PostgreSqlParser.RULE_import_qualification_type); - try { - this.state = 4136; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_LIMIT: - this.enterOuterAlt(localContext, 1); - { - this.state = 4133; - this.match(PostgreSqlParser.KW_LIMIT); - this.state = 4134; - this.match(PostgreSqlParser.KW_TO); - } - break; - case PostgreSqlParser.KW_EXCEPT: - this.enterOuterAlt(localContext, 2); - { - this.state = 4135; - this.match(PostgreSqlParser.KW_EXCEPT); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public import_qualification(): Import_qualificationContext { - let localContext = new Import_qualificationContext(this.context, this.state); - this.enterRule(localContext, 400, PostgreSqlParser.RULE_import_qualification); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4138; - this.import_qualification_type(); - this.state = 4139; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4140; - this.relation_expr_list(); - this.state = 4141; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createusermappingstmt(): CreateusermappingstmtContext { - let localContext = new CreateusermappingstmtContext(this.context, this.state); - this.enterRule(localContext, 402, PostgreSqlParser.RULE_createusermappingstmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4143; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4144; - this.match(PostgreSqlParser.KW_USER); - this.state = 4145; - this.match(PostgreSqlParser.KW_MAPPING); - this.state = 4147; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 220) { - { - this.state = 4146; - this.opt_if_not_exists(); + this.state = 3056; + this.opt_if_not_exists(); } } - this.state = 4149; + this.state = 3059; this.match(PostgreSqlParser.KW_FOR); - this.state = 4150; - this.auth_ident(); - this.state = 4151; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 4152; - this.name(); - this.state = 4154; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 326, this.context) ) { - case 1: - { - this.state = 4153; - this.create_generic_options(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public auth_ident(): Auth_identContext { - let localContext = new Auth_identContext(this.context, this.state); - this.enterRule(localContext, 404, PostgreSqlParser.RULE_auth_ident); - try { - this.state = 4158; + this.state = 3062; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_AND: @@ -18598,202 +15890,31 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLVARIABLENAME: case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); { - this.state = 4156; + this.state = 3060; this.rolespec(); } break; case PostgreSqlParser.KW_USER: - this.enterOuterAlt(localContext, 2); { - this.state = 4157; + this.state = 3061; this.match(PostgreSqlParser.KW_USER); } break; default: throw new antlr.NoViableAltException(this); } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alterusermappingstmt(): AlterusermappingstmtContext { - let localContext = new AlterusermappingstmtContext(this.context, this.state); - this.enterRule(localContext, 406, PostgreSqlParser.RULE_alterusermappingstmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4160; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 4161; - this.match(PostgreSqlParser.KW_USER); - this.state = 4162; - this.match(PostgreSqlParser.KW_MAPPING); - this.state = 4163; - this.match(PostgreSqlParser.KW_FOR); - this.state = 4164; - this.auth_ident(); - this.state = 4165; + this.state = 3064; this.match(PostgreSqlParser.KW_SERVER); - this.state = 4166; - this.name(); - this.state = 4167; - this.alter_generic_options(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createpolicystmt(): CreatepolicystmtContext { - let localContext = new CreatepolicystmtContext(this.context, this.state); - this.enterRule(localContext, 408, PostgreSqlParser.RULE_createpolicystmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4169; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4170; - this.match(PostgreSqlParser.KW_POLICY); - this.state = 4171; - this.name(); - this.state = 4172; - this.match(PostgreSqlParser.KW_ON); - this.state = 4173; - this.qualified_name(); - this.state = 4175; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 328, this.context) ) { - case 1: - { - this.state = 4174; - this.rowsecuritydefaultpermissive(); - } - break; - } - this.state = 4178; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 4177; - this.rowsecuritydefaultforcmd(); - } - } - - this.state = 4181; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 94) { - { - this.state = 4180; - this.rowsecuritydefaulttorole(); - } - } - - this.state = 4184; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 100) { - { - this.state = 4183; - this.rowsecurityoptionalexpr(); - } - } - - this.state = 4187; + this.state = 3065; + this.colid(); + this.state = 3067; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 332, this.context) ) { case 1: { - this.state = 4186; - this.rowsecurityoptionalwithcheck(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alterpolicystmt(): AlterpolicystmtContext { - let localContext = new AlterpolicystmtContext(this.context, this.state); - this.enterRule(localContext, 410, PostgreSqlParser.RULE_alterpolicystmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4189; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 4190; - this.match(PostgreSqlParser.KW_POLICY); - this.state = 4191; - this.name(); - this.state = 4192; - this.match(PostgreSqlParser.KW_ON); - this.state = 4193; - this.qualified_name(); - this.state = 4195; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 94) { - { - this.state = 4194; - this.rowsecurityoptionaltorole(); - } - } - - this.state = 4198; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 100) { - { - this.state = 4197; - this.rowsecurityoptionalexpr(); - } - } - - this.state = 4201; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 335, this.context) ) { - case 1: - { - this.state = 4200; - this.rowsecurityoptionalwithcheck(); + this.state = 3066; + this.create_generic_options(); } break; } @@ -18813,479 +15934,419 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alterprocedurestmt(): AlterprocedurestmtContext { - let localContext = new AlterprocedurestmtContext(this.context, this.state); - this.enterRule(localContext, 412, PostgreSqlParser.RULE_alterprocedurestmt); - let _la: number; + public alterusermappingstmt(): AlterusermappingstmtContext { + let localContext = new AlterusermappingstmtContext(this.context, this.state); + this.enterRule(localContext, 240, PostgreSqlParser.RULE_alterusermappingstmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 4203; + this.state = 3069; this.match(PostgreSqlParser.KW_ALTER); - this.state = 4204; - this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 4205; - this.procedure_name(); - this.state = 4207; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2) { - { - this.state = 4206; - this.func_args(); - } - } - - this.state = 4209; - this.procedure_cluase(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public procedure_cluase(): Procedure_cluaseContext { - let localContext = new Procedure_cluaseContext(this.context, this.state); - this.enterRule(localContext, 414, PostgreSqlParser.RULE_procedure_cluase); - let _la: number; - try { - let alternative: number; - this.state = 4237; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 340, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 4211; - this.procedure_action(); - this.state = 4215; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 337, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 4212; - this.procedure_action(); - } - } - } - this.state = 4217; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 337, this.context); - } - this.state = 4219; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 338, this.context) ) { - case 1: - { - this.state = 4218; - this.match(PostgreSqlParser.KW_RESTRICT); - } - break; - } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 4221; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 4222; - this.match(PostgreSqlParser.KW_TO); - this.state = 4223; - this.procedure_name_create(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 4224; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 4225; - this.match(PostgreSqlParser.KW_TO); - this.state = 4226; - this.rolespec(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 4227; - this.match(PostgreSqlParser.KW_SET); - this.state = 4228; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 4229; - this.schema_name_create(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 4231; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 269) { - { - this.state = 4230; - this.match(PostgreSqlParser.KW_NO); - } - } - - this.state = 4233; - this.match(PostgreSqlParser.KW_DEPENDS); - this.state = 4234; - this.match(PostgreSqlParser.KW_ON); - this.state = 4235; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 4236; - this.name(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public procedure_action(): Procedure_actionContext { - let localContext = new Procedure_actionContext(this.context, this.state); - this.enterRule(localContext, 416, PostgreSqlParser.RULE_procedure_action); - let _la: number; - try { - this.state = 4267; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 345, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 4249; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 343, this.context) ) { - case 1: - { - this.state = 4240; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 205) { - { - this.state = 4239; - this.match(PostgreSqlParser.KW_EXTERNAL); - } - } - - this.state = 4242; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 4243; - this.match(PostgreSqlParser.KW_INVOKER); - } - break; - case 2: - { - this.state = 4245; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 205) { - { - this.state = 4244; - this.match(PostgreSqlParser.KW_EXTERNAL); - } - } - - this.state = 4247; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 4248; - this.match(PostgreSqlParser.KW_DEFINER); - } - break; - } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 4251; - this.match(PostgreSqlParser.KW_SET); - this.state = 4252; - this.name(); - this.state = 4253; - _la = this.tokenStream.LA(1); - if(!(_la === 9 || _la === 94)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 4256; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 344, this.context) ) { - case 1: - { - this.state = 4254; - this.name(); - } - break; - case 2: - { - this.state = 4255; - this.match(PostgreSqlParser.KW_DEFAULT); - } - break; - } - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 4258; - this.match(PostgreSqlParser.KW_SET); - this.state = 4259; - this.name(); - this.state = 4260; - this.match(PostgreSqlParser.KW_FROM); - this.state = 4261; - this.match(PostgreSqlParser.KW_CURRENT); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 4263; - this.match(PostgreSqlParser.KW_RESET); - this.state = 4264; - this.name(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 4265; - this.match(PostgreSqlParser.KW_RESET); - this.state = 4266; - this.match(PostgreSqlParser.KW_ALL); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public rowsecurityoptionalexpr(): RowsecurityoptionalexprContext { - let localContext = new RowsecurityoptionalexprContext(this.context, this.state); - this.enterRule(localContext, 418, PostgreSqlParser.RULE_rowsecurityoptionalexpr); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4269; - this.match(PostgreSqlParser.KW_USING); - this.state = 4270; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4271; - this.a_expr(); - this.state = 4272; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public rowsecurityoptionalwithcheck(): RowsecurityoptionalwithcheckContext { - let localContext = new RowsecurityoptionalwithcheckContext(this.context, this.state); - this.enterRule(localContext, 420, PostgreSqlParser.RULE_rowsecurityoptionalwithcheck); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4274; - this.match(PostgreSqlParser.KW_WITH); - this.state = 4275; - this.match(PostgreSqlParser.KW_CHECK); - this.state = 4276; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4277; - this.a_expr(); - this.state = 4278; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public rowsecuritydefaulttorole(): RowsecuritydefaulttoroleContext { - let localContext = new RowsecuritydefaulttoroleContext(this.context, this.state); - this.enterRule(localContext, 422, PostgreSqlParser.RULE_rowsecuritydefaulttorole); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4280; - this.match(PostgreSqlParser.KW_TO); - this.state = 4281; - this.role_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public rowsecurityoptionaltorole(): RowsecurityoptionaltoroleContext { - let localContext = new RowsecurityoptionaltoroleContext(this.context, this.state); - this.enterRule(localContext, 424, PostgreSqlParser.RULE_rowsecurityoptionaltorole); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4283; - this.match(PostgreSqlParser.KW_TO); - this.state = 4284; - this.role_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public rowsecuritydefaultpermissive(): RowsecuritydefaultpermissiveContext { - let localContext = new RowsecuritydefaultpermissiveContext(this.context, this.state); - this.enterRule(localContext, 426, PostgreSqlParser.RULE_rowsecuritydefaultpermissive); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4286; - this.match(PostgreSqlParser.KW_AS); - this.state = 4290; + this.state = 3070; + this.match(PostgreSqlParser.KW_USER); + this.state = 3071; + this.match(PostgreSqlParser.KW_MAPPING); + this.state = 3072; + this.match(PostgreSqlParser.KW_FOR); + this.state = 3075; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_PERMISSIVE: - { - this.state = 4287; - this.match(PostgreSqlParser.KW_PERMISSIVE); - } - break; - case PostgreSqlParser.KW_RESTRICTIVE: - { - this.state = 4288; - this.match(PostgreSqlParser.KW_RESTRICTIVE); - } - break; case PostgreSqlParser.KW_AND: case PostgreSqlParser.KW_ARRAY: case PostgreSqlParser.KW_COLLATE: case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_CURRENT_ROLE: + case PostgreSqlParser.KW_CURRENT_USER: case PostgreSqlParser.KW_DEFAULT: case PostgreSqlParser.KW_DO: case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_SESSION_USER: + case PostgreSqlParser.KW_AUTHORIZATION: + case PostgreSqlParser.KW_BINARY: + case PostgreSqlParser.KW_COLLATION: + case PostgreSqlParser.KW_CONCURRENTLY: + case PostgreSqlParser.KW_CROSS: + case PostgreSqlParser.KW_CURRENT_SCHEMA: + case PostgreSqlParser.KW_FREEZE: + case PostgreSqlParser.KW_FULL: + case PostgreSqlParser.KW_ILIKE: + case PostgreSqlParser.KW_INNER: case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_ISNULL: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_LIKE: + case PostgreSqlParser.KW_NATURAL: + case PostgreSqlParser.KW_NOTNULL: case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_OVERLAPS: + case PostgreSqlParser.KW_RIGHT: + case PostgreSqlParser.KW_SIMILAR: + case PostgreSqlParser.KW_VERBOSE: + case PostgreSqlParser.KW_ABORT: case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: case PostgreSqlParser.KW_NEXT: case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: case PostgreSqlParser.KW_SCHEMA: case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_TABLESAMPLE: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: case PostgreSqlParser.KW_ELSIF: case PostgreSqlParser.KW_REVERSE: case PostgreSqlParser.KW_SLICE: @@ -19302,6 +16363,9 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_EXCEPTION: case PostgreSqlParser.KW_ASSERT: case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_PUBLIC: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: case PostgreSqlParser.Identifier: case PostgreSqlParser.QuotedIdentifier: case PostgreSqlParser.UnicodeQuotedIdentifier: @@ -19312,13 +16376,25 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 4289; - this.identifier(); + this.state = 3073; + this.rolespec(); + } + break; + case PostgreSqlParser.KW_USER: + { + this.state = 3074; + this.match(PostgreSqlParser.KW_USER); } break; default: throw new antlr.NoViableAltException(this); } + this.state = 3077; + this.match(PostgreSqlParser.KW_SERVER); + this.state = 3078; + this.colid(); + this.state = 3079; + this.alter_generic_options(); } } catch (re) { @@ -19335,47 +16411,178 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public rowsecuritydefaultforcmd(): RowsecuritydefaultforcmdContext { - let localContext = new RowsecuritydefaultforcmdContext(this.context, this.state); - this.enterRule(localContext, 428, PostgreSqlParser.RULE_rowsecuritydefaultforcmd); + public createpolicystmt(): CreatepolicystmtContext { + let localContext = new CreatepolicystmtContext(this.context, this.state); + this.enterRule(localContext, 242, PostgreSqlParser.RULE_createpolicystmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4292; - this.match(PostgreSqlParser.KW_FOR); - this.state = 4293; - this.row_security_cmd(); + this.state = 3081; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 3082; + this.match(PostgreSqlParser.KW_POLICY); + this.state = 3083; + this.colid(); + this.state = 3084; + this.match(PostgreSqlParser.KW_ON); + this.state = 3085; + this.qualified_name(); + this.state = 3092; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 335, this.context) ) { + case 1: + { + this.state = 3086; + this.match(PostgreSqlParser.KW_AS); + this.state = 3090; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_PERMISSIVE: + { + this.state = 3087; + this.match(PostgreSqlParser.KW_PERMISSIVE); + } + break; + case PostgreSqlParser.KW_RESTRICTIVE: + { + this.state = 3088; + this.match(PostgreSqlParser.KW_RESTRICTIVE); + } + break; + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 3089; + this.identifier(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + this.state = 3096; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 62) { + { + this.state = 3094; + this.match(PostgreSqlParser.KW_FOR); + this.state = 3095; + _la = this.tokenStream.LA(1); + if(!(_la === 30 || _la === 88 || _la === 182 || _la === 241 || _la === 369)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } } - } - finally { - this.exitRule(); - } - return localContext; - } - public row_security_cmd(): Row_security_cmdContext { - let localContext = new Row_security_cmdContext(this.context, this.state); - this.enterRule(localContext, 430, PostgreSqlParser.RULE_row_security_cmd); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4295; + + this.state = 3100; + this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if(!(_la === 30 || _la === 88 || _la === 182 || _la === 241 || _la === 369)) { - this.errorHandler.recoverInline(this); + if (_la === 94) { + { + this.state = 3098; + this.match(PostgreSqlParser.KW_TO); + this.state = 3099; + this.role_list(); + } } - else { - this.errorHandler.reportMatch(this); - this.consume(); + + this.state = 3103; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 100) { + { + this.state = 3102; + this.rowsecurityoptionalexpr(); + } + } + + this.state = 3106; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 339, this.context) ) { + case 1: + { + this.state = 3105; + this.rowsecurityoptionalwithcheck(); + } + break; } } } @@ -19393,28 +16600,55 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public createamstmt(): CreateamstmtContext { - let localContext = new CreateamstmtContext(this.context, this.state); - this.enterRule(localContext, 432, PostgreSqlParser.RULE_createamstmt); + public alterpolicystmt(): AlterpolicystmtContext { + let localContext = new AlterpolicystmtContext(this.context, this.state); + this.enterRule(localContext, 244, PostgreSqlParser.RULE_alterpolicystmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4297; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4298; - this.match(PostgreSqlParser.KW_ACCESS); - this.state = 4299; - this.match(PostgreSqlParser.KW_METHOD); - this.state = 4300; - this.name(); - this.state = 4301; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 4302; - this.am_type(); - this.state = 4303; - this.match(PostgreSqlParser.KW_HANDLER); - this.state = 4304; - this.handler_name(); + this.state = 3108; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 3109; + this.match(PostgreSqlParser.KW_POLICY); + this.state = 3110; + this.colid(); + this.state = 3111; + this.match(PostgreSqlParser.KW_ON); + this.state = 3112; + this.qualified_name(); + this.state = 3115; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 94) { + { + this.state = 3113; + this.match(PostgreSqlParser.KW_TO); + this.state = 3114; + this.role_list(); + } + } + + this.state = 3118; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 100) { + { + this.state = 3117; + this.rowsecurityoptionalexpr(); + } + } + + this.state = 3121; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 342, this.context) ) { + case 1: + { + this.state = 3120; + this.rowsecurityoptionalwithcheck(); + } + break; + } } } catch (re) { @@ -19431,21 +16665,117 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public am_type(): Am_typeContext { - let localContext = new Am_typeContext(this.context, this.state); - this.enterRule(localContext, 434, PostgreSqlParser.RULE_am_type); + public alterprocedurestmt(): AlterprocedurestmtContext { + let localContext = new AlterprocedurestmtContext(this.context, this.state); + this.enterRule(localContext, 246, PostgreSqlParser.RULE_alterprocedurestmt); let _la: number; try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 4306; + this.state = 3123; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 3124; + this.match(PostgreSqlParser.KW_PROCEDURE); + this.state = 3125; + this.procedure_name(); + this.state = 3127; + this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if(!(_la === 92 || _la === 226)) { - this.errorHandler.recoverInline(this); + if (_la === 2) { + { + this.state = 3126; + this.func_args(); + } } - else { - this.errorHandler.reportMatch(this); - this.consume(); + + this.state = 3155; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 347, this.context) ) { + case 1: + { + this.state = 3129; + this.procedure_action(); + this.state = 3133; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 344, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 3130; + this.procedure_action(); + } + } + } + this.state = 3135; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 344, this.context); + } + this.state = 3137; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 345, this.context) ) { + case 1: + { + this.state = 3136; + this.match(PostgreSqlParser.KW_RESTRICT); + } + break; + } + } + break; + case 2: + { + this.state = 3139; + this.match(PostgreSqlParser.KW_RENAME); + this.state = 3140; + this.match(PostgreSqlParser.KW_TO); + this.state = 3141; + this.procedure_name_create(); + } + break; + case 3: + { + this.state = 3142; + this.match(PostgreSqlParser.KW_OWNER); + this.state = 3143; + this.match(PostgreSqlParser.KW_TO); + this.state = 3144; + this.rolespec(); + } + break; + case 4: + { + this.state = 3145; + this.match(PostgreSqlParser.KW_SET); + this.state = 3146; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 3147; + this.schema_name_create(); + } + break; + case 5: + { + this.state = 3149; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269) { + { + this.state = 3148; + this.match(PostgreSqlParser.KW_NO); + } + } + + this.state = 3151; + this.match(PostgreSqlParser.KW_DEPENDS); + this.state = 3152; + this.match(PostgreSqlParser.KW_ON); + this.state = 3153; + this.match(PostgreSqlParser.KW_EXTENSION); + this.state = 3154; + this.colid(); + } + break; } } } @@ -19463,162 +16793,527 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public createtrigstmt(): CreatetrigstmtContext { - let localContext = new CreatetrigstmtContext(this.context, this.state); - this.enterRule(localContext, 436, PostgreSqlParser.RULE_createtrigstmt); + public procedure_action(): Procedure_actionContext { + let localContext = new Procedure_actionContext(this.context, this.state); + this.enterRule(localContext, 248, PostgreSqlParser.RULE_procedure_action); let _la: number; try { - this.state = 4362; + this.state = 3186; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 356, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 353, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 4308; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4310; + this.state = 3167; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 82) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 350, this.context) ) { + case 1: { - this.state = 4309; - this.opt_or_replace(); + this.state = 3158; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 205) { + { + this.state = 3157; + this.match(PostgreSqlParser.KW_EXTERNAL); + } } - } - this.state = 4312; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 4313; - this.name(); - this.state = 4314; - this.triggeractiontime(); - this.state = 4315; - this.triggerevents(); - this.state = 4316; - this.match(PostgreSqlParser.KW_ON); - this.state = 4317; - this.table_name(); - this.state = 4319; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 447) { - { - this.state = 4318; - this.triggerreferencing(); + this.state = 3160; + this.match(PostgreSqlParser.KW_SECURITY); + this.state = 3161; + this.match(PostgreSqlParser.KW_INVOKER); } - } - - this.state = 4322; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { + break; + case 2: { - this.state = 4321; - this.triggerforspec(); + this.state = 3163; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 205) { + { + this.state = 3162; + this.match(PostgreSqlParser.KW_EXTERNAL); + } } - } - this.state = 4325; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 102) { - { - this.state = 4324; - this.triggerwhen(); + this.state = 3165; + this.match(PostgreSqlParser.KW_SECURITY); + this.state = 3166; + this.match(PostgreSqlParser.KW_DEFINER); } + break; } - - this.state = 4327; - this.match(PostgreSqlParser.KW_EXECUTE); - this.state = 4328; - this.function_or_procedure(); - this.state = 4329; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4330; - this.triggerfuncargs(); - this.state = 4331; - this.match(PostgreSqlParser.CLOSE_PAREN); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 4333; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4335; - this.errorHandler.sync(this); + this.state = 3169; + this.match(PostgreSqlParser.KW_SET); + this.state = 3170; + this.colid(); + this.state = 3171; _la = this.tokenStream.LA(1); - if (_la === 82) { - { - this.state = 4334; - this.opt_or_replace(); - } + if(!(_la === 9 || _la === 94)) { + this.errorHandler.recoverInline(this); } - - this.state = 4338; + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3174; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 45) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 351, this.context) ) { + case 1: { - this.state = 4337; - this.match(PostgreSqlParser.KW_CONSTRAINT); + this.state = 3172; + this.colid(); } - } - - this.state = 4340; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 4341; - this.name(); - this.state = 4342; - this.triggeractiontime(); - this.state = 4343; - this.triggerevents(); - this.state = 4344; - this.match(PostgreSqlParser.KW_ON); - this.state = 4345; - this.table_name(); - this.state = 4347; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 64) { + break; + case 2: { - this.state = 4346; - this.optconstrfromtable(); + this.state = 3173; + this.match(PostgreSqlParser.KW_DEFAULT); } + break; } - - this.state = 4349; - this.constraintattributespec(); - this.state = 4351; + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 3176; + this.match(PostgreSqlParser.KW_SET); + this.state = 3177; + this.colid(); + this.state = 3178; + this.match(PostgreSqlParser.KW_FROM); + this.state = 3179; + this.match(PostgreSqlParser.KW_CURRENT); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 3181; + this.match(PostgreSqlParser.KW_RESET); + this.state = 3184; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: { - this.state = 4350; - this.foreachrow(); + this.state = 3182; + this.colid(); } - } - - this.state = 4354; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 102) { + break; + case PostgreSqlParser.KW_ALL: { - this.state = 4353; - this.triggerwhen(); + this.state = 3183; + this.match(PostgreSqlParser.KW_ALL); } + break; + default: + throw new antlr.NoViableAltException(this); } - - this.state = 4356; - this.match(PostgreSqlParser.KW_EXECUTE); - this.state = 4357; - this.function_or_procedure(); - this.state = 4358; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4359; - this.triggerfuncargs(); - this.state = 4360; - this.match(PostgreSqlParser.CLOSE_PAREN); } break; } @@ -19637,38 +17332,20 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public triggeractiontime(): TriggeractiontimeContext { - let localContext = new TriggeractiontimeContext(this.context, this.state); - this.enterRule(localContext, 438, PostgreSqlParser.RULE_triggeractiontime); + public rowsecurityoptionalexpr(): RowsecurityoptionalexprContext { + let localContext = new RowsecurityoptionalexprContext(this.context, this.state); + this.enterRule(localContext, 250, PostgreSqlParser.RULE_rowsecurityoptionalexpr); try { - this.state = 4368; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_BEFORE: - this.enterOuterAlt(localContext, 1); - { - this.state = 4364; - this.match(PostgreSqlParser.KW_BEFORE); - } - break; - case PostgreSqlParser.KW_AFTER: - this.enterOuterAlt(localContext, 2); - { - this.state = 4365; - this.match(PostgreSqlParser.KW_AFTER); - } - break; - case PostgreSqlParser.KW_INSTEAD: - this.enterOuterAlt(localContext, 3); - { - this.state = 4366; - this.match(PostgreSqlParser.KW_INSTEAD); - this.state = 4367; - this.match(PostgreSqlParser.KW_OF); - } - break; - default: - throw new antlr.NoViableAltException(this); + this.enterOuterAlt(localContext, 1); + { + this.state = 3188; + this.match(PostgreSqlParser.KW_USING); + this.state = 3189; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 3190; + this.expression(); + this.state = 3191; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -19685,27 +17362,22 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public foreachrow(): ForeachrowContext { - let localContext = new ForeachrowContext(this.context, this.state); - this.enterRule(localContext, 440, PostgreSqlParser.RULE_foreachrow); - let _la: number; + public rowsecurityoptionalwithcheck(): RowsecurityoptionalwithcheckContext { + let localContext = new RowsecurityoptionalwithcheckContext(this.context, this.state); + this.enterRule(localContext, 252, PostgreSqlParser.RULE_rowsecurityoptionalwithcheck); try { this.enterOuterAlt(localContext, 1); { - this.state = 4370; - this.match(PostgreSqlParser.KW_FOR); - this.state = 4372; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 192) { - { - this.state = 4371; - this.match(PostgreSqlParser.KW_EACH); - } - } - - this.state = 4374; - this.roworstatment(); + this.state = 3193; + this.match(PostgreSqlParser.KW_WITH); + this.state = 3194; + this.match(PostgreSqlParser.KW_CHECK); + this.state = 3195; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 3196; + this.expression(); + this.state = 3197; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -19722,22 +17394,36 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public roworstatment(): RoworstatmentContext { - let localContext = new RoworstatmentContext(this.context, this.state); - this.enterRule(localContext, 442, PostgreSqlParser.RULE_roworstatment); + public createamstmt(): CreateamstmtContext { + let localContext = new CreateamstmtContext(this.context, this.state); + this.enterRule(localContext, 254, PostgreSqlParser.RULE_createamstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4376; + this.state = 3199; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 3200; + this.match(PostgreSqlParser.KW_ACCESS); + this.state = 3201; + this.match(PostgreSqlParser.KW_METHOD); + this.state = 3202; + this.colid(); + this.state = 3203; + this.match(PostgreSqlParser.KW_TYPE); + this.state = 3204; _la = this.tokenStream.LA(1); - if(!(_la === 341 || _la === 414)) { + if(!(_la === 92 || _la === 226)) { this.errorHandler.recoverInline(this); } else { this.errorHandler.reportMatch(this); this.consume(); } + this.state = 3205; + this.match(PostgreSqlParser.KW_HANDLER); + this.state = 3206; + this.any_name(); } } catch (re) { @@ -19754,31 +17440,258 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public triggerevents(): TriggereventsContext { - let localContext = new TriggereventsContext(this.context, this.state); - this.enterRule(localContext, 444, PostgreSqlParser.RULE_triggerevents); + public createtrigstmt(): CreatetrigstmtContext { + let localContext = new CreatetrigstmtContext(this.context, this.state); + this.enterRule(localContext, 256, PostgreSqlParser.RULE_createtrigstmt); let _la: number; try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4378; - this.triggeroneevent(); - this.state = 4383; + this.state = 3286; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 82) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 368, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); { + this.state = 3208; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 3210; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 82) { + { + this.state = 3209; + this.opt_or_replace(); + } + } + + this.state = 3212; + this.match(PostgreSqlParser.KW_TRIGGER); + this.state = 3213; + this.colid(); + this.state = 3214; + this.triggeractiontime(); + this.state = 3215; + this.triggerevents(); + this.state = 3216; + this.match(PostgreSqlParser.KW_ON); + this.state = 3217; + this.table_name(); + this.state = 3229; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 447) { + { + this.state = 3218; + this.match(PostgreSqlParser.KW_REFERENCING); + this.state = 3225; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 3219; + _la = this.tokenStream.LA(1); + if(!(_la === 448 || _la === 449)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3220; + _la = this.tokenStream.LA(1); + if(!(_la === 92 || _la === 414)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3222; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 36) { + { + this.state = 3221; + this.match(PostgreSqlParser.KW_AS); + } + } + + this.state = 3224; + this.colid(); + } + } + this.state = 3227; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 448 || _la === 449); + } + } + + this.state = 3236; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 62) { + { + this.state = 3231; + this.match(PostgreSqlParser.KW_FOR); + this.state = 3233; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 192) { + { + this.state = 3232; + this.match(PostgreSqlParser.KW_EACH); + } + } + + this.state = 3235; + _la = this.tokenStream.LA(1); + if(!(_la === 341 || _la === 414)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 3239; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 102) { + { + this.state = 3238; + this.triggerwhen(); + } + } + + this.state = 3241; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 3242; + this.function_or_procedure(); + this.state = 3243; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 3244; + this.triggerfuncargs(); + this.state = 3245; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 4379; - this.match(PostgreSqlParser.KW_OR); - this.state = 4380; - this.triggeroneevent(); + this.state = 3247; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 3249; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 82) { + { + this.state = 3248; + this.opt_or_replace(); + } + } + + this.state = 3252; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 45) { + { + this.state = 3251; + this.match(PostgreSqlParser.KW_CONSTRAINT); + } + } + + this.state = 3254; + this.match(PostgreSqlParser.KW_TRIGGER); + this.state = 3255; + this.colid(); + this.state = 3256; + this.triggeractiontime(); + this.state = 3257; + this.triggerevents(); + this.state = 3258; + this.match(PostgreSqlParser.KW_ON); + this.state = 3259; + this.table_name(); + this.state = 3262; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 64) { + { + this.state = 3260; + this.match(PostgreSqlParser.KW_FROM); + this.state = 3261; + this.qualified_name(); + } } + + this.state = 3267; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (((((_la - 54)) & ~0x1F) === 0 && ((1 << (_la - 54)) & 8421377) !== 0) || _la === 269) { + { + { + this.state = 3264; + this.constraintattributeElem(); + } + } + this.state = 3269; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - this.state = 4385; + this.state = 3275; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - } + if (_la === 62) { + { + this.state = 3270; + this.match(PostgreSqlParser.KW_FOR); + this.state = 3272; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 192) { + { + this.state = 3271; + this.match(PostgreSqlParser.KW_EACH); + } + } + + this.state = 3274; + _la = this.tokenStream.LA(1); + if(!(_la === 341 || _la === 414)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 3278; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 102) { + { + this.state = 3277; + this.triggerwhen(); + } + } + + this.state = 3280; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 3281; + this.function_or_procedure(); + this.state = 3282; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 3283; + this.triggerfuncargs(); + this.state = 3284; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; } } catch (re) { @@ -19795,52 +17708,38 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public triggeroneevent(): TriggeroneeventContext { - let localContext = new TriggeroneeventContext(this.context, this.state); - this.enterRule(localContext, 446, PostgreSqlParser.RULE_triggeroneevent); + public triggeractiontime(): TriggeractiontimeContext { + let localContext = new TriggeractiontimeContext(this.context, this.state); + this.enterRule(localContext, 258, PostgreSqlParser.RULE_triggeractiontime); try { - this.state = 4393; + this.state = 3292; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 360, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_BEFORE: this.enterOuterAlt(localContext, 1); { - this.state = 4386; - this.match(PostgreSqlParser.KW_INSERT); + this.state = 3288; + this.match(PostgreSqlParser.KW_BEFORE); } break; - case 2: + case PostgreSqlParser.KW_AFTER: this.enterOuterAlt(localContext, 2); { - this.state = 4387; - this.match(PostgreSqlParser.KW_DELETE); + this.state = 3289; + this.match(PostgreSqlParser.KW_AFTER); } break; - case 3: + case PostgreSqlParser.KW_INSTEAD: this.enterOuterAlt(localContext, 3); { - this.state = 4388; - this.match(PostgreSqlParser.KW_UPDATE); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 4389; - this.match(PostgreSqlParser.KW_UPDATE); - this.state = 4390; + this.state = 3290; + this.match(PostgreSqlParser.KW_INSTEAD); + this.state = 3291; this.match(PostgreSqlParser.KW_OF); - this.state = 4391; - this.column_list(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 4392; - this.match(PostgreSqlParser.KW_TRUNCATE); } break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -19857,53 +17756,31 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public triggerreferencing(): TriggerreferencingContext { - let localContext = new TriggerreferencingContext(this.context, this.state); - this.enterRule(localContext, 448, PostgreSqlParser.RULE_triggerreferencing); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4395; - this.match(PostgreSqlParser.KW_REFERENCING); - this.state = 4396; - this.triggertransitions(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public triggertransitions(): TriggertransitionsContext { - let localContext = new TriggertransitionsContext(this.context, this.state); - this.enterRule(localContext, 450, PostgreSqlParser.RULE_triggertransitions); + public triggerevents(): TriggereventsContext { + let localContext = new TriggereventsContext(this.context, this.state); + this.enterRule(localContext, 260, PostgreSqlParser.RULE_triggerevents); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4399; + this.state = 3294; + this.triggeroneevent(); + this.state = 3299; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - do { + while (_la === 82) { { { - this.state = 4398; - this.triggertransition(); + this.state = 3295; + this.match(PostgreSqlParser.KW_OR); + this.state = 3296; + this.triggeroneevent(); } } - this.state = 4401; + this.state = 3301; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - } while (_la === 448 || _la === 449); + } } } catch (re) { @@ -19920,210 +17797,56 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public triggertransition(): TriggertransitionContext { - let localContext = new TriggertransitionContext(this.context, this.state); - this.enterRule(localContext, 452, PostgreSqlParser.RULE_triggertransition); + public triggeroneevent(): TriggeroneeventContext { + let localContext = new TriggeroneeventContext(this.context, this.state); + this.enterRule(localContext, 262, PostgreSqlParser.RULE_triggeroneevent); let _la: number; try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4403; - this.transitionoldornew(); - this.state = 4404; - this.transitionrowortable(); - this.state = 4406; + this.state = 3310; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 36) { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_INSERT: + this.enterOuterAlt(localContext, 1); { - this.state = 4405; - this.opt_as(); + this.state = 3302; + this.match(PostgreSqlParser.KW_INSERT); } - } - - this.state = 4408; - this.transitionrelname(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public transitionoldornew(): TransitionoldornewContext { - let localContext = new TransitionoldornewContext(this.context, this.state); - this.enterRule(localContext, 454, PostgreSqlParser.RULE_transitionoldornew); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4410; - _la = this.tokenStream.LA(1); - if(!(_la === 448 || _la === 449)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public transitionrowortable(): TransitionrowortableContext { - let localContext = new TransitionrowortableContext(this.context, this.state); - this.enterRule(localContext, 456, PostgreSqlParser.RULE_transitionrowortable); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4412; - _la = this.tokenStream.LA(1); - if(!(_la === 92 || _la === 414)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public transitionrelname(): TransitionrelnameContext { - let localContext = new TransitionrelnameContext(this.context, this.state); - this.enterRule(localContext, 458, PostgreSqlParser.RULE_transitionrelname); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4414; - this.colid(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public triggerforspec(): TriggerforspecContext { - let localContext = new TriggerforspecContext(this.context, this.state); - this.enterRule(localContext, 460, PostgreSqlParser.RULE_triggerforspec); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4416; - this.match(PostgreSqlParser.KW_FOR); - this.state = 4418; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 192) { + break; + case PostgreSqlParser.KW_DELETE: + this.enterOuterAlt(localContext, 2); + { + this.state = 3303; + this.match(PostgreSqlParser.KW_DELETE); + } + break; + case PostgreSqlParser.KW_UPDATE: + this.enterOuterAlt(localContext, 3); { - this.state = 4417; - this.triggerforopteach(); + this.state = 3304; + this.match(PostgreSqlParser.KW_UPDATE); + this.state = 3307; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 275) { + { + this.state = 3305; + this.match(PostgreSqlParser.KW_OF); + this.state = 3306; + this.column_list(); + } } - } - this.state = 4420; - this.triggerfortype(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public triggerforopteach(): TriggerforopteachContext { - let localContext = new TriggerforopteachContext(this.context, this.state); - this.enterRule(localContext, 462, PostgreSqlParser.RULE_triggerforopteach); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4422; - this.match(PostgreSqlParser.KW_EACH); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public triggerfortype(): TriggerfortypeContext { - let localContext = new TriggerfortypeContext(this.context, this.state); - this.enterRule(localContext, 464, PostgreSqlParser.RULE_triggerfortype); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4424; - _la = this.tokenStream.LA(1); - if(!(_la === 341 || _la === 414)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } + } + break; + case PostgreSqlParser.KW_TRUNCATE: + this.enterOuterAlt(localContext, 4); + { + this.state = 3309; + this.match(PostgreSqlParser.KW_TRUNCATE); + } + break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -20142,17 +17865,17 @@ export class PostgreSqlParser extends SQLParserBase { } public triggerwhen(): TriggerwhenContext { let localContext = new TriggerwhenContext(this.context, this.state); - this.enterRule(localContext, 466, PostgreSqlParser.RULE_triggerwhen); + this.enterRule(localContext, 264, PostgreSqlParser.RULE_triggerwhen); try { this.enterOuterAlt(localContext, 1); { - this.state = 4426; + this.state = 3312; this.match(PostgreSqlParser.KW_WHEN); - this.state = 4427; + this.state = 3313; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4428; - this.a_expr(); - this.state = 4429; + this.state = 3314; + this.expression(); + this.state = 3315; this.match(PostgreSqlParser.CLOSE_PAREN); } } @@ -20172,26 +17895,26 @@ export class PostgreSqlParser extends SQLParserBase { } public function_or_procedure(): Function_or_procedureContext { let localContext = new Function_or_procedureContext(this.context, this.state); - this.enterRule(localContext, 468, PostgreSqlParser.RULE_function_or_procedure); + this.enterRule(localContext, 266, PostgreSqlParser.RULE_function_or_procedure); try { - this.state = 4435; + this.state = 3321; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_FUNCTION: this.enterOuterAlt(localContext, 1); { - this.state = 4431; + this.state = 3317; this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 4432; + this.state = 3318; this.function_name(); } break; case PostgreSqlParser.KW_PROCEDURE: this.enterOuterAlt(localContext, 2); { - this.state = 4433; + this.state = 3319; this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 4434; + this.state = 3320; this.procedure_name(); } break; @@ -20215,12 +17938,12 @@ export class PostgreSqlParser extends SQLParserBase { } public triggerfuncargs(): TriggerfuncargsContext { let localContext = new TriggerfuncargsContext(this.context, this.state); - this.enterRule(localContext, 470, PostgreSqlParser.RULE_triggerfuncargs); + this.enterRule(localContext, 268, PostgreSqlParser.RULE_triggerfuncargs); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4439; + this.state = 3325; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_ALL: @@ -20715,7 +18438,7 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 4437; + this.state = 3323; this.triggerfuncarg(); } break; @@ -20728,19 +18451,19 @@ export class PostgreSqlParser extends SQLParserBase { default: throw new antlr.NoViableAltException(this); } - this.state = 4445; + this.state = 3331; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 4441; + this.state = 3327; this.match(PostgreSqlParser.COMMA); - this.state = 4442; + this.state = 3328; this.triggerfuncarg(); } } - this.state = 4447; + this.state = 3333; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -20762,36 +18485,36 @@ export class PostgreSqlParser extends SQLParserBase { } public triggerfuncarg(): TriggerfuncargContext { let localContext = new TriggerfuncargContext(this.context, this.state); - this.enterRule(localContext, 472, PostgreSqlParser.RULE_triggerfuncarg); + this.enterRule(localContext, 270, PostgreSqlParser.RULE_triggerfuncarg); try { - this.state = 4452; + this.state = 3338; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 367, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 376, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 4448; - this.iconst(); + this.state = 3334; + this.match(PostgreSqlParser.Integral); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 4449; - this.fconst(); + this.state = 3335; + this.match(PostgreSqlParser.Numeric); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 4450; + this.state = 3336; this.sconst(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 4451; + this.state = 3337; this.collabel(); } break; @@ -20811,127 +18534,62 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public optconstrfromtable(): OptconstrfromtableContext { - let localContext = new OptconstrfromtableContext(this.context, this.state); - this.enterRule(localContext, 474, PostgreSqlParser.RULE_optconstrfromtable); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4454; - this.match(PostgreSqlParser.KW_FROM); - this.state = 4455; - this.qualified_name(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public constraintattributespec(): ConstraintattributespecContext { - let localContext = new ConstraintattributespecContext(this.context, this.state); - this.enterRule(localContext, 476, PostgreSqlParser.RULE_constraintattributespec); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 4460; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 368, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 4457; - this.constraintattributeElem(); - } - } - } - this.state = 4462; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 368, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public constraintattributeElem(): ConstraintattributeElemContext { let localContext = new ConstraintattributeElemContext(this.context, this.state); - this.enterRule(localContext, 478, PostgreSqlParser.RULE_constraintattributeElem); + this.enterRule(localContext, 272, PostgreSqlParser.RULE_constraintattributeElem); + let _la: number; try { - this.state = 4474; + this.state = 3350; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 369, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 378, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 4463; - this.match(PostgreSqlParser.KW_NOT); - this.state = 4464; + this.state = 3341; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { + { + this.state = 3340; + this.match(PostgreSqlParser.KW_NOT); + } + } + + this.state = 3343; this.match(PostgreSqlParser.KW_DEFERRABLE); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 4465; - this.match(PostgreSqlParser.KW_DEFERRABLE); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 4466; + this.state = 3344; this.match(PostgreSqlParser.KW_INITIALLY); - this.state = 4467; - this.match(PostgreSqlParser.KW_IMMEDIATE); + this.state = 3345; + _la = this.tokenStream.LA(1); + if(!(_la === 180 || _la === 221)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 4468; - this.match(PostgreSqlParser.KW_INITIALLY); - this.state = 4469; - this.match(PostgreSqlParser.KW_DEFERRED); } break; - case 5: - this.enterOuterAlt(localContext, 5); + case 3: + this.enterOuterAlt(localContext, 3); { - this.state = 4470; + this.state = 3346; this.match(PostgreSqlParser.KW_NOT); - this.state = 4471; + this.state = 3347; this.match(PostgreSqlParser.KW_VALID); } break; - case 6: - this.enterOuterAlt(localContext, 6); + case 4: + this.enterOuterAlt(localContext, 4); { - this.state = 4472; + this.state = 3348; this.match(PostgreSqlParser.KW_NO); - this.state = 4473; + this.state = 3349; this.match(PostgreSqlParser.KW_INHERIT); } break; @@ -20953,106 +18611,59 @@ export class PostgreSqlParser extends SQLParserBase { } public createeventtrigstmt(): CreateeventtrigstmtContext { let localContext = new CreateeventtrigstmtContext(this.context, this.state); - this.enterRule(localContext, 480, PostgreSqlParser.RULE_createeventtrigstmt); - try { - this.state = 4500; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 370, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 4476; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4477; - this.match(PostgreSqlParser.KW_EVENT); - this.state = 4478; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 4479; - this.name(); - this.state = 4480; - this.match(PostgreSqlParser.KW_ON); - this.state = 4481; - this.collabel(); - this.state = 4482; - this.match(PostgreSqlParser.KW_EXECUTE); - this.state = 4483; - this.function_or_procedure(); - this.state = 4484; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4485; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 4487; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4488; - this.match(PostgreSqlParser.KW_EVENT); - this.state = 4489; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 4490; - this.name(); - this.state = 4491; - this.match(PostgreSqlParser.KW_ON); - this.state = 4492; - this.collabel(); - this.state = 4493; - this.match(PostgreSqlParser.KW_WHEN); - this.state = 4494; - this.event_trigger_when_list(); - this.state = 4495; - this.match(PostgreSqlParser.KW_EXECUTE); - this.state = 4496; - this.function_or_procedure(); - this.state = 4497; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4498; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public event_trigger_when_list(): Event_trigger_when_listContext { - let localContext = new Event_trigger_when_listContext(this.context, this.state); - this.enterRule(localContext, 482, PostgreSqlParser.RULE_event_trigger_when_list); + this.enterRule(localContext, 274, PostgreSqlParser.RULE_createeventtrigstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4502; - this.event_trigger_when_item(); - this.state = 4507; + this.state = 3352; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 3353; + this.match(PostgreSqlParser.KW_EVENT); + this.state = 3354; + this.match(PostgreSqlParser.KW_TRIGGER); + this.state = 3355; + this.colid(); + this.state = 3356; + this.match(PostgreSqlParser.KW_ON); + this.state = 3357; + this.collabel(); + this.state = 3367; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - while (_la === 33) { - { + if (_la === 102) { { - this.state = 4503; - this.match(PostgreSqlParser.KW_AND); - this.state = 4504; + this.state = 3358; + this.match(PostgreSqlParser.KW_WHEN); + this.state = 3359; this.event_trigger_when_item(); - } - } - this.state = 4509; + this.state = 3364; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); + while (_la === 33) { + { + { + this.state = 3360; + this.match(PostgreSqlParser.KW_AND); + this.state = 3361; + this.event_trigger_when_item(); + } + } + this.state = 3366; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } } + + this.state = 3369; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 3370; + this.function_or_procedure(); + this.state = 3371; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 3372; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -21071,61 +18682,35 @@ export class PostgreSqlParser extends SQLParserBase { } public event_trigger_when_item(): Event_trigger_when_itemContext { let localContext = new Event_trigger_when_itemContext(this.context, this.state); - this.enterRule(localContext, 484, PostgreSqlParser.RULE_event_trigger_when_item); + this.enterRule(localContext, 276, PostgreSqlParser.RULE_event_trigger_when_item); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4510; + this.state = 3374; this.colid(); - this.state = 4511; + this.state = 3375; this.match(PostgreSqlParser.KW_IN); - this.state = 4512; + this.state = 3376; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4513; - this.event_trigger_value_list(); - this.state = 4514; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public event_trigger_value_list(): Event_trigger_value_listContext { - let localContext = new Event_trigger_value_listContext(this.context, this.state); - this.enterRule(localContext, 486, PostgreSqlParser.RULE_event_trigger_value_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4516; + this.state = 3377; this.sconst(); - this.state = 4521; + this.state = 3381; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 4517; - this.match(PostgreSqlParser.COMMA); - this.state = 4518; - this.sconst(); + this.state = 3378; + this.notify_payload(); } } - this.state = 4523; + this.state = 3383; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } + this.state = 3384; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -21144,55 +18729,32 @@ export class PostgreSqlParser extends SQLParserBase { } public altereventtrigstmt(): AltereventtrigstmtContext { let localContext = new AltereventtrigstmtContext(this.context, this.state); - this.enterRule(localContext, 488, PostgreSqlParser.RULE_altereventtrigstmt); + this.enterRule(localContext, 278, PostgreSqlParser.RULE_altereventtrigstmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4524; + this.state = 3386; this.match(PostgreSqlParser.KW_ALTER); - this.state = 4525; + this.state = 3387; this.match(PostgreSqlParser.KW_EVENT); - this.state = 4526; + this.state = 3388; this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 4527; - this.name(); - this.state = 4528; - this.enable_trigger(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public enable_trigger(): Enable_triggerContext { - let localContext = new Enable_triggerContext(this.context, this.state); - this.enterRule(localContext, 490, PostgreSqlParser.RULE_enable_trigger); - let _la: number; - try { - this.state = 4535; + this.state = 3389; + this.colid(); + this.state = 3395; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_ENABLE: - this.enterOuterAlt(localContext, 1); { - this.state = 4530; + this.state = 3390; this.match(PostgreSqlParser.KW_ENABLE); - this.state = 4532; + this.state = 3392; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 373, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 382, this.context) ) { case 1: { - this.state = 4531; + this.state = 3391; _la = this.tokenStream.LA(1); if(!(_la === 139 || _la === 312)) { this.errorHandler.recoverInline(this); @@ -21207,15 +18769,15 @@ export class PostgreSqlParser extends SQLParserBase { } break; case PostgreSqlParser.KW_DISABLE: - this.enterOuterAlt(localContext, 2); { - this.state = 4534; + this.state = 3394; this.match(PostgreSqlParser.KW_DISABLE); } break; default: throw new antlr.NoViableAltException(this); } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -21233,26 +18795,41 @@ export class PostgreSqlParser extends SQLParserBase { } public createassertionstmt(): CreateassertionstmtContext { let localContext = new CreateassertionstmtContext(this.context, this.state); - this.enterRule(localContext, 492, PostgreSqlParser.RULE_createassertionstmt); + this.enterRule(localContext, 280, PostgreSqlParser.RULE_createassertionstmt); try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 4537; + this.state = 3397; this.match(PostgreSqlParser.KW_CREATE); - this.state = 4538; + this.state = 3398; this.match(PostgreSqlParser.KW_ASSERTION); - this.state = 4539; + this.state = 3399; this.any_name(); - this.state = 4540; + this.state = 3400; this.match(PostgreSqlParser.KW_CHECK); - this.state = 4541; + this.state = 3401; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4542; - this.a_expr(); - this.state = 4543; + this.state = 3402; + this.expression(); + this.state = 3403; this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 4544; - this.constraintattributespec(); + this.state = 3407; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 384, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 3404; + this.constraintattributeElem(); + } + } + } + this.state = 3409; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 384, this.context); + } } } catch (re) { @@ -21271,284 +18848,255 @@ export class PostgreSqlParser extends SQLParserBase { } public definestmt(): DefinestmtContext { let localContext = new DefinestmtContext(this.context, this.state); - this.enterRule(localContext, 494, PostgreSqlParser.RULE_definestmt); + this.enterRule(localContext, 282, PostgreSqlParser.RULE_definestmt); let _la: number; try { - this.state = 4649; + this.state = 3488; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 381, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 396, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 4546; + this.state = 3410; this.match(PostgreSqlParser.KW_CREATE); - this.state = 4548; + this.state = 3412; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 82) { { - this.state = 4547; + this.state = 3411; this.opt_or_replace(); } } - this.state = 4550; + this.state = 3414; this.match(PostgreSqlParser.KW_AGGREGATE); - this.state = 4551; + this.state = 3415; this.function_name(); - this.state = 4552; - this.aggr_args(); - this.state = 4553; - this.definition(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 4555; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4557; + this.state = 3430; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 82) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 387, this.context) ) { + case 1: { - this.state = 4556; - this.opt_or_replace(); + { + this.state = 3416; + this.aggr_args(); + this.state = 3417; + this.definition(); + } + } + break; + case 2: + { + this.state = 3419; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 3420; + this.old_aggr_elem(); + this.state = 3425; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 3421; + this.match(PostgreSqlParser.COMMA); + this.state = 3422; + this.old_aggr_elem(); + } + } + this.state = 3427; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 3428; + this.match(PostgreSqlParser.CLOSE_PAREN); } + break; } - - this.state = 4559; - this.match(PostgreSqlParser.KW_AGGREGATE); - this.state = 4560; - this.function_name(); - this.state = 4561; - this.old_aggr_definition(); } break; - case 3: - this.enterOuterAlt(localContext, 3); + case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 4563; + this.state = 3432; this.match(PostgreSqlParser.KW_CREATE); - this.state = 4564; + this.state = 3433; this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 4565; + this.state = 3434; this.any_operator(); - this.state = 4566; - this.definition(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 4568; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4569; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 4570; - this.any_name(); - this.state = 4571; + this.state = 3435; this.definition(); } break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 4573; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4574; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 4575; - this.any_name(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); + case 3: + this.enterOuterAlt(localContext, 3); { - this.state = 4576; + this.state = 3437; this.match(PostgreSqlParser.KW_CREATE); - this.state = 4577; + this.state = 3438; this.match(PostgreSqlParser.KW_TYPE); - this.state = 4578; + this.state = 3439; this.any_name(); - this.state = 4579; + this.state = 3440; this.match(PostgreSqlParser.KW_AS); - this.state = 4580; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4582; + this.state = 3458; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.OPEN_PAREN: { - this.state = 4581; - this.opttablefuncelementlist(); + this.state = 3441; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 3443; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { + { + this.state = 3442; + this.tablefuncelementlist(); + } } - } - this.state = 4584; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 3445; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_ENUM: + { + this.state = 3446; + this.match(PostgreSqlParser.KW_ENUM); + this.state = 3447; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 3455; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 558)) & ~0x1F) === 0 && ((1 << (_la - 558)) & 67108885) !== 0)) { + { + this.state = 3448; + this.sconst(); + this.state = 3452; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 3449; + this.notify_payload(); + } + } + this.state = 3454; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + + this.state = 3457; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } break; - case 7: - this.enterOuterAlt(localContext, 7); + case 4: + this.enterOuterAlt(localContext, 4); { - this.state = 4586; + this.state = 3460; this.match(PostgreSqlParser.KW_CREATE); - this.state = 4587; + this.state = 3461; this.match(PostgreSqlParser.KW_TYPE); - this.state = 4588; + this.state = 3462; this.any_name(); - this.state = 4589; - this.match(PostgreSqlParser.KW_AS); - this.state = 4590; - this.match(PostgreSqlParser.KW_ENUM); - this.state = 4591; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4593; + this.state = 3468; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 558)) & ~0x1F) === 0 && ((1 << (_la - 558)) & 67108885) !== 0)) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 393, this.context) ) { + case 1: { - this.state = 4592; - this.opt_enum_val_list(); + this.state = 3465; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 36) { + { + this.state = 3463; + this.match(PostgreSqlParser.KW_AS); + this.state = 3464; + this.match(PostgreSqlParser.KW_RANGE); + } } - } - this.state = 4595; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 4597; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4598; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 4599; - this.any_name(); - this.state = 4600; - this.match(PostgreSqlParser.KW_AS); - this.state = 4601; - this.match(PostgreSqlParser.KW_RANGE); - this.state = 4602; - this.definition(); + this.state = 3467; + this.definition(); + } + break; } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 4604; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4605; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 4606; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 4607; - this.match(PostgreSqlParser.KW_PARSER); - this.state = 4608; - this.any_name(); - this.state = 4609; - this.definition(); } break; - case 10: - this.enterOuterAlt(localContext, 10); + case 5: + this.enterOuterAlt(localContext, 5); { - this.state = 4611; + this.state = 3470; this.match(PostgreSqlParser.KW_CREATE); - this.state = 4612; + this.state = 3471; this.match(PostgreSqlParser.KW_TEXT); - this.state = 4613; + this.state = 3472; this.match(PostgreSqlParser.KW_SEARCH); - this.state = 4614; - this.match(PostgreSqlParser.KW_DICTIONARY); - this.state = 4615; - this.any_name(); - this.state = 4616; - this.definition(); + this.state = 3473; + _la = this.tokenStream.LA(1); + if(!(_la === 163 || _la === 185 || _la === 283 || _la === 353)) { + this.errorHandler.recoverInline(this); } - break; - case 11: - this.enterOuterAlt(localContext, 11); - { - this.state = 4618; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4619; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 4620; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 4621; - this.match(PostgreSqlParser.KW_TEMPLATE); - this.state = 4622; - this.any_name(); - this.state = 4623; - this.definition(); + else { + this.errorHandler.reportMatch(this); + this.consume(); } - break; - case 12: - this.enterOuterAlt(localContext, 12); - { - this.state = 4625; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4626; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 4627; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 4628; - this.match(PostgreSqlParser.KW_CONFIGURATION); - this.state = 4629; + this.state = 3474; this.any_name(); - this.state = 4630; + this.state = 3475; this.definition(); } break; - case 13: - this.enterOuterAlt(localContext, 13); + case 6: + this.enterOuterAlt(localContext, 6); { - this.state = 4632; + this.state = 3477; this.match(PostgreSqlParser.KW_CREATE); - this.state = 4633; + this.state = 3478; this.match(PostgreSqlParser.KW_COLLATION); - this.state = 4635; + this.state = 3480; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 379, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 394, this.context) ) { case 1: { - this.state = 4634; + this.state = 3479; this.opt_if_not_exists(); } break; } - this.state = 4637; + this.state = 3482; this.any_name(); - this.state = 4638; - this.definition(); - } - break; - case 14: - this.enterOuterAlt(localContext, 14); - { - this.state = 4640; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 4641; - this.match(PostgreSqlParser.KW_COLLATION); - this.state = 4643; + this.state = 3486; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 380, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.OPEN_PAREN: { - this.state = 4642; - this.opt_if_not_exists(); + this.state = 3483; + this.definition(); + } + break; + case PostgreSqlParser.KW_FROM: + { + { + this.state = 3484; + this.match(PostgreSqlParser.KW_FROM); + this.state = 3485; + this.any_name(); + } } break; + default: + throw new antlr.NoViableAltException(this); } - this.state = 4645; - this.any_name(); - this.state = 4646; - this.match(PostgreSqlParser.KW_FROM); - this.state = 4647; - this.any_name(); } break; } @@ -21569,57 +19117,33 @@ export class PostgreSqlParser extends SQLParserBase { } public definition(): DefinitionContext { let localContext = new DefinitionContext(this.context, this.state); - this.enterRule(localContext, 496, PostgreSqlParser.RULE_definition); + this.enterRule(localContext, 284, PostgreSqlParser.RULE_definition); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4651; + this.state = 3490; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4652; - this.def_list(); - this.state = 4653; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public def_list(): Def_listContext { - let localContext = new Def_listContext(this.context, this.state); - this.enterRule(localContext, 498, PostgreSqlParser.RULE_def_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4655; + this.state = 3491; this.def_elem(); - this.state = 4660; + this.state = 3496; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 4656; + this.state = 3492; this.match(PostgreSqlParser.COMMA); - this.state = 4657; + this.state = 3493; this.def_elem(); } } - this.state = 4662; + this.state = 3498; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } + this.state = 3499; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -21638,21 +19162,21 @@ export class PostgreSqlParser extends SQLParserBase { } public def_elem(): Def_elemContext { let localContext = new Def_elemContext(this.context, this.state); - this.enterRule(localContext, 500, PostgreSqlParser.RULE_def_elem); + this.enterRule(localContext, 286, PostgreSqlParser.RULE_def_elem); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4663; + this.state = 3501; this.collabel(); - this.state = 4666; + this.state = 3504; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 10) { { - this.state = 4664; + this.state = 3502; this.match(PostgreSqlParser.EQUAL); - this.state = 4665; + this.state = 3503; this.def_arg(); } } @@ -21675,50 +19199,50 @@ export class PostgreSqlParser extends SQLParserBase { } public def_arg(): Def_argContext { let localContext = new Def_argContext(this.context, this.state); - this.enterRule(localContext, 502, PostgreSqlParser.RULE_def_arg); + this.enterRule(localContext, 288, PostgreSqlParser.RULE_def_arg); try { - this.state = 4674; + this.state = 3512; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 384, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 399, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 4668; + this.state = 3506; this.func_type(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 4669; + this.state = 3507; this.reserved_keyword(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 4670; + this.state = 3508; this.qual_all_op(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 4671; + this.state = 3509; this.numericonly(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 4672; + this.state = 3510; this.sconst(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 4673; + this.state = 3511; this.match(PostgreSqlParser.KW_NONE); } break; @@ -21738,86 +19262,17 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public old_aggr_definition(): Old_aggr_definitionContext { - let localContext = new Old_aggr_definitionContext(this.context, this.state); - this.enterRule(localContext, 504, PostgreSqlParser.RULE_old_aggr_definition); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4676; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4677; - this.old_aggr_list(); - this.state = 4678; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public old_aggr_list(): Old_aggr_listContext { - let localContext = new Old_aggr_listContext(this.context, this.state); - this.enterRule(localContext, 506, PostgreSqlParser.RULE_old_aggr_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4680; - this.old_aggr_elem(); - this.state = 4685; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 4681; - this.match(PostgreSqlParser.COMMA); - this.state = 4682; - this.old_aggr_elem(); - } - } - this.state = 4687; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public old_aggr_elem(): Old_aggr_elemContext { let localContext = new Old_aggr_elemContext(this.context, this.state); - this.enterRule(localContext, 508, PostgreSqlParser.RULE_old_aggr_elem); + this.enterRule(localContext, 290, PostgreSqlParser.RULE_old_aggr_elem); try { this.enterOuterAlt(localContext, 1); { - this.state = 4688; + this.state = 3514; this.identifier(); - this.state = 4689; + this.state = 3515; this.match(PostgreSqlParser.EQUAL); - this.state = 4690; + this.state = 3516; this.def_arg(); } } @@ -21835,110 +19290,45 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_enum_val_list(): Opt_enum_val_listContext { - let localContext = new Opt_enum_val_listContext(this.context, this.state); - this.enterRule(localContext, 510, PostgreSqlParser.RULE_opt_enum_val_list); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4692; - this.enum_val_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public enum_val_list(): Enum_val_listContext { - let localContext = new Enum_val_listContext(this.context, this.state); - this.enterRule(localContext, 512, PostgreSqlParser.RULE_enum_val_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4694; - this.sconst(); - this.state = 4699; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 4695; - this.match(PostgreSqlParser.COMMA); - this.state = 4696; - this.sconst(); - } - } - this.state = 4701; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public alterenumstmt(): AlterenumstmtContext { let localContext = new AlterenumstmtContext(this.context, this.state); - this.enterRule(localContext, 514, PostgreSqlParser.RULE_alterenumstmt); + this.enterRule(localContext, 292, PostgreSqlParser.RULE_alterenumstmt); let _la: number; try { - this.state = 4724; + this.state = 3540; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 389, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 402, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 4702; + this.state = 3518; this.match(PostgreSqlParser.KW_ALTER); - this.state = 4703; + this.state = 3519; this.match(PostgreSqlParser.KW_TYPE); - this.state = 4704; + this.state = 3520; this.any_name(); - this.state = 4705; + this.state = 3521; this.match(PostgreSqlParser.KW_ADD); - this.state = 4706; + this.state = 3522; this.match(PostgreSqlParser.KW_VALUE); - this.state = 4708; + this.state = 3524; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 220) { { - this.state = 4707; + this.state = 3523; this.opt_if_not_exists(); } } - this.state = 4710; + this.state = 3526; this.sconst(); - this.state = 4713; + this.state = 3529; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 388, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 401, this.context) ) { case 1: { - this.state = 4711; + this.state = 3527; _la = this.tokenStream.LA(1); if(!(_la === 135 || _la === 145)) { this.errorHandler.recoverInline(this); @@ -21947,7 +19337,7 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 4712; + this.state = 3528; this.sconst(); } break; @@ -21957,21 +19347,21 @@ export class PostgreSqlParser extends SQLParserBase { case 2: this.enterOuterAlt(localContext, 2); { - this.state = 4715; + this.state = 3531; this.match(PostgreSqlParser.KW_ALTER); - this.state = 4716; + this.state = 3532; this.match(PostgreSqlParser.KW_TYPE); - this.state = 4717; + this.state = 3533; this.any_name(); - this.state = 4718; + this.state = 3534; this.match(PostgreSqlParser.KW_RENAME); - this.state = 4719; + this.state = 3535; this.match(PostgreSqlParser.KW_VALUE); - this.state = 4720; + this.state = 3536; this.sconst(); - this.state = 4721; + this.state = 3537; this.match(PostgreSqlParser.KW_TO); - this.state = 4722; + this.state = 3538; this.sconst(); } break; @@ -21993,15 +19383,15 @@ export class PostgreSqlParser extends SQLParserBase { } public opt_if_not_exists(): Opt_if_not_existsContext { let localContext = new Opt_if_not_existsContext(this.context, this.state); - this.enterRule(localContext, 516, PostgreSqlParser.RULE_opt_if_not_exists); + this.enterRule(localContext, 294, PostgreSqlParser.RULE_opt_if_not_exists); try { this.enterOuterAlt(localContext, 1); { - this.state = 4726; + this.state = 3542; this.match(PostgreSqlParser.KW_IF); - this.state = 4727; + this.state = 3543; this.match(PostgreSqlParser.KW_NOT); - this.state = 4728; + this.state = 3544; this.match(PostgreSqlParser.KW_EXISTS); } } @@ -22021,91 +19411,66 @@ export class PostgreSqlParser extends SQLParserBase { } public createopclassstmt(): CreateopclassstmtContext { let localContext = new CreateopclassstmtContext(this.context, this.state); - this.enterRule(localContext, 518, PostgreSqlParser.RULE_createopclassstmt); + this.enterRule(localContext, 296, PostgreSqlParser.RULE_createopclassstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4730; + this.state = 3546; this.match(PostgreSqlParser.KW_CREATE); - this.state = 4731; + this.state = 3547; this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 4732; + this.state = 3548; this.match(PostgreSqlParser.KW_CLASS); - this.state = 4733; + this.state = 3549; this.any_name(); - this.state = 4735; + this.state = 3551; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 53) { { - this.state = 4734; - this.opt_default(); + this.state = 3550; + this.match(PostgreSqlParser.KW_DEFAULT); } } - this.state = 4737; + this.state = 3553; this.match(PostgreSqlParser.KW_FOR); - this.state = 4738; + this.state = 3554; this.match(PostgreSqlParser.KW_TYPE); - this.state = 4739; + this.state = 3555; this.typename(); - this.state = 4740; - this.match(PostgreSqlParser.KW_USING); - this.state = 4741; - this.name(); - this.state = 4743; + this.state = 3556; + this.table_access_method_clause(); + this.state = 3559; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 206) { { - this.state = 4742; - this.opt_opfamily(); + this.state = 3557; + this.match(PostgreSqlParser.KW_FAMILY); + this.state = 3558; + this.any_name(); } } - this.state = 4745; + this.state = 3561; this.match(PostgreSqlParser.KW_AS); - this.state = 4746; - this.opclass_item_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opclass_item_list(): Opclass_item_listContext { - let localContext = new Opclass_item_listContext(this.context, this.state); - this.enterRule(localContext, 520, PostgreSqlParser.RULE_opclass_item_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4748; + this.state = 3562; this.opclass_item(); - this.state = 4753; + this.state = 3567; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 4749; + this.state = 3563; this.match(PostgreSqlParser.COMMA); - this.state = 4750; + this.state = 3564; this.opclass_item(); } } - this.state = 4755; + this.state = 3569; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -22127,230 +19492,109 @@ export class PostgreSqlParser extends SQLParserBase { } public opclass_item(): Opclass_itemContext { let localContext = new Opclass_itemContext(this.context, this.state); - this.enterRule(localContext, 522, PostgreSqlParser.RULE_opclass_item); + this.enterRule(localContext, 298, PostgreSqlParser.RULE_opclass_item); let _la: number; try { - this.state = 4787; + this.state = 3596; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 397, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_OPERATOR: this.enterOuterAlt(localContext, 1); { - this.state = 4756; + this.state = 3570; this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 4757; - this.iconst(); - this.state = 4758; + this.state = 3571; + this.match(PostgreSqlParser.Integral); + this.state = 3572; this.any_operator(); - this.state = 4760; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 4759; - this.opclass_purpose(); - } - } - - this.state = 4763; + this.state = 3574; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 394, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 406, this.context) ) { case 1: { - this.state = 4762; - this.opt_recheck(); + this.state = 3573; + this.oper_argtypes(); } break; } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 4765; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 4766; - this.iconst(); - this.state = 4767; - this.operator_with_argtypes(); - this.state = 4769; + this.state = 3583; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 62) { { - this.state = 4768; - this.opclass_purpose(); + this.state = 3576; + this.match(PostgreSqlParser.KW_FOR); + this.state = 3581; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_SEARCH: + { + this.state = 3577; + this.match(PostgreSqlParser.KW_SEARCH); + } + break; + case PostgreSqlParser.KW_ORDER: + { + { + this.state = 3578; + this.match(PostgreSqlParser.KW_ORDER); + this.state = 3579; + this.match(PostgreSqlParser.KW_BY); + this.state = 3580; + this.any_name(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } } } - this.state = 4772; + this.state = 3586; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 396, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 409, this.context) ) { case 1: { - this.state = 4771; - this.opt_recheck(); + this.state = 3585; + this.match(PostgreSqlParser.KW_RECHECK); } break; } } break; - case 3: - this.enterOuterAlt(localContext, 3); + case PostgreSqlParser.KW_FUNCTION: + this.enterOuterAlt(localContext, 2); { - this.state = 4774; + this.state = 3588; this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 4775; - this.iconst(); - this.state = 4776; - this.function_with_argtypes(); + this.state = 3589; + this.match(PostgreSqlParser.Integral); + this.state = 3591; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 3590; + this.prep_type_clause(); + } } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 4778; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 4779; - this.iconst(); - this.state = 4780; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4781; - this.type_list(); - this.state = 4782; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 4783; + + this.state = 3593; this.function_with_argtypes(); } break; - case 5: - this.enterOuterAlt(localContext, 5); + case PostgreSqlParser.KW_STORAGE: + this.enterOuterAlt(localContext, 3); { - this.state = 4785; + this.state = 3594; this.match(PostgreSqlParser.KW_STORAGE); - this.state = 4786; + this.state = 3595; this.typename(); } break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_default(): Opt_defaultContext { - let localContext = new Opt_defaultContext(this.context, this.state); - this.enterRule(localContext, 524, PostgreSqlParser.RULE_opt_default); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4789; - this.match(PostgreSqlParser.KW_DEFAULT); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_opfamily(): Opt_opfamilyContext { - let localContext = new Opt_opfamilyContext(this.context, this.state); - this.enterRule(localContext, 526, PostgreSqlParser.RULE_opt_opfamily); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4791; - this.match(PostgreSqlParser.KW_FAMILY); - this.state = 4792; - this.any_name(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opclass_purpose(): Opclass_purposeContext { - let localContext = new Opclass_purposeContext(this.context, this.state); - this.enterRule(localContext, 528, PostgreSqlParser.RULE_opclass_purpose); - try { - this.state = 4800; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 398, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 4794; - this.match(PostgreSqlParser.KW_FOR); - this.state = 4795; - this.match(PostgreSqlParser.KW_SEARCH); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 4796; - this.match(PostgreSqlParser.KW_FOR); - this.state = 4797; - this.match(PostgreSqlParser.KW_ORDER); - this.state = 4798; - this.match(PostgreSqlParser.KW_BY); - this.state = 4799; - this.any_name(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_recheck(): Opt_recheckContext { - let localContext = new Opt_recheckContext(this.context, this.state); - this.enterRule(localContext, 530, PostgreSqlParser.RULE_opt_recheck); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 4802; - this.match(PostgreSqlParser.KW_RECHECK); + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -22369,22 +19613,20 @@ export class PostgreSqlParser extends SQLParserBase { } public createopfamilystmt(): CreateopfamilystmtContext { let localContext = new CreateopfamilystmtContext(this.context, this.state); - this.enterRule(localContext, 532, PostgreSqlParser.RULE_createopfamilystmt); + this.enterRule(localContext, 300, PostgreSqlParser.RULE_createopfamilystmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 4804; + this.state = 3598; this.match(PostgreSqlParser.KW_CREATE); - this.state = 4805; + this.state = 3599; this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 4806; + this.state = 3600; this.match(PostgreSqlParser.KW_FAMILY); - this.state = 4807; + this.state = 3601; this.any_name(); - this.state = 4808; - this.match(PostgreSqlParser.KW_USING); - this.state = 4809; - this.name(); + this.state = 3602; + this.table_access_method_clause(); } } catch (re) { @@ -22403,53 +19645,75 @@ export class PostgreSqlParser extends SQLParserBase { } public alteropfamilystmt(): AlteropfamilystmtContext { let localContext = new AlteropfamilystmtContext(this.context, this.state); - this.enterRule(localContext, 534, PostgreSqlParser.RULE_alteropfamilystmt); + this.enterRule(localContext, 302, PostgreSqlParser.RULE_alteropfamilystmt); + let _la: number; try { - this.state = 4829; + this.enterOuterAlt(localContext, 1); + { + this.state = 3604; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 3605; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 3606; + this.match(PostgreSqlParser.KW_FAMILY); + this.state = 3607; + this.any_name(); + this.state = 3608; + this.table_access_method_clause(); + this.state = 3627; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 399, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_ADD: { - this.state = 4811; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 4812; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 4813; - this.match(PostgreSqlParser.KW_FAMILY); - this.state = 4814; - this.any_name(); - this.state = 4815; - this.match(PostgreSqlParser.KW_USING); - this.state = 4816; - this.name(); - this.state = 4817; + this.state = 3609; this.match(PostgreSqlParser.KW_ADD); - this.state = 4818; - this.opclass_item_list(); + this.state = 3610; + this.opclass_item(); + this.state = 3615; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 3611; + this.match(PostgreSqlParser.COMMA); + this.state = 3612; + this.opclass_item(); + } + } + this.state = 3617; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } } break; - case 2: - this.enterOuterAlt(localContext, 2); + case PostgreSqlParser.KW_DROP: { - this.state = 4820; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 4821; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 4822; - this.match(PostgreSqlParser.KW_FAMILY); - this.state = 4823; - this.any_name(); - this.state = 4824; - this.match(PostgreSqlParser.KW_USING); - this.state = 4825; - this.name(); - this.state = 4826; + this.state = 3618; this.match(PostgreSqlParser.KW_DROP); - this.state = 4827; - this.opclass_drop_list(); + this.state = 3619; + this.opclass_drop(); + this.state = 3624; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 3620; + this.match(PostgreSqlParser.COMMA); + this.state = 3621; + this.opclass_drop(); + } + } + this.state = 3626; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } } break; + default: + throw new antlr.NoViableAltException(this); + } } } catch (re) { @@ -22466,86 +19730,26 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opclass_drop_list(): Opclass_drop_listContext { - let localContext = new Opclass_drop_listContext(this.context, this.state); - this.enterRule(localContext, 536, PostgreSqlParser.RULE_opclass_drop_list); + public opclass_drop(): Opclass_dropContext { + let localContext = new Opclass_dropContext(this.context, this.state); + this.enterRule(localContext, 304, PostgreSqlParser.RULE_opclass_drop); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 4831; - this.opclass_drop(); - this.state = 4836; - this.errorHandler.sync(this); + this.state = 3629; _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 4832; - this.match(PostgreSqlParser.COMMA); - this.state = 4833; - this.opclass_drop(); - } - } - this.state = 4838; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } + if(!(_la === 211 || _la === 278)) { + this.errorHandler.recoverInline(this); } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + else { + this.errorHandler.reportMatch(this); + this.consume(); } - } - finally { - this.exitRule(); - } - return localContext; - } - public opclass_drop(): Opclass_dropContext { - let localContext = new Opclass_dropContext(this.context, this.state); - this.enterRule(localContext, 538, PostgreSqlParser.RULE_opclass_drop); - try { - this.state = 4851; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_OPERATOR: - this.enterOuterAlt(localContext, 1); - { - this.state = 4839; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 4840; - this.iconst(); - this.state = 4841; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4842; - this.type_list(); - this.state = 4843; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_FUNCTION: - this.enterOuterAlt(localContext, 2); - { - this.state = 4845; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 4846; - this.iconst(); - this.state = 4847; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 4848; - this.type_list(); - this.state = 4849; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - default: - throw new antlr.NoViableAltException(this); + this.state = 3630; + this.match(PostgreSqlParser.Integral); + this.state = 3631; + this.prep_type_clause(); } } catch (re) { @@ -22564,21 +19768,21 @@ export class PostgreSqlParser extends SQLParserBase { } public reassignownedstmt(): ReassignownedstmtContext { let localContext = new ReassignownedstmtContext(this.context, this.state); - this.enterRule(localContext, 540, PostgreSqlParser.RULE_reassignownedstmt); + this.enterRule(localContext, 306, PostgreSqlParser.RULE_reassignownedstmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 4853; + this.state = 3633; this.match(PostgreSqlParser.KW_REASSIGN); - this.state = 4854; + this.state = 3634; this.match(PostgreSqlParser.KW_OWNED); - this.state = 4855; + this.state = 3635; this.match(PostgreSqlParser.KW_BY); - this.state = 4856; + this.state = 3636; this.role_list(); - this.state = 4857; + this.state = 3637; this.match(PostgreSqlParser.KW_TO); - this.state = 4858; + this.state = 3638; this.rolespec(); } } @@ -22598,1259 +19802,1417 @@ export class PostgreSqlParser extends SQLParserBase { } public dropstmt(): DropstmtContext { let localContext = new DropstmtContext(this.context, this.state); - this.enterRule(localContext, 542, PostgreSqlParser.RULE_dropstmt); + this.enterRule(localContext, 308, PostgreSqlParser.RULE_dropstmt); let _la: number; try { - this.state = 5239; + this.state = 3847; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 476, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 452, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 4860; + this.state = 3640; this.match(PostgreSqlParser.KW_DROP); - this.state = 4861; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 4863; + this.state = 3663; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 402, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_SEQUENCE: { - this.state = 4862; - this.opt_if_exists(); + this.state = 3641; + this.match(PostgreSqlParser.KW_SEQUENCE); } break; - } - this.state = 4865; - this.table_name_list(); - this.state = 4867; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 403, this.context) ) { - case 1: + case PostgreSqlParser.KW_INDEX: { - this.state = 4866; - this.opt_drop_behavior(); + this.state = 3642; + this.match(PostgreSqlParser.KW_INDEX); } break; - } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 4869; - this.match(PostgreSqlParser.KW_DROP); - this.state = 4870; - this.match(PostgreSqlParser.KW_SEQUENCE); - this.state = 4872; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 404, this.context) ) { - case 1: + case PostgreSqlParser.KW_COLLATION: { - this.state = 4871; - this.opt_if_exists(); + this.state = 3643; + this.match(PostgreSqlParser.KW_COLLATION); } break; - } - this.state = 4874; - this.name_list(); - this.state = 4876; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 405, this.context) ) { - case 1: + case PostgreSqlParser.KW_CONVERSION: { - this.state = 4875; - this.opt_drop_behavior(); + this.state = 3644; + this.match(PostgreSqlParser.KW_CONVERSION); } break; - } - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 4878; - this.match(PostgreSqlParser.KW_DROP); - this.state = 4879; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 4881; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 406, this.context) ) { - case 1: + case PostgreSqlParser.KW_STATISTICS: { - this.state = 4880; - this.opt_if_exists(); + this.state = 3645; + this.match(PostgreSqlParser.KW_STATISTICS); } break; - } - this.state = 4883; - this.view_nameList(); - this.state = 4885; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 407, this.context) ) { - case 1: + case PostgreSqlParser.KW_PUBLICATION: { - this.state = 4884; - this.opt_drop_behavior(); + this.state = 3646; + this.match(PostgreSqlParser.KW_PUBLICATION); } break; - } - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 4887; - this.match(PostgreSqlParser.KW_DROP); - this.state = 4888; - this.match(PostgreSqlParser.KW_MATERIALIZED); - this.state = 4889; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 4891; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 408, this.context) ) { - case 1: + case PostgreSqlParser.KW_SERVER: { - this.state = 4890; - this.opt_if_exists(); + this.state = 3647; + this.match(PostgreSqlParser.KW_SERVER); } break; - } - this.state = 4893; - this.view_nameList(); - this.state = 4895; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 409, this.context) ) { - case 1: + case PostgreSqlParser.KW_ACCESS: { - this.state = 4894; - this.opt_drop_behavior(); + this.state = 3648; + this.match(PostgreSqlParser.KW_ACCESS); + this.state = 3649; + this.match(PostgreSqlParser.KW_METHOD); } break; - } - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 4897; - this.match(PostgreSqlParser.KW_DROP); - this.state = 4898; - this.match(PostgreSqlParser.KW_INDEX); - this.state = 4900; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 410, this.context) ) { - case 1: + case PostgreSqlParser.KW_EVENT: { - this.state = 4899; - this.opt_if_exists(); + this.state = 3650; + this.match(PostgreSqlParser.KW_EVENT); + this.state = 3651; + this.match(PostgreSqlParser.KW_TRIGGER); } break; - } - this.state = 4902; - this.name_list(); - this.state = 4904; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 411, this.context) ) { - case 1: + case PostgreSqlParser.KW_EXTENSION: { - this.state = 4903; - this.opt_drop_behavior(); + this.state = 3652; + this.match(PostgreSqlParser.KW_EXTENSION); } break; - } - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 4906; - this.match(PostgreSqlParser.KW_DROP); - this.state = 4907; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 4908; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 4910; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 412, this.context) ) { - case 1: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_PROCEDURAL: { - this.state = 4909; - this.opt_if_exists(); + this.state = 3654; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 295) { + { + this.state = 3653; + this.match(PostgreSqlParser.KW_PROCEDURAL); + } } - break; - } - this.state = 4912; - this.table_name_list(); - this.state = 4914; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 413, this.context) ) { - case 1: - { - this.state = 4913; - this.opt_drop_behavior(); + + this.state = 3656; + this.match(PostgreSqlParser.KW_LANGUAGE); } break; - } - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 4916; - this.match(PostgreSqlParser.KW_DROP); - this.state = 4917; - this.match(PostgreSqlParser.KW_COLLATION); - this.state = 4919; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 414, this.context) ) { - case 1: + case PostgreSqlParser.KW_FOREIGN: { - this.state = 4918; - this.opt_if_exists(); + this.state = 3657; + this.match(PostgreSqlParser.KW_FOREIGN); + this.state = 3658; + this.match(PostgreSqlParser.KW_DATA); + this.state = 3659; + this.match(PostgreSqlParser.KW_WRAPPER); } break; - } - this.state = 4921; - this.name_list(); - this.state = 4923; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 415, this.context) ) { - case 1: + case PostgreSqlParser.KW_TEXT: { - this.state = 4922; - this.opt_drop_behavior(); + this.state = 3660; + this.match(PostgreSqlParser.KW_TEXT); + this.state = 3661; + this.match(PostgreSqlParser.KW_SEARCH); + this.state = 3662; + _la = this.tokenStream.LA(1); + if(!(_la === 163 || _la === 185 || _la === 283 || _la === 353)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } } break; + default: + throw new antlr.NoViableAltException(this); } - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 4925; - this.match(PostgreSqlParser.KW_DROP); - this.state = 4926; - this.match(PostgreSqlParser.KW_CONVERSION); - this.state = 4928; + this.state = 3666; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 416, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 417, this.context) ) { case 1: { - this.state = 4927; + this.state = 3665; this.opt_if_exists(); } break; } - this.state = 4930; + this.state = 3668; this.name_list(); - this.state = 4932; + this.state = 3670; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 417, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 418, this.context) ) { case 1: { - this.state = 4931; + this.state = 3669; this.opt_drop_behavior(); } break; } } break; - case 9: - this.enterOuterAlt(localContext, 9); + case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 4934; + this.state = 3672; this.match(PostgreSqlParser.KW_DROP); - this.state = 4935; - this.match(PostgreSqlParser.KW_STATISTICS); - this.state = 4937; + this.state = 3674; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 418, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 259) { { - this.state = 4936; - this.opt_if_exists(); + this.state = 3673; + this.match(PostgreSqlParser.KW_MATERIALIZED); } - break; } - this.state = 4939; - this.name_list(); - this.state = 4941; + + this.state = 3676; + this.match(PostgreSqlParser.KW_VIEW); + this.state = 3678; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 419, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 420, this.context) ) { case 1: { - this.state = 4940; - this.opt_drop_behavior(); + this.state = 3677; + this.opt_if_exists(); } break; } - } - break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 4943; - this.match(PostgreSqlParser.KW_DROP); - this.state = 4944; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 4945; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 4946; - this.match(PostgreSqlParser.KW_PARSER); - this.state = 4948; + this.state = 3680; + this.view_name(); + this.state = 3685; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 420, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + while (_la === 6) { { - this.state = 4947; - this.opt_if_exists(); + { + this.state = 3681; + this.match(PostgreSqlParser.COMMA); + this.state = 3682; + this.view_name(); } - break; + } + this.state = 3687; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - this.state = 4950; - this.name_list(); - this.state = 4952; + this.state = 3689; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 421, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 422, this.context) ) { case 1: { - this.state = 4951; + this.state = 3688; this.opt_drop_behavior(); } break; } } break; - case 11: - this.enterOuterAlt(localContext, 11); + case 3: + this.enterOuterAlt(localContext, 3); { - this.state = 4954; + this.state = 3691; this.match(PostgreSqlParser.KW_DROP); - this.state = 4955; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 4956; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 4957; - this.match(PostgreSqlParser.KW_DICTIONARY); - this.state = 4959; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 422, this.context) ) { - case 1: - { - this.state = 4958; - this.opt_if_exists(); - } - break; - } - this.state = 4961; - this.name_list(); - this.state = 4963; + this.state = 3693; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 423, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 63) { { - this.state = 4962; - this.opt_drop_behavior(); + this.state = 3692; + this.match(PostgreSqlParser.KW_FOREIGN); } - break; - } } - break; - case 12: - this.enterOuterAlt(localContext, 12); - { - this.state = 4965; - this.match(PostgreSqlParser.KW_DROP); - this.state = 4966; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 4967; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 4968; - this.match(PostgreSqlParser.KW_TEMPLATE); - this.state = 4970; + + this.state = 3695; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 3697; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 424, this.context) ) { case 1: { - this.state = 4969; + this.state = 3696; this.opt_if_exists(); } break; } - this.state = 4972; - this.name_list(); - this.state = 4974; + this.state = 3699; + this.table_name_list(); + this.state = 3701; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 425, this.context) ) { case 1: { - this.state = 4973; + this.state = 3700; this.opt_drop_behavior(); } break; } } break; - case 13: - this.enterOuterAlt(localContext, 13); + case 4: + this.enterOuterAlt(localContext, 4); { - this.state = 4976; + this.state = 3703; this.match(PostgreSqlParser.KW_DROP); - this.state = 4977; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 4978; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 4979; - this.match(PostgreSqlParser.KW_CONFIGURATION); - this.state = 4981; + this.state = 3704; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 3706; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 426, this.context) ) { case 1: { - this.state = 4980; + this.state = 3705; this.opt_if_exists(); } break; } - this.state = 4983; - this.name_list(); - this.state = 4985; + this.state = 3708; + this.schema_name_list(); + this.state = 3710; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 427, this.context) ) { case 1: { - this.state = 4984; + this.state = 3709; this.opt_drop_behavior(); } break; } } break; - case 14: - this.enterOuterAlt(localContext, 14); + case 5: + this.enterOuterAlt(localContext, 5); { - this.state = 4987; + this.state = 3712; this.match(PostgreSqlParser.KW_DROP); - this.state = 4988; - this.match(PostgreSqlParser.KW_ACCESS); - this.state = 4989; - this.match(PostgreSqlParser.KW_METHOD); - this.state = 4991; + this.state = 3713; + _la = this.tokenStream.LA(1); + if(!(_la === 321 || _la === 357 || _la === 445)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3715; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 428, this.context) ) { case 1: { - this.state = 4990; + this.state = 3714; this.opt_if_exists(); } break; } - this.state = 4993; - this.name_list(); - this.state = 4995; + this.state = 3717; + this.colid(); + this.state = 3718; + this.match(PostgreSqlParser.KW_ON); + this.state = 3719; + this.any_name(); + this.state = 3721; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 429, this.context) ) { case 1: { - this.state = 4994; + this.state = 3720; this.opt_drop_behavior(); } break; } } break; - case 15: - this.enterOuterAlt(localContext, 15); + case 6: + this.enterOuterAlt(localContext, 6); { - this.state = 4997; + this.state = 3723; this.match(PostgreSqlParser.KW_DROP); - this.state = 4998; - this.match(PostgreSqlParser.KW_EVENT); - this.state = 4999; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 5001; + this.state = 3724; + _la = this.tokenStream.LA(1); + if(!(_la === 189 || _la === 360)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3726; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 430, this.context) ) { case 1: { - this.state = 5000; + this.state = 3725; this.opt_if_exists(); } break; } - this.state = 5003; - this.name_list(); - this.state = 5005; + this.state = 3728; + this.typename(); + this.state = 3733; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 3729; + this.match(PostgreSqlParser.COMMA); + this.state = 3730; + this.typename(); + } + } + this.state = 3735; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 3737; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 431, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 432, this.context) ) { case 1: { - this.state = 5004; + this.state = 3736; this.opt_drop_behavior(); } break; } } break; - case 16: - this.enterOuterAlt(localContext, 16); + case 7: + this.enterOuterAlt(localContext, 7); { - this.state = 5007; + this.state = 3739; this.match(PostgreSqlParser.KW_DROP); - this.state = 5008; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 5010; + this.state = 3740; + this.match(PostgreSqlParser.KW_INDEX); + this.state = 3741; + this.match(PostgreSqlParser.KW_CONCURRENTLY); + this.state = 3743; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 432, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 433, this.context) ) { case 1: { - this.state = 5009; + this.state = 3742; this.opt_if_exists(); } break; } - this.state = 5012; - this.name_list(); - this.state = 5014; + this.state = 3745; + this.any_name_list(); + this.state = 3747; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 433, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 434, this.context) ) { case 1: { - this.state = 5013; + this.state = 3746; this.opt_drop_behavior(); } break; } } break; - case 17: - this.enterOuterAlt(localContext, 17); + case 8: + this.enterOuterAlt(localContext, 8); { - this.state = 5016; + this.state = 3749; this.match(PostgreSqlParser.KW_DROP); - this.state = 5017; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 5018; - this.match(PostgreSqlParser.KW_DATA); - this.state = 5019; - this.match(PostgreSqlParser.KW_WRAPPER); - this.state = 5021; + this.state = 3750; + this.match(PostgreSqlParser.KW_CAST); + this.state = 3752; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 434, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 220) { { - this.state = 5020; + this.state = 3751; this.opt_if_exists(); } - break; } - this.state = 5023; - this.name_list(); - this.state = 5025; + + this.state = 3754; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 3755; + this.typename(); + this.state = 3756; + this.match(PostgreSqlParser.KW_AS); + this.state = 3757; + this.typename(); + this.state = 3758; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 3760; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 435, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 436, this.context) ) { case 1: { - this.state = 5024; + this.state = 3759; this.opt_drop_behavior(); } break; } } break; - case 18: - this.enterOuterAlt(localContext, 18); + case 9: + this.enterOuterAlt(localContext, 9); { - this.state = 5027; + this.state = 3762; this.match(PostgreSqlParser.KW_DROP); - this.state = 5029; - this.errorHandler.sync(this); + this.state = 3763; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 3764; _la = this.tokenStream.LA(1); - if (_la === 295) { - { - this.state = 5028; - this.opt_procedural(); - } + if(!(_la === 156 || _la === 206)) { + this.errorHandler.recoverInline(this); } - - this.state = 5031; - this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 5033; + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3766; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 437, this.context) ) { case 1: { - this.state = 5032; + this.state = 3765; this.opt_if_exists(); } break; } - this.state = 5035; - this.name_list(); - this.state = 5037; + this.state = 3768; + this.any_name(); + this.state = 3769; + this.table_access_method_clause(); + this.state = 3771; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 438, this.context) ) { case 1: { - this.state = 5036; + this.state = 3770; this.opt_drop_behavior(); } break; } } break; - case 19: - this.enterOuterAlt(localContext, 19); + case 10: + this.enterOuterAlt(localContext, 10); { - this.state = 5039; + this.state = 3773; this.match(PostgreSqlParser.KW_DROP); - this.state = 5040; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 5042; + this.state = 3774; + this.match(PostgreSqlParser.KW_OWNED); + this.state = 3775; + this.match(PostgreSqlParser.KW_BY); + this.state = 3776; + this.role_list(); + this.state = 3778; this.errorHandler.sync(this); switch (this.interpreter.adaptivePredict(this.tokenStream, 439, this.context) ) { case 1: { - this.state = 5041; - this.opt_if_exists(); - } - break; - } - this.state = 5044; - this.name_list(); - this.state = 5046; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 440, this.context) ) { - case 1: - { - this.state = 5045; + this.state = 3777; this.opt_drop_behavior(); } break; } } break; - case 20: - this.enterOuterAlt(localContext, 20); + case 11: + this.enterOuterAlt(localContext, 11); { - this.state = 5048; + this.state = 3780; this.match(PostgreSqlParser.KW_DROP); - this.state = 5049; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 5051; + this.state = 3781; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); + this.state = 3783; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 441, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 440, this.context) ) { case 1: { - this.state = 5050; + this.state = 3782; this.opt_if_exists(); } break; } - this.state = 5053; - this.name_list(); - this.state = 5055; + this.state = 3785; + this.colid(); + this.state = 3787; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 442, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 441, this.context) ) { case 1: { - this.state = 5054; + this.state = 3786; this.opt_drop_behavior(); } break; } } break; - case 21: - this.enterOuterAlt(localContext, 21); + case 12: + this.enterOuterAlt(localContext, 12); { - this.state = 5057; + this.state = 3789; this.match(PostgreSqlParser.KW_DROP); - this.state = 5058; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 5060; + this.state = 3790; + this.match(PostgreSqlParser.KW_TABLESPACE); + this.state = 3792; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 443, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 442, this.context) ) { case 1: { - this.state = 5059; + this.state = 3791; this.opt_if_exists(); } break; } - this.state = 5062; - this.schema_name_list(); - this.state = 5064; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 444, this.context) ) { - case 1: - { - this.state = 5063; - this.opt_drop_behavior(); - } - break; - } + this.state = 3794; + this.tablespace_name(); } break; - case 22: - this.enterOuterAlt(localContext, 22); + case 13: + this.enterOuterAlt(localContext, 13); { - this.state = 5066; + this.state = 3795; this.match(PostgreSqlParser.KW_DROP); - this.state = 5067; - this.match(PostgreSqlParser.KW_POLICY); - this.state = 5069; + this.state = 3796; + this.match(PostgreSqlParser.KW_TRANSFORM); + this.state = 3798; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 445, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 220) { { - this.state = 5068; + this.state = 3797; this.opt_if_exists(); } - break; } - this.state = 5071; - this.name(); - this.state = 5072; - this.match(PostgreSqlParser.KW_ON); - this.state = 5073; - this.any_name(); - this.state = 5075; + + this.state = 3800; + this.match(PostgreSqlParser.KW_FOR); + this.state = 3801; + this.typename(); + this.state = 3802; + this.match(PostgreSqlParser.KW_LANGUAGE); + this.state = 3803; + this.colid(); + this.state = 3805; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 446, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 444, this.context) ) { case 1: { - this.state = 5074; + this.state = 3804; this.opt_drop_behavior(); } break; } } break; - case 23: - this.enterOuterAlt(localContext, 23); + case 14: + this.enterOuterAlt(localContext, 14); { - this.state = 5077; + this.state = 3807; this.match(PostgreSqlParser.KW_DROP); - this.state = 5078; - this.match(PostgreSqlParser.KW_RULE); - this.state = 5080; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 447, this.context) ) { - case 1: - { - this.state = 5079; - this.opt_if_exists(); - } - break; + this.state = 3808; + _la = this.tokenStream.LA(1); + if(!(_la === 66 || _la === 99 || _la === 318)) { + this.errorHandler.recoverInline(this); } - this.state = 5082; - this.name(); - this.state = 5083; - this.match(PostgreSqlParser.KW_ON); - this.state = 5084; - this.any_name(); - this.state = 5086; + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3810; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 448, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 445, this.context) ) { case 1: { - this.state = 5085; - this.opt_drop_behavior(); + this.state = 3809; + this.opt_if_exists(); } break; } + this.state = 3812; + this.role_list(); } break; - case 24: - this.enterOuterAlt(localContext, 24); + case 15: + this.enterOuterAlt(localContext, 15); { - this.state = 5088; + this.state = 3813; this.match(PostgreSqlParser.KW_DROP); - this.state = 5089; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 5091; + this.state = 3814; + this.match(PostgreSqlParser.KW_USER); + this.state = 3815; + this.match(PostgreSqlParser.KW_MAPPING); + this.state = 3817; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 449, this.context) ) { - case 1: - { - this.state = 5090; - this.opt_if_exists(); - } - break; - } - this.state = 5093; - this.name(); - this.state = 5094; - this.match(PostgreSqlParser.KW_ON); - this.state = 5095; - this.any_name(); - this.state = 5097; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 450, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 220) { { - this.state = 5096; - this.opt_drop_behavior(); + this.state = 3816; + this.opt_if_exists(); } - break; - } } - break; - case 25: - this.enterOuterAlt(localContext, 25); - { - this.state = 5099; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5100; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 5102; + + this.state = 3819; + this.match(PostgreSqlParser.KW_FOR); + this.state = 3822; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 451, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_CURRENT_ROLE: + case PostgreSqlParser.KW_CURRENT_USER: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_SESSION_USER: + case PostgreSqlParser.KW_AUTHORIZATION: + case PostgreSqlParser.KW_BINARY: + case PostgreSqlParser.KW_COLLATION: + case PostgreSqlParser.KW_CONCURRENTLY: + case PostgreSqlParser.KW_CROSS: + case PostgreSqlParser.KW_CURRENT_SCHEMA: + case PostgreSqlParser.KW_FREEZE: + case PostgreSqlParser.KW_FULL: + case PostgreSqlParser.KW_ILIKE: + case PostgreSqlParser.KW_INNER: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_ISNULL: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_LIKE: + case PostgreSqlParser.KW_NATURAL: + case PostgreSqlParser.KW_NOTNULL: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_OVERLAPS: + case PostgreSqlParser.KW_RIGHT: + case PostgreSqlParser.KW_SIMILAR: + case PostgreSqlParser.KW_VERBOSE: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_TABLESAMPLE: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_PUBLIC: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: { - this.state = 5101; - this.opt_if_exists(); + this.state = 3820; + this.rolespec(); } break; - } - this.state = 5104; - this.type_name_list(); - this.state = 5106; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 452, this.context) ) { - case 1: + case PostgreSqlParser.KW_USER: { - this.state = 5105; - this.opt_drop_behavior(); + this.state = 3821; + this.match(PostgreSqlParser.KW_USER); } break; + default: + throw new antlr.NoViableAltException(this); } + this.state = 3824; + this.match(PostgreSqlParser.KW_SERVER); + this.state = 3825; + this.colid(); } break; - case 26: - this.enterOuterAlt(localContext, 26); + case 16: + this.enterOuterAlt(localContext, 16); { - this.state = 5108; + this.state = 3826; this.match(PostgreSqlParser.KW_DROP); - this.state = 5109; - this.match(PostgreSqlParser.KW_DOMAIN); - this.state = 5111; + this.state = 3827; + this.match(PostgreSqlParser.KW_DATABASE); + this.state = 3829; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 453, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 448, this.context) ) { case 1: { - this.state = 5110; + this.state = 3828; this.opt_if_exists(); } break; } - this.state = 5113; - this.type_name_list(); - this.state = 5115; + this.state = 3831; + this.database_name(); + this.state = 3845; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 454, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 451, this.context) ) { case 1: { - this.state = 5114; - this.opt_drop_behavior(); + this.state = 3833; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 105) { + { + this.state = 3832; + this.match(PostgreSqlParser.KW_WITH); + } + } + + { + this.state = 3835; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 3836; + this.match(PostgreSqlParser.KW_FORCE); + this.state = 3841; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 3837; + this.match(PostgreSqlParser.COMMA); + this.state = 3838; + this.match(PostgreSqlParser.KW_FORCE); + } + } + this.state = 3843; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 3844; + this.match(PostgreSqlParser.CLOSE_PAREN); + } } break; } } break; - case 27: - this.enterOuterAlt(localContext, 27); - { - this.state = 5117; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5118; - this.match(PostgreSqlParser.KW_INDEX); - this.state = 5119; - this.match(PostgreSqlParser.KW_CONCURRENTLY); - this.state = 5121; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 455, this.context) ) { - case 1: - { - this.state = 5120; - this.opt_if_exists(); - } - break; - } - this.state = 5123; - this.any_name_list(); - this.state = 5125; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public object_type_any_name(): Object_type_any_nameContext { + let localContext = new Object_type_any_nameContext(this.context, this.state); + this.enterRule(localContext, 310, PostgreSqlParser.RULE_object_type_any_name); + let _la: number; + try { + this.state = 3865; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_FOREIGN: + case PostgreSqlParser.KW_TABLE: + this.enterOuterAlt(localContext, 1); + { + this.state = 3850; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 456, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 63) { { - this.state = 5124; - this.opt_drop_behavior(); + this.state = 3849; + this.match(PostgreSqlParser.KW_FOREIGN); } - break; } + + this.state = 3852; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 3853; + this.table_name(); } break; - case 28: - this.enterOuterAlt(localContext, 28); + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_VIEW: + this.enterOuterAlt(localContext, 2); { - this.state = 5127; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5128; - this.match(PostgreSqlParser.KW_CAST); - this.state = 5130; + this.state = 3855; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 220) { + if (_la === 259) { { - this.state = 5129; - this.opt_if_exists(); + this.state = 3854; + this.match(PostgreSqlParser.KW_MATERIALIZED); } } - this.state = 5132; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 5133; - this.typename(); - this.state = 5134; - this.match(PostgreSqlParser.KW_AS); - this.state = 5135; - this.typename(); - this.state = 5136; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 5138; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 458, this.context) ) { - case 1: - { - this.state = 5137; - this.opt_drop_behavior(); - } - break; - } + this.state = 3857; + this.match(PostgreSqlParser.KW_VIEW); + this.state = 3858; + this.view_name(); } break; - case 29: - this.enterOuterAlt(localContext, 29); + case PostgreSqlParser.KW_COLLATION: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_STATISTICS: + this.enterOuterAlt(localContext, 3); { - this.state = 5140; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5141; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 5142; - this.match(PostgreSqlParser.KW_CLASS); - this.state = 5144; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 459, this.context) ) { - case 1: - { - this.state = 5143; - this.opt_if_exists(); - } - break; + this.state = 3859; + _la = this.tokenStream.LA(1); + if(!(_la === 108 || _la === 168 || _la === 226 || _la === 328 || _la === 342)) { + this.errorHandler.recoverInline(this); } - this.state = 5146; - this.any_name(); - this.state = 5147; - this.match(PostgreSqlParser.KW_USING); - this.state = 5148; - this.name(); - this.state = 5150; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 460, this.context) ) { - case 1: - { - this.state = 5149; - this.opt_drop_behavior(); - } - break; + else { + this.errorHandler.reportMatch(this); + this.consume(); } + this.state = 3860; + this.any_name(); } break; - case 30: - this.enterOuterAlt(localContext, 30); + case PostgreSqlParser.KW_TEXT: + this.enterOuterAlt(localContext, 4); { - this.state = 5152; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5153; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 5154; - this.match(PostgreSqlParser.KW_FAMILY); - this.state = 5156; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 461, this.context) ) { - case 1: - { - this.state = 5155; - this.opt_if_exists(); - } - break; + this.state = 3861; + this.match(PostgreSqlParser.KW_TEXT); + this.state = 3862; + this.match(PostgreSqlParser.KW_SEARCH); + this.state = 3863; + _la = this.tokenStream.LA(1); + if(!(_la === 163 || _la === 185 || _la === 283 || _la === 353)) { + this.errorHandler.recoverInline(this); } - this.state = 5158; - this.any_name(); - this.state = 5159; - this.match(PostgreSqlParser.KW_USING); - this.state = 5160; - this.name(); - this.state = 5162; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 462, this.context) ) { - case 1: - { - this.state = 5161; - this.opt_drop_behavior(); - } - break; + else { + this.errorHandler.reportMatch(this); + this.consume(); } + this.state = 3864; + this.any_name(); } break; - case 31: - this.enterOuterAlt(localContext, 31); + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public object_type_name(): Object_type_nameContext { + let localContext = new Object_type_nameContext(this.context, this.state); + this.enterRule(localContext, 312, PostgreSqlParser.RULE_object_type_name); + let _la: number; + try { + this.state = 3891; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_FOREIGN: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + this.enterOuterAlt(localContext, 1); { - this.state = 5164; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5165; - this.match(PostgreSqlParser.KW_OWNED); - this.state = 5166; - this.match(PostgreSqlParser.KW_BY); - this.state = 5167; - this.role_list(); - this.state = 5169; + this.state = 3883; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 463, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_EVENT: { - this.state = 5168; - this.opt_drop_behavior(); + this.state = 3867; + this.match(PostgreSqlParser.KW_EVENT); + this.state = 3868; + this.match(PostgreSqlParser.KW_TRIGGER); } break; - } - } - break; - case 32: - this.enterOuterAlt(localContext, 32); - { - this.state = 5171; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5172; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 5174; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 464, this.context) ) { - case 1: + case PostgreSqlParser.KW_ACCESS: { - this.state = 5173; - this.opt_if_exists(); + this.state = 3869; + this.match(PostgreSqlParser.KW_ACCESS); + this.state = 3870; + this.match(PostgreSqlParser.KW_METHOD); } break; - } - this.state = 5176; - this.view_nameList(); - this.state = 5178; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 465, this.context) ) { - case 1: + case PostgreSqlParser.KW_EXTENSION: { - this.state = 5177; - this.opt_drop_behavior(); + this.state = 3871; + this.match(PostgreSqlParser.KW_EXTENSION); } break; - } - } - break; - case 33: - this.enterOuterAlt(localContext, 33); - { - this.state = 5180; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5181; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 5183; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 466, this.context) ) { - case 1: + case PostgreSqlParser.KW_PUBLICATION: { - this.state = 5182; - this.opt_if_exists(); + this.state = 3872; + this.match(PostgreSqlParser.KW_PUBLICATION); } break; - } - this.state = 5185; - this.name(); - this.state = 5187; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 467, this.context) ) { - case 1: + case PostgreSqlParser.KW_SERVER: { - this.state = 5186; - this.opt_drop_behavior(); + this.state = 3873; + this.match(PostgreSqlParser.KW_SERVER); } break; - } - } - break; - case 34: - this.enterOuterAlt(localContext, 34); - { - this.state = 5189; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5190; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 5192; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 468, this.context) ) { - case 1: + case PostgreSqlParser.KW_ROLE: { - this.state = 5191; - this.opt_if_exists(); + this.state = 3874; + this.match(PostgreSqlParser.KW_ROLE); } break; - } - this.state = 5194; - this.tablespace_name(); - } - break; - case 35: - this.enterOuterAlt(localContext, 35); - { - this.state = 5195; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5196; - this.match(PostgreSqlParser.KW_TRANSFORM); - this.state = 5198; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 220) { + case PostgreSqlParser.KW_SUBSCRIPTION: { - this.state = 5197; - this.opt_if_exists(); + this.state = 3875; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); } - } - - this.state = 5200; - this.match(PostgreSqlParser.KW_FOR); - this.state = 5201; - this.typename(); - this.state = 5202; - this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 5203; - this.name(); - this.state = 5205; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 470, this.context) ) { - case 1: + break; + case PostgreSqlParser.KW_FOREIGN: { - this.state = 5204; - this.opt_drop_behavior(); + this.state = 3876; + this.match(PostgreSqlParser.KW_FOREIGN); + this.state = 3877; + this.match(PostgreSqlParser.KW_DATA); + this.state = 3878; + this.match(PostgreSqlParser.KW_WRAPPER); } break; - } - } - break; - case 36: - this.enterOuterAlt(localContext, 36); - { - this.state = 5207; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5208; - _la = this.tokenStream.LA(1); - if(!(_la === 66 || _la === 99 || _la === 318)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 5210; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 471, this.context) ) { - case 1: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_PROCEDURAL: { - this.state = 5209; - this.opt_if_exists(); + this.state = 3880; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 295) { + { + this.state = 3879; + this.match(PostgreSqlParser.KW_PROCEDURAL); + } + } + + this.state = 3882; + this.match(PostgreSqlParser.KW_LANGUAGE); } break; + default: + throw new antlr.NoViableAltException(this); } - this.state = 5212; - this.role_list(); + this.state = 3885; + this.colid(); } break; - case 37: - this.enterOuterAlt(localContext, 37); + case PostgreSqlParser.KW_SCHEMA: + this.enterOuterAlt(localContext, 2); { - this.state = 5213; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5214; - this.match(PostgreSqlParser.KW_USER); - this.state = 5215; - this.match(PostgreSqlParser.KW_MAPPING); - this.state = 5217; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 220) { - { - this.state = 5216; - this.opt_if_exists(); - } - } - - this.state = 5219; - this.match(PostgreSqlParser.KW_FOR); - this.state = 5220; - this.auth_ident(); - this.state = 5221; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 5222; - this.name(); + this.state = 3886; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 3887; + this.schema_name(); } break; - case 38: - this.enterOuterAlt(localContext, 38); + case PostgreSqlParser.KW_DATABASE: + this.enterOuterAlt(localContext, 3); { - this.state = 5224; - this.match(PostgreSqlParser.KW_DROP); - this.state = 5225; + this.state = 3888; this.match(PostgreSqlParser.KW_DATABASE); - this.state = 5227; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 473, this.context) ) { - case 1: - { - this.state = 5226; - this.opt_if_exists(); - } - break; - } - this.state = 5229; + this.state = 3889; this.database_name(); - this.state = 5237; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 475, this.context) ) { - case 1: - { - this.state = 5231; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 105) { - { - this.state = 5230; - this.opt_with(); - } - } - - this.state = 5233; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 5234; - this.drop_option_list(); - this.state = 5235; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; } + break; + case PostgreSqlParser.KW_TABLESPACE: + this.enterOuterAlt(localContext, 4); + { + this.state = 3890; + this.opttablespace(); } break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -23867,28 +21229,28 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public view_nameList(): View_nameListContext { - let localContext = new View_nameListContext(this.context, this.state); - this.enterRule(localContext, 544, PostgreSqlParser.RULE_view_nameList); + public any_name_list(): Any_name_listContext { + let localContext = new Any_name_listContext(this.context, this.state); + this.enterRule(localContext, 314, PostgreSqlParser.RULE_any_name_list); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 5241; - this.view_name(); - this.state = 5246; + this.state = 3893; + this.any_name(); + this.state = 3898; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 5242; + this.state = 3894; this.match(PostgreSqlParser.COMMA); - this.state = 5243; - this.view_name(); + this.state = 3895; + this.any_name(); } } - this.state = 5248; + this.state = 3900; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -23908,121 +21270,24 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public object_type_any_name(): Object_type_any_nameContext { - let localContext = new Object_type_any_nameContext(this.context, this.state); - this.enterRule(localContext, 546, PostgreSqlParser.RULE_object_type_any_name); - let _la: number; + public any_name(): Any_nameContext { + let localContext = new Any_nameContext(this.context, this.state); + this.enterRule(localContext, 316, PostgreSqlParser.RULE_any_name); try { - this.state = 5273; + this.enterOuterAlt(localContext, 1); + { + this.state = 3901; + this.colid(); + this.state = 3903; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_FOREIGN: - case PostgreSqlParser.KW_TABLE: - this.enterOuterAlt(localContext, 1); - { - this.state = 5250; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 63) { - { - this.state = 5249; - this.match(PostgreSqlParser.KW_FOREIGN); - } - } - - this.state = 5252; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 5253; - this.table_name(); - } - break; - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_VIEW: - this.enterOuterAlt(localContext, 2); - { - this.state = 5255; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 259) { - { - this.state = 5254; - this.match(PostgreSqlParser.KW_MATERIALIZED); - } - } - - this.state = 5257; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 5258; - this.view_name(); - } - break; - case PostgreSqlParser.KW_INDEX: - this.enterOuterAlt(localContext, 3); - { - this.state = 5259; - this.match(PostgreSqlParser.KW_INDEX); - this.state = 5260; - this.any_name(); - } - break; - case PostgreSqlParser.KW_COLLATION: - this.enterOuterAlt(localContext, 4); - { - this.state = 5261; - this.match(PostgreSqlParser.KW_COLLATION); - this.state = 5262; - this.any_name(); - } - break; - case PostgreSqlParser.KW_CONVERSION: - this.enterOuterAlt(localContext, 5); - { - this.state = 5263; - this.match(PostgreSqlParser.KW_CONVERSION); - this.state = 5264; - this.any_name(); - } - break; - case PostgreSqlParser.KW_STATISTICS: - this.enterOuterAlt(localContext, 6); - { - this.state = 5265; - this.match(PostgreSqlParser.KW_STATISTICS); - this.state = 5266; - this.any_name(); - } - break; - case PostgreSqlParser.KW_SEQUENCE: - this.enterOuterAlt(localContext, 7); - { - this.state = 5267; - this.match(PostgreSqlParser.KW_SEQUENCE); - this.state = 5268; - this.any_name(); - } - break; - case PostgreSqlParser.KW_TEXT: - this.enterOuterAlt(localContext, 8); + switch (this.interpreter.adaptivePredict(this.tokenStream, 460, this.context) ) { + case 1: { - this.state = 5269; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 5270; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 5271; - _la = this.tokenStream.LA(1); - if(!(_la === 163 || _la === 185 || _la === 283 || _la === 353)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 5272; - this.any_name(); + this.state = 3902; + this.attrs(); } break; - default: - throw new antlr.NoViableAltException(this); + } } } catch (re) { @@ -24039,380 +21304,34 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public object_type_name(): Object_type_nameContext { - let localContext = new Object_type_nameContext(this.context, this.state); - this.enterRule(localContext, 548, PostgreSqlParser.RULE_object_type_name); - let _la: number; + public attrs(): AttrsContext { + let localContext = new AttrsContext(this.context, this.state); + this.enterRule(localContext, 318, PostgreSqlParser.RULE_attrs); try { - this.state = 5306; + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 3907; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_ACCESS: - this.enterOuterAlt(localContext, 1); - { - { - this.state = 5275; - this.match(PostgreSqlParser.KW_ACCESS); - this.state = 5276; - this.match(PostgreSqlParser.KW_METHOD); - this.state = 5277; - this.name(); - } + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 3905; + this.match(PostgreSqlParser.DOT); + this.state = 3906; + this.collabel(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); } - break; - case PostgreSqlParser.KW_EVENT: - this.enterOuterAlt(localContext, 2); - { - { - this.state = 5278; - this.match(PostgreSqlParser.KW_EVENT); - this.state = 5279; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 5280; - this.name(); - } - } - break; - case PostgreSqlParser.KW_EXTENSION: - this.enterOuterAlt(localContext, 3); - { - { - this.state = 5281; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 5282; - this.name(); - } - } - break; - case PostgreSqlParser.KW_FOREIGN: - this.enterOuterAlt(localContext, 4); - { - { - this.state = 5283; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 5284; - this.match(PostgreSqlParser.KW_DATA); - this.state = 5285; - this.match(PostgreSqlParser.KW_WRAPPER); - this.state = 5286; - this.name(); - } - } - break; - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_PROCEDURAL: - this.enterOuterAlt(localContext, 5); - { - { - this.state = 5288; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 295) { - { - this.state = 5287; - this.opt_procedural(); - } - } - - this.state = 5290; - this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 5291; - this.name(); - } - } - break; - case PostgreSqlParser.KW_PUBLICATION: - this.enterOuterAlt(localContext, 6); - { - { - this.state = 5292; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 5293; - this.name(); - } - } - break; - case PostgreSqlParser.KW_SCHEMA: - this.enterOuterAlt(localContext, 7); - { - { - this.state = 5294; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 5295; - this.schema_name(); - } - } - break; - case PostgreSqlParser.KW_SERVER: - this.enterOuterAlt(localContext, 8); - { - { - this.state = 5296; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 5297; - this.name(); - } - } - break; - case PostgreSqlParser.KW_DATABASE: - this.enterOuterAlt(localContext, 9); - { - { - this.state = 5298; - this.match(PostgreSqlParser.KW_DATABASE); - this.state = 5299; - this.database_name(); - } - } - break; - case PostgreSqlParser.KW_ROLE: - this.enterOuterAlt(localContext, 10); - { - { - this.state = 5300; - this.match(PostgreSqlParser.KW_ROLE); - this.state = 5301; - this.name(); - } - } - break; - case PostgreSqlParser.KW_SUBSCRIPTION: - this.enterOuterAlt(localContext, 11); - { - { - this.state = 5302; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 5303; - this.name(); - } - } - break; - case PostgreSqlParser.KW_TABLESPACE: - this.enterOuterAlt(localContext, 12); - { - { - this.state = 5304; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 5305; - this.tablespace_name(); - } - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public object_type_name_on_any_name(): Object_type_name_on_any_nameContext { - let localContext = new Object_type_name_on_any_nameContext(this.context, this.state); - this.enterRule(localContext, 550, PostgreSqlParser.RULE_object_type_name_on_any_name); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5308; - _la = this.tokenStream.LA(1); - if(!(_la === 321 || _la === 357 || _la === 445)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public any_name_list(): Any_name_listContext { - let localContext = new Any_name_listContext(this.context, this.state); - this.enterRule(localContext, 552, PostgreSqlParser.RULE_any_name_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5310; - this.any_name(); - this.state = 5315; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 5311; - this.match(PostgreSqlParser.COMMA); - this.state = 5312; - this.any_name(); - } - } - this.state = 5317; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public relation_column_name(): Relation_column_nameContext { - let localContext = new Relation_column_nameContext(this.context, this.state); - this.enterRule(localContext, 554, PostgreSqlParser.RULE_relation_column_name); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5318; - this.relation_name(); - this.state = 5319; - this.match(PostgreSqlParser.DOT); - this.state = 5320; - this.column_name(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public relation_name(): Relation_nameContext { - let localContext = new Relation_nameContext(this.context, this.state); - this.enterRule(localContext, 556, PostgreSqlParser.RULE_relation_name); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5322; - this.colid(); - this.state = 5324; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 484, this.context) ) { - case 1: - { - this.state = 5323; - this.attrs(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public any_name(): Any_nameContext { - let localContext = new Any_nameContext(this.context, this.state); - this.enterRule(localContext, 558, PostgreSqlParser.RULE_any_name); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5326; - this.colid(); - this.state = 5328; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 485, this.context) ) { - case 1: - { - this.state = 5327; - this.attrs(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public attrs(): AttrsContext { - let localContext = new AttrsContext(this.context, this.state); - this.enterRule(localContext, 560, PostgreSqlParser.RULE_attrs); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 5332; - this.errorHandler.sync(this); - alternative = 1; - do { - switch (alternative) { - case 1: - { - { - this.state = 5330; - this.match(PostgreSqlParser.DOT); - this.state = 5331; - this.attr_name(); - } - } - break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 5334; + this.state = 3909; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 486, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 461, this.context); } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); } } @@ -24430,90 +21349,49 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public type_name_list(): Type_name_listContext { - let localContext = new Type_name_listContext(this.context, this.state); - this.enterRule(localContext, 562, PostgreSqlParser.RULE_type_name_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5336; - this.typename(); - this.state = 5341; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 5337; - this.match(PostgreSqlParser.COMMA); - this.state = 5338; - this.typename(); - } - } - this.state = 5343; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public truncatestmt(): TruncatestmtContext { let localContext = new TruncatestmtContext(this.context, this.state); - this.enterRule(localContext, 564, PostgreSqlParser.RULE_truncatestmt); + this.enterRule(localContext, 320, PostgreSqlParser.RULE_truncatestmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 5344; + this.state = 3911; this.match(PostgreSqlParser.KW_TRUNCATE); - this.state = 5346; + this.state = 3913; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 92) { { - this.state = 5345; + this.state = 3912; this.match(PostgreSqlParser.KW_TABLE); } } - this.state = 5348; + this.state = 3915; this.truncate_table(); - this.state = 5353; + this.state = 3920; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 5349; + this.state = 3916; this.match(PostgreSqlParser.COMMA); - this.state = 5350; + this.state = 3917; this.truncate_table(); } } - this.state = 5355; + this.state = 3922; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 5358; + this.state = 3925; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 490, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 464, this.context) ) { case 1: { - this.state = 5356; + this.state = 3923; _la = this.tokenStream.LA(1); if(!(_la === 167 || _la === 314)) { this.errorHandler.recoverInline(this); @@ -24522,17 +21400,17 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 5357; + this.state = 3924; this.match(PostgreSqlParser.KW_IDENTITY); } break; } - this.state = 5361; + this.state = 3928; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 491, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 465, this.context) ) { case 1: { - this.state = 5360; + this.state = 3927; this.opt_drop_behavior(); } break; @@ -24555,29 +21433,29 @@ export class PostgreSqlParser extends SQLParserBase { } public truncate_table(): Truncate_tableContext { let localContext = new Truncate_tableContext(this.context, this.state); - this.enterRule(localContext, 566, PostgreSqlParser.RULE_truncate_table); + this.enterRule(localContext, 322, PostgreSqlParser.RULE_truncate_table); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 5364; + this.state = 3931; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 81) { { - this.state = 5363; + this.state = 3930; this.match(PostgreSqlParser.KW_ONLY); } } - this.state = 5366; + this.state = 3933; this.table_name(); - this.state = 5368; + this.state = 3935; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 9) { { - this.state = 5367; + this.state = 3934; this.match(PostgreSqlParser.STAR); } } @@ -24600,448 +21478,250 @@ export class PostgreSqlParser extends SQLParserBase { } public commentstmt(): CommentstmtContext { let localContext = new CommentstmtContext(this.context, this.state); - this.enterRule(localContext, 568, PostgreSqlParser.RULE_commentstmt); + this.enterRule(localContext, 324, PostgreSqlParser.RULE_commentstmt); + let _la: number; try { - this.state = 5535; + this.enterOuterAlt(localContext, 1); + { + this.state = 3937; + this.match(PostgreSqlParser.KW_COMMENT); + this.state = 3938; + this.match(PostgreSqlParser.KW_ON); + this.state = 3997; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 495, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 471, this.context) ) { case 1: - this.enterOuterAlt(localContext, 1); { - this.state = 5370; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5371; - this.match(PostgreSqlParser.KW_ON); - this.state = 5372; + this.state = 3939; this.object_type_any_name(); - this.state = 5373; - this.match(PostgreSqlParser.KW_IS); - this.state = 5374; - this.comment_text(); } break; case 2: - this.enterOuterAlt(localContext, 2); { - this.state = 5376; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5377; - this.match(PostgreSqlParser.KW_ON); - this.state = 5378; - this.match(PostgreSqlParser.KW_COLUMN); - this.state = 5379; - this.relation_column_name(); - this.state = 5380; - this.match(PostgreSqlParser.KW_IS); - this.state = 5381; - this.comment_text(); + this.state = 3940; + this.object_type_name(); } break; case 3: - this.enterOuterAlt(localContext, 3); { - this.state = 5383; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5384; - this.match(PostgreSqlParser.KW_ON); - this.state = 5385; - this.object_type_name(); - this.state = 5386; - this.match(PostgreSqlParser.KW_IS); - this.state = 5387; - this.comment_text(); + this.state = 3941; + this.match(PostgreSqlParser.KW_COLUMN); + { + this.state = 3942; + this.colid(); + this.state = 3944; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 468, this.context) ) { + case 1: + { + this.state = 3943; + this.attrs(); + } + break; + } + } + this.state = 3946; + this.match(PostgreSqlParser.DOT); + this.state = 3947; + this.column_name(); } break; case 4: - this.enterOuterAlt(localContext, 4); { - this.state = 5389; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5390; - this.match(PostgreSqlParser.KW_ON); - this.state = 5391; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 5392; - this.typename(); - this.state = 5393; - this.match(PostgreSqlParser.KW_IS); - this.state = 5394; - this.comment_text(); + this.state = 3949; + _la = this.tokenStream.LA(1); + if(!(_la === 189 || _la === 360)) { + this.errorHandler.recoverInline(this); } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 5396; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5397; - this.match(PostgreSqlParser.KW_ON); - this.state = 5398; - this.match(PostgreSqlParser.KW_DOMAIN); - this.state = 5399; + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3950; this.typename(); - this.state = 5400; - this.match(PostgreSqlParser.KW_IS); - this.state = 5401; - this.comment_text(); } break; - case 6: - this.enterOuterAlt(localContext, 6); + case 5: { - this.state = 5403; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5404; - this.match(PostgreSqlParser.KW_ON); - this.state = 5405; + this.state = 3951; this.match(PostgreSqlParser.KW_AGGREGATE); - this.state = 5406; + this.state = 3952; this.aggregate_with_argtypes(); - this.state = 5407; - this.match(PostgreSqlParser.KW_IS); - this.state = 5408; - this.comment_text(); } break; - case 7: - this.enterOuterAlt(localContext, 7); + case 6: { - this.state = 5410; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5411; - this.match(PostgreSqlParser.KW_ON); - this.state = 5412; + this.state = 3953; this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 5413; + this.state = 3954; this.function_with_argtypes(); - this.state = 5414; - this.match(PostgreSqlParser.KW_IS); - this.state = 5415; - this.comment_text(); } break; - case 8: - this.enterOuterAlt(localContext, 8); + case 7: { - this.state = 5417; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5418; - this.match(PostgreSqlParser.KW_ON); - this.state = 5419; + this.state = 3955; this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 5420; + this.state = 3956; this.operator_with_argtypes(); - this.state = 5421; - this.match(PostgreSqlParser.KW_IS); - this.state = 5422; - this.comment_text(); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 5424; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5425; - this.match(PostgreSqlParser.KW_ON); - this.state = 5426; - this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 5427; - this.name(); - this.state = 5428; - this.match(PostgreSqlParser.KW_ON); - this.state = 5429; - this.table_name(); - this.state = 5430; - this.match(PostgreSqlParser.KW_IS); - this.state = 5431; - this.comment_text(); } break; - case 10: - this.enterOuterAlt(localContext, 10); + case 8: { - this.state = 5433; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5434; - this.match(PostgreSqlParser.KW_ON); - this.state = 5435; + this.state = 3957; this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 5436; - this.name(); - this.state = 5437; + this.state = 3958; + this.colid(); + this.state = 3959; this.match(PostgreSqlParser.KW_ON); - this.state = 5439; + this.state = 3965; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 494, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 470, this.context) ) { case 1: { - this.state = 5438; - this.match(PostgreSqlParser.KW_DOMAIN); + this.state = 3960; + this.table_name(); + } + break; + case 2: + { + { + this.state = 3962; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 469, this.context) ) { + case 1: + { + this.state = 3961; + this.match(PostgreSqlParser.KW_DOMAIN); + } + break; + } + this.state = 3964; + this.any_name(); + } } break; } - this.state = 5441; - this.any_name(); - this.state = 5442; - this.match(PostgreSqlParser.KW_IS); - this.state = 5443; - this.comment_text(); } break; - case 11: - this.enterOuterAlt(localContext, 11); + case 9: { - this.state = 5445; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5446; - this.match(PostgreSqlParser.KW_ON); - this.state = 5447; - this.match(PostgreSqlParser.KW_POLICY); - this.state = 5448; - this.name(); - this.state = 5449; + this.state = 3967; + _la = this.tokenStream.LA(1); + if(!(_la === 321 || _la === 357 || _la === 445)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3968; + this.colid(); + this.state = 3969; this.match(PostgreSqlParser.KW_ON); - this.state = 5450; + this.state = 3970; this.any_name(); - this.state = 5451; - this.match(PostgreSqlParser.KW_IS); - this.state = 5452; - this.comment_text(); } break; - case 12: - this.enterOuterAlt(localContext, 12); + case 10: { - this.state = 5454; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5455; - this.match(PostgreSqlParser.KW_ON); - this.state = 5456; - this.match(PostgreSqlParser.KW_RULE); - this.state = 5457; - this.name(); - this.state = 5458; - this.match(PostgreSqlParser.KW_ON); - this.state = 5459; - this.any_name(); - this.state = 5460; - this.match(PostgreSqlParser.KW_IS); - this.state = 5461; - this.comment_text(); + this.state = 3972; + this.match(PostgreSqlParser.KW_PROCEDURE); + this.state = 3973; + this.procedure_with_argtypes(); } break; - case 13: - this.enterOuterAlt(localContext, 13); + case 11: { - this.state = 5463; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5464; - this.match(PostgreSqlParser.KW_ON); - this.state = 5465; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 5466; - this.name(); - this.state = 5467; - this.match(PostgreSqlParser.KW_ON); - this.state = 5468; - this.any_name(); - this.state = 5469; - this.match(PostgreSqlParser.KW_IS); - this.state = 5470; - this.comment_text(); - } - break; - case 14: - this.enterOuterAlt(localContext, 14); - { - this.state = 5472; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5473; - this.match(PostgreSqlParser.KW_ON); - this.state = 5474; - this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 5475; - this.procedure_with_argtypes(); - this.state = 5476; - this.match(PostgreSqlParser.KW_IS); - this.state = 5477; - this.comment_text(); - } - break; - case 15: - this.enterOuterAlt(localContext, 15); - { - this.state = 5479; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5480; - this.match(PostgreSqlParser.KW_ON); - this.state = 5481; + this.state = 3974; this.match(PostgreSqlParser.KW_ROUTINE); - this.state = 5482; + this.state = 3975; this.routine_with_argtypes(); - this.state = 5483; - this.match(PostgreSqlParser.KW_IS); - this.state = 5484; - this.comment_text(); } break; - case 16: - this.enterOuterAlt(localContext, 16); + case 12: { - this.state = 5486; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5487; - this.match(PostgreSqlParser.KW_ON); - this.state = 5488; + this.state = 3976; this.match(PostgreSqlParser.KW_TRANSFORM); - this.state = 5489; + this.state = 3977; this.match(PostgreSqlParser.KW_FOR); - this.state = 5490; + this.state = 3978; this.typename(); - this.state = 5491; + this.state = 3979; this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 5492; - this.name(); - this.state = 5493; - this.match(PostgreSqlParser.KW_IS); - this.state = 5494; - this.comment_text(); + this.state = 3980; + this.colid(); } break; - case 17: - this.enterOuterAlt(localContext, 17); + case 13: { - this.state = 5496; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5497; - this.match(PostgreSqlParser.KW_ON); - this.state = 5498; + this.state = 3982; this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 5499; - this.match(PostgreSqlParser.KW_CLASS); - this.state = 5500; - this.any_name(); - this.state = 5501; - this.match(PostgreSqlParser.KW_USING); - this.state = 5502; - this.name(); - this.state = 5503; - this.match(PostgreSqlParser.KW_IS); - this.state = 5504; - this.comment_text(); + this.state = 3983; + _la = this.tokenStream.LA(1); + if(!(_la === 156 || _la === 206)) { + this.errorHandler.recoverInline(this); } - break; - case 18: - this.enterOuterAlt(localContext, 18); - { - this.state = 5506; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5507; - this.match(PostgreSqlParser.KW_ON); - this.state = 5508; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 5509; - this.match(PostgreSqlParser.KW_FAMILY); - this.state = 5510; + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 3984; this.any_name(); - this.state = 5511; - this.match(PostgreSqlParser.KW_USING); - this.state = 5512; - this.name(); - this.state = 5513; - this.match(PostgreSqlParser.KW_IS); - this.state = 5514; - this.comment_text(); + this.state = 3985; + this.table_access_method_clause(); } break; - case 19: - this.enterOuterAlt(localContext, 19); + case 14: { - this.state = 5516; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5517; - this.match(PostgreSqlParser.KW_ON); - this.state = 5518; + this.state = 3987; this.match(PostgreSqlParser.KW_LARGE); - this.state = 5519; + this.state = 3988; this.match(PostgreSqlParser.KW_OBJECT); - this.state = 5520; + this.state = 3989; this.numericonly(); - this.state = 5521; - this.match(PostgreSqlParser.KW_IS); - this.state = 5522; - this.comment_text(); } break; - case 20: - this.enterOuterAlt(localContext, 20); + case 15: { - this.state = 5524; - this.match(PostgreSqlParser.KW_COMMENT); - this.state = 5525; - this.match(PostgreSqlParser.KW_ON); - this.state = 5526; + this.state = 3990; this.match(PostgreSqlParser.KW_CAST); - this.state = 5527; + this.state = 3991; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 5528; + this.state = 3992; this.typename(); - this.state = 5529; + this.state = 3993; this.match(PostgreSqlParser.KW_AS); - this.state = 5530; + this.state = 3994; this.typename(); - this.state = 5531; + this.state = 3995; this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 5532; - this.match(PostgreSqlParser.KW_IS); - this.state = 5533; - this.comment_text(); } break; } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public comment_text(): Comment_textContext { - let localContext = new Comment_textContext(this.context, this.state); - this.enterRule(localContext, 570, PostgreSqlParser.RULE_comment_text); - try { - this.state = 5539; + this.state = 3999; + this.match(PostgreSqlParser.KW_IS); + this.state = 4002; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.StringConstant: case PostgreSqlParser.UnicodeEscapeStringConstant: case PostgreSqlParser.BeginDollarStringConstant: case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); { - this.state = 5537; + this.state = 4000; this.sconst(); } break; case PostgreSqlParser.KW_NULL: - this.enterOuterAlt(localContext, 2); { - this.state = 5538; + this.state = 4001; this.match(PostgreSqlParser.KW_NULL); } break; default: throw new antlr.NoViableAltException(this); } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -25059,369 +21739,134 @@ export class PostgreSqlParser extends SQLParserBase { } public seclabelstmt(): SeclabelstmtContext { let localContext = new SeclabelstmtContext(this.context, this.state); - this.enterRule(localContext, 572, PostgreSqlParser.RULE_seclabelstmt); + this.enterRule(localContext, 326, PostgreSqlParser.RULE_seclabelstmt); let _la: number; try { - this.state = 5650; + this.enterOuterAlt(localContext, 1); + { + this.state = 4004; + this.match(PostgreSqlParser.KW_SECURITY); + this.state = 4005; + this.match(PostgreSqlParser.KW_LABEL); + this.state = 4008; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 507, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); + _la = this.tokenStream.LA(1); + if (_la === 62) { { - this.state = 5541; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 5542; - this.match(PostgreSqlParser.KW_LABEL); - this.state = 5544; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 5543; - this.opt_provider(); - } + this.state = 4006; + this.match(PostgreSqlParser.KW_FOR); + this.state = 4007; + this.nonreservedword_or_sconst(); } + } - this.state = 5546; - this.match(PostgreSqlParser.KW_ON); - this.state = 5547; - this.match(PostgreSqlParser.KW_COLUMN); - this.state = 5548; - this.column_name(); - this.state = 5549; - this.match(PostgreSqlParser.KW_IS); - this.state = 5550; - this.security_label(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); + this.state = 4010; + this.match(PostgreSqlParser.KW_ON); + this.state = 4028; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 474, this.context) ) { + case 1: { - this.state = 5552; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 5553; - this.match(PostgreSqlParser.KW_LABEL); - this.state = 5555; - this.errorHandler.sync(this); + this.state = 4011; _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 5554; - this.opt_provider(); - } - } - - this.state = 5557; - this.match(PostgreSqlParser.KW_ON); - this.state = 5558; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 5559; - this.typename(); - this.state = 5560; - this.match(PostgreSqlParser.KW_IS); - this.state = 5561; - this.security_label(); + if(!(_la === 189 || _la === 360)) { + this.errorHandler.recoverInline(this); } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 5563; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 5564; - this.match(PostgreSqlParser.KW_LABEL); - this.state = 5566; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 5565; - this.opt_provider(); - } + else { + this.errorHandler.reportMatch(this); + this.consume(); } - - this.state = 5568; - this.match(PostgreSqlParser.KW_ON); - this.state = 5569; - this.match(PostgreSqlParser.KW_DOMAIN); - this.state = 5570; + this.state = 4012; this.typename(); - this.state = 5571; - this.match(PostgreSqlParser.KW_IS); - this.state = 5572; - this.security_label(); } break; - case 4: - this.enterOuterAlt(localContext, 4); + case 2: { - this.state = 5574; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 5575; - this.match(PostgreSqlParser.KW_LABEL); - this.state = 5577; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 5576; - this.opt_provider(); - } - } - - this.state = 5579; - this.match(PostgreSqlParser.KW_ON); - this.state = 5580; + this.state = 4013; this.match(PostgreSqlParser.KW_AGGREGATE); - this.state = 5581; + this.state = 4014; this.aggregate_with_argtypes(); - this.state = 5582; - this.match(PostgreSqlParser.KW_IS); - this.state = 5583; - this.security_label(); } break; - case 5: - this.enterOuterAlt(localContext, 5); + case 3: { - this.state = 5585; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 5586; - this.match(PostgreSqlParser.KW_LABEL); - this.state = 5588; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 5587; - this.opt_provider(); - } + this.state = 4015; + this.match(PostgreSqlParser.KW_COLUMN); + this.state = 4016; + this.column_name(); } - - this.state = 5590; - this.match(PostgreSqlParser.KW_ON); - this.state = 5591; + break; + case 4: + { + this.state = 4017; this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 5592; + this.state = 4018; this.function_with_argtypes(); - this.state = 5593; - this.match(PostgreSqlParser.KW_IS); - this.state = 5594; - this.security_label(); } break; - case 6: - this.enterOuterAlt(localContext, 6); + case 5: { - this.state = 5596; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 5597; - this.match(PostgreSqlParser.KW_LABEL); - this.state = 5599; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 5598; - this.opt_provider(); - } - } - - this.state = 5601; - this.match(PostgreSqlParser.KW_ON); - this.state = 5602; + this.state = 4019; this.match(PostgreSqlParser.KW_LARGE); - this.state = 5603; + this.state = 4020; this.match(PostgreSqlParser.KW_OBJECT); - this.state = 5604; + this.state = 4021; this.numericonly(); - this.state = 5605; - this.match(PostgreSqlParser.KW_IS); - this.state = 5606; - this.security_label(); } break; - case 7: - this.enterOuterAlt(localContext, 7); + case 6: { - this.state = 5608; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 5609; - this.match(PostgreSqlParser.KW_LABEL); - this.state = 5611; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 5610; - this.opt_provider(); - } - } - - this.state = 5613; - this.match(PostgreSqlParser.KW_ON); - this.state = 5614; + this.state = 4022; this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 5615; + this.state = 4023; this.procedure_with_argtypes(); - this.state = 5616; - this.match(PostgreSqlParser.KW_IS); - this.state = 5617; - this.security_label(); } break; - case 8: - this.enterOuterAlt(localContext, 8); + case 7: { - this.state = 5619; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 5620; - this.match(PostgreSqlParser.KW_LABEL); - this.state = 5622; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 5621; - this.opt_provider(); - } - } - - this.state = 5624; - this.match(PostgreSqlParser.KW_ON); - this.state = 5625; + this.state = 4024; this.match(PostgreSqlParser.KW_ROUTINE); - this.state = 5626; + this.state = 4025; this.routine_with_argtypes(); - this.state = 5627; - this.match(PostgreSqlParser.KW_IS); - this.state = 5628; - this.security_label(); } break; - case 9: - this.enterOuterAlt(localContext, 9); + case 8: { - this.state = 5630; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 5631; - this.match(PostgreSqlParser.KW_LABEL); - this.state = 5633; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 5632; - this.opt_provider(); - } - } - - this.state = 5635; - this.match(PostgreSqlParser.KW_ON); - this.state = 5636; + this.state = 4026; this.object_type_any_name(); - this.state = 5637; - this.match(PostgreSqlParser.KW_IS); - this.state = 5638; - this.security_label(); } break; - case 10: - this.enterOuterAlt(localContext, 10); + case 9: { - this.state = 5640; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 5641; - this.match(PostgreSqlParser.KW_LABEL); - this.state = 5643; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 5642; - this.opt_provider(); - } - } - - this.state = 5645; - this.match(PostgreSqlParser.KW_ON); - this.state = 5646; + this.state = 4027; this.object_type_name(); - this.state = 5647; - this.match(PostgreSqlParser.KW_IS); - this.state = 5648; - this.security_label(); } break; } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_provider(): Opt_providerContext { - let localContext = new Opt_providerContext(this.context, this.state); - this.enterRule(localContext, 574, PostgreSqlParser.RULE_opt_provider); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5652; - this.match(PostgreSqlParser.KW_FOR); - this.state = 5653; - this.nonreservedword_or_sconst(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public security_label(): Security_labelContext { - let localContext = new Security_labelContext(this.context, this.state); - this.enterRule(localContext, 576, PostgreSqlParser.RULE_security_label); - try { - this.state = 5657; + this.state = 4030; + this.match(PostgreSqlParser.KW_IS); + this.state = 4033; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.StringConstant: case PostgreSqlParser.UnicodeEscapeStringConstant: case PostgreSqlParser.BeginDollarStringConstant: case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); { - this.state = 5655; + this.state = 4031; this.sconst(); } break; case PostgreSqlParser.KW_NULL: - this.enterOuterAlt(localContext, 2); { - this.state = 5656; + this.state = 4032; this.match(PostgreSqlParser.KW_NULL); } break; default: throw new antlr.NoViableAltException(this); } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -25439,31 +21884,22 @@ export class PostgreSqlParser extends SQLParserBase { } public fetchstmt(): FetchstmtContext { let localContext = new FetchstmtContext(this.context, this.state); - this.enterRule(localContext, 578, PostgreSqlParser.RULE_fetchstmt); + this.enterRule(localContext, 328, PostgreSqlParser.RULE_fetchstmt); + let _la: number; try { - this.state = 5663; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_FETCH: - this.enterOuterAlt(localContext, 1); - { - this.state = 5659; - this.match(PostgreSqlParser.KW_FETCH); - this.state = 5660; - this.fetch_args(); - } - break; - case PostgreSqlParser.KW_MOVE: - this.enterOuterAlt(localContext, 2); - { - this.state = 5661; - this.match(PostgreSqlParser.KW_MOVE); - this.state = 5662; - this.fetch_args(); - } - break; - default: - throw new antlr.NoViableAltException(this); + this.enterOuterAlt(localContext, 1); + { + this.state = 4035; + _la = this.tokenStream.LA(1); + if(!(_la === 61 || _la === 265)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 4036; + this.fetch_args(); } } catch (re) { @@ -25482,304 +21918,586 @@ export class PostgreSqlParser extends SQLParserBase { } public fetch_args(): Fetch_argsContext { let localContext = new Fetch_argsContext(this.context, this.state); - this.enterRule(localContext, 580, PostgreSqlParser.RULE_fetch_args); + this.enterRule(localContext, 330, PostgreSqlParser.RULE_fetch_args); let _la: number; try { - this.state = 5750; + this.state = 4081; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 524, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 487, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 5665; - this.cursor_name(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 5666; - this.from_in(); - this.state = 5667; - this.cursor_name(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 5669; - this.match(PostgreSqlParser.KW_NEXT); - this.state = 5671; + this.state = 4039; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 64 || _la === 68) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 476, this.context) ) { + case 1: { - this.state = 5670; - this.opt_from_in(); + this.state = 4038; + _la = this.tokenStream.LA(1); + if(!(_la === 207 || _la === 249 || _la === 268 || _la === 293)) { + this.errorHandler.recoverInline(this); } - } - - this.state = 5673; - this.cursor_name(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 5674; - this.match(PostgreSqlParser.KW_PRIOR); - this.state = 5676; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 64 || _la === 68) { - { - this.state = 5675; - this.opt_from_in(); + else { + this.errorHandler.reportMatch(this); + this.consume(); } - } - - this.state = 5678; - this.cursor_name(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 5679; - this.match(PostgreSqlParser.KW_FIRST); - this.state = 5681; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 64 || _la === 68) { - { - this.state = 5680; - this.opt_from_in(); } + break; } - - this.state = 5683; - this.cursor_name(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 5684; - this.match(PostgreSqlParser.KW_LAST); - this.state = 5686; + this.state = 4042; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 64 || _la === 68) { { - this.state = 5685; - this.opt_from_in(); + this.state = 4041; + this.from_in(); } } - this.state = 5688; - this.cursor_name(); + this.state = 4044; + this.colid(); } break; - case 7: - this.enterOuterAlt(localContext, 7); + case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 5689; - this.match(PostgreSqlParser.KW_ABSOLUTE); - this.state = 5690; - this.signediconst(); - this.state = 5692; + this.state = 4046; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 64 || _la === 68) { + if (_la === 130 || _la === 307) { { - this.state = 5691; - this.opt_from_in(); + this.state = 4045; + _la = this.tokenStream.LA(1); + if(!(_la === 130 || _la === 307)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); } - } - - this.state = 5694; - this.cursor_name(); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 5696; - this.match(PostgreSqlParser.KW_RELATIVE); - this.state = 5697; - this.signediconst(); - this.state = 5699; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 64 || _la === 68) { - { - this.state = 5698; - this.opt_from_in(); } } - this.state = 5701; - this.cursor_name(); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 5703; + this.state = 4048; this.signediconst(); - this.state = 5705; + this.state = 4050; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 64 || _la === 68) { { - this.state = 5704; - this.opt_from_in(); + this.state = 4049; + this.from_in(); } } - this.state = 5707; - this.cursor_name(); + this.state = 4052; + this.colid(); } break; - case 10: - this.enterOuterAlt(localContext, 10); + case 3: + this.enterOuterAlt(localContext, 3); { - this.state = 5709; - this.match(PostgreSqlParser.KW_ALL); - this.state = 5711; + this.state = 4054; + this.match(PostgreSqlParser.KW_FORWARD); + this.state = 4056; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 64 || _la === 68) { + if (_la === 12 || _la === 13 || _la === 571) { { - this.state = 5710; - this.opt_from_in(); + this.state = 4055; + this.signediconst(); } } - this.state = 5713; - this.cursor_name(); - } - break; - case 11: - this.enterOuterAlt(localContext, 11); - { - this.state = 5714; - this.match(PostgreSqlParser.KW_FORWARD); - this.state = 5716; + this.state = 4059; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 64 || _la === 68) { { - this.state = 5715; - this.opt_from_in(); + this.state = 4058; + this.from_in(); } } - this.state = 5718; - this.cursor_name(); + this.state = 4061; + this.colid(); } break; - case 12: - this.enterOuterAlt(localContext, 12); + case 4: + this.enterOuterAlt(localContext, 4); { - this.state = 5719; - this.match(PostgreSqlParser.KW_FORWARD); - this.state = 5720; - this.signediconst(); - this.state = 5722; + this.state = 4063; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 64 || _la === 68) { + if (_la === 210) { { - this.state = 5721; - this.opt_from_in(); + this.state = 4062; + this.match(PostgreSqlParser.KW_FORWARD); } } - this.state = 5724; - this.cursor_name(); - } - break; - case 13: - this.enterOuterAlt(localContext, 13); - { - this.state = 5726; - this.match(PostgreSqlParser.KW_FORWARD); - this.state = 5727; + this.state = 4065; this.match(PostgreSqlParser.KW_ALL); - this.state = 5729; + this.state = 4067; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 64 || _la === 68) { { - this.state = 5728; - this.opt_from_in(); + this.state = 4066; + this.from_in(); } } - this.state = 5731; - this.cursor_name(); + this.state = 4069; + this.colid(); } break; - case 14: - this.enterOuterAlt(localContext, 14); + case 5: + this.enterOuterAlt(localContext, 5); { - this.state = 5732; + this.state = 4070; this.match(PostgreSqlParser.KW_BACKWARD); - this.state = 5734; + this.state = 4075; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 64 || _la === 68) { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_ALL: + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_FROM: + case PostgreSqlParser.KW_IN: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: { - this.state = 5733; - this.opt_from_in(); + this.state = 4072; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 30) { + { + this.state = 4071; + this.match(PostgreSqlParser.KW_ALL); + } } - } - this.state = 5736; - this.cursor_name(); - } - break; - case 15: - this.enterOuterAlt(localContext, 15); - { - this.state = 5737; - this.match(PostgreSqlParser.KW_BACKWARD); - this.state = 5738; - this.signediconst(); - this.state = 5740; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 64 || _la === 68) { + } + break; + case PostgreSqlParser.PLUS: + case PostgreSqlParser.MINUS: + case PostgreSqlParser.Integral: { - this.state = 5739; - this.opt_from_in(); + this.state = 4074; + this.signediconst(); } + break; + default: + throw new antlr.NoViableAltException(this); } - - this.state = 5742; - this.cursor_name(); - } - break; - case 16: - this.enterOuterAlt(localContext, 16); - { - this.state = 5744; - this.match(PostgreSqlParser.KW_BACKWARD); - this.state = 5745; - this.match(PostgreSqlParser.KW_ALL); - this.state = 5747; + this.state = 4078; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 64 || _la === 68) { { - this.state = 5746; - this.opt_from_in(); + this.state = 4077; + this.from_in(); } } - this.state = 5749; - this.cursor_name(); + this.state = 4080; + this.colid(); } break; } @@ -25800,12 +22518,12 @@ export class PostgreSqlParser extends SQLParserBase { } public from_in(): From_inContext { let localContext = new From_inContext(this.context, this.state); - this.enterRule(localContext, 582, PostgreSqlParser.RULE_from_in); + this.enterRule(localContext, 332, PostgreSqlParser.RULE_from_in); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 5752; + this.state = 4083; _la = this.tokenStream.LA(1); if(!(_la === 64 || _la === 68)) { this.errorHandler.recoverInline(this); @@ -25830,14 +22548,38 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_from_in(): Opt_from_inContext { - let localContext = new Opt_from_inContext(this.context, this.state); - this.enterRule(localContext, 584, PostgreSqlParser.RULE_opt_from_in); + public grantstmt(): GrantstmtContext { + let localContext = new GrantstmtContext(this.context, this.state); + this.enterRule(localContext, 334, PostgreSqlParser.RULE_grantstmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 5754; - this.from_in(); + this.state = 4085; + this.match(PostgreSqlParser.KW_GRANT); + this.state = 4086; + this.privileges(); + this.state = 4087; + this.match(PostgreSqlParser.KW_ON); + this.state = 4088; + this.privilege_target(); + this.state = 4089; + this.match(PostgreSqlParser.KW_TO); + this.state = 4090; + this.grantee_list(); + this.state = 4094; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 488, this.context) ) { + case 1: + { + this.state = 4091; + this.match(PostgreSqlParser.KW_WITH); + this.state = 4092; + this.match(PostgreSqlParser.KW_GRANT); + this.state = 4093; + this.match(PostgreSqlParser.KW_OPTION); + } + break; + } } } catch (re) { @@ -25854,31 +22596,46 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public grantstmt(): GrantstmtContext { - let localContext = new GrantstmtContext(this.context, this.state); - this.enterRule(localContext, 586, PostgreSqlParser.RULE_grantstmt); + public revokestmt(): RevokestmtContext { + let localContext = new RevokestmtContext(this.context, this.state); + this.enterRule(localContext, 336, PostgreSqlParser.RULE_revokestmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 5756; - this.match(PostgreSqlParser.KW_GRANT); - this.state = 5757; + this.state = 4096; + this.match(PostgreSqlParser.KW_REVOKE); + this.state = 4100; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 65) { + { + this.state = 4097; + this.match(PostgreSqlParser.KW_GRANT); + this.state = 4098; + this.match(PostgreSqlParser.KW_OPTION); + this.state = 4099; + this.match(PostgreSqlParser.KW_FOR); + } + } + + this.state = 4102; this.privileges(); - this.state = 5758; + this.state = 4103; this.match(PostgreSqlParser.KW_ON); - this.state = 5759; + this.state = 4104; this.privilege_target(); - this.state = 5760; - this.match(PostgreSqlParser.KW_TO); - this.state = 5761; + this.state = 4105; + this.match(PostgreSqlParser.KW_FROM); + this.state = 4106; this.grantee_list(); - this.state = 5763; + this.state = 4108; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 525, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 490, this.context) ) { case 1: { - this.state = 5762; - this.opt_grant_grant_option(); + this.state = 4107; + this.opt_drop_behavior(); } break; } @@ -25898,195 +22655,87 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public revokestmt(): RevokestmtContext { - let localContext = new RevokestmtContext(this.context, this.state); - this.enterRule(localContext, 588, PostgreSqlParser.RULE_revokestmt); + public privileges(): PrivilegesContext { + let localContext = new PrivilegesContext(this.context, this.state); + this.enterRule(localContext, 338, PostgreSqlParser.RULE_privileges); + let _la: number; try { - this.state = 5786; + this.state = 4133; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 528, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 495, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 5765; - this.match(PostgreSqlParser.KW_REVOKE); - this.state = 5766; - this.privileges(); - this.state = 5767; - this.match(PostgreSqlParser.KW_ON); - this.state = 5768; - this.privilege_target(); - this.state = 5769; - this.match(PostgreSqlParser.KW_FROM); - this.state = 5770; - this.grantee_list(); - this.state = 5772; + this.state = 4110; + this.privilege(); + this.state = 4115; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 526, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + while (_la === 6) { { - this.state = 5771; - this.opt_drop_behavior(); + { + this.state = 4111; + this.match(PostgreSqlParser.COMMA); + this.state = 4112; + this.privilege(); } - break; + } + this.state = 4117; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 5774; - this.match(PostgreSqlParser.KW_REVOKE); - this.state = 5775; - this.match(PostgreSqlParser.KW_GRANT); - this.state = 5776; - this.match(PostgreSqlParser.KW_OPTION); - this.state = 5777; - this.match(PostgreSqlParser.KW_FOR); - this.state = 5778; - this.privileges(); - this.state = 5779; - this.match(PostgreSqlParser.KW_ON); - this.state = 5780; - this.privilege_target(); - this.state = 5781; - this.match(PostgreSqlParser.KW_FROM); - this.state = 5782; - this.grantee_list(); - this.state = 5784; + this.state = 4118; + this.match(PostgreSqlParser.KW_ALL); + this.state = 4120; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 527, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 294) { { - this.state = 5783; - this.opt_drop_behavior(); + this.state = 4119; + this.match(PostgreSqlParser.KW_PRIVILEGES); } - break; } + + this.state = 4123; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 4122; + this.opt_column_list(); + } } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public privileges(): PrivilegesContext { - let localContext = new PrivilegesContext(this.context, this.state); - this.enterRule(localContext, 590, PostgreSqlParser.RULE_privileges); - try { - this.state = 5804; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 529, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 5788; - this.privilege_list(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 5789; - this.match(PostgreSqlParser.KW_ALL); + } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 5790; - this.match(PostgreSqlParser.KW_ALL); - this.state = 5791; - this.match(PostgreSqlParser.KW_PRIVILEGES); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 5792; - this.match(PostgreSqlParser.KW_ALL); - this.state = 5793; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 5794; - this.column_list(); - this.state = 5795; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 5797; - this.match(PostgreSqlParser.KW_ALL); - this.state = 5798; - this.match(PostgreSqlParser.KW_PRIVILEGES); - this.state = 5799; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 5800; - this.column_list(); - this.state = 5801; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 5803; - this.beforeprivilegeselectlist(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public beforeprivilegeselectlist(): BeforeprivilegeselectlistContext { - let localContext = new BeforeprivilegeselectlistContext(this.context, this.state); - this.enterRule(localContext, 592, PostgreSqlParser.RULE_beforeprivilegeselectlist); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5806; - this.beforeprivilegeselect(); - this.state = 5811; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 5807; - this.match(PostgreSqlParser.COMMA); - this.state = 5808; + this.state = 4125; this.beforeprivilegeselect(); - } - } - this.state = 5813; + this.state = 4130; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - } + while (_la === 6) { + { + { + this.state = 4126; + this.match(PostgreSqlParser.COMMA); + this.state = 4127; + this.beforeprivilegeselect(); + } + } + this.state = 4132; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + break; } } catch (re) { @@ -26105,12 +22754,12 @@ export class PostgreSqlParser extends SQLParserBase { } public beforeprivilegeselect(): BeforeprivilegeselectContext { let localContext = new BeforeprivilegeselectContext(this.context, this.state); - this.enterRule(localContext, 594, PostgreSqlParser.RULE_beforeprivilegeselect); + this.enterRule(localContext, 340, PostgreSqlParser.RULE_beforeprivilegeselect); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 5814; + this.state = 4135; _la = this.tokenStream.LA(1); if(!(_la === 46 || _la === 88 || _la === 182 || _la === 202 || _la === 241 || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & 131173) !== 0) || ((((_la - 521)) & ~0x1F) === 0 && ((1 << (_la - 521)) & 7) !== 0))) { this.errorHandler.recoverInline(this); @@ -26135,104 +22784,32 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public privilege_list(): Privilege_listContext { - let localContext = new Privilege_listContext(this.context, this.state); - this.enterRule(localContext, 596, PostgreSqlParser.RULE_privilege_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5816; - this.privilege(); - this.state = 5821; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 5817; - this.match(PostgreSqlParser.COMMA); - this.state = 5818; - this.privilege(); - } - } - this.state = 5823; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public privilege(): PrivilegeContext { let localContext = new PrivilegeContext(this.context, this.state); - this.enterRule(localContext, 598, PostgreSqlParser.RULE_privilege); + this.enterRule(localContext, 342, PostgreSqlParser.RULE_privilege); let _la: number; try { - this.state = 5840; + this.enterOuterAlt(localContext, 1); + { + this.state = 4141; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_SELECT: - this.enterOuterAlt(localContext, 1); { - this.state = 5824; + this.state = 4137; this.match(PostgreSqlParser.KW_SELECT); - this.state = 5826; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2) { - { - this.state = 5825; - this.opt_column_list(); - } - } - } break; case PostgreSqlParser.KW_REFERENCES: - this.enterOuterAlt(localContext, 2); { - this.state = 5828; + this.state = 4138; this.match(PostgreSqlParser.KW_REFERENCES); - this.state = 5830; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2) { - { - this.state = 5829; - this.opt_column_list(); - } - } - } break; case PostgreSqlParser.KW_CREATE: - this.enterOuterAlt(localContext, 3); { - this.state = 5832; + this.state = 4139; this.match(PostgreSqlParser.KW_CREATE); - this.state = 5834; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2) { - { - this.state = 5833; - this.opt_column_list(); - } - } - } break; case PostgreSqlParser.KW_AND: @@ -26634,25 +23211,25 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLVARIABLENAME: case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 4); { - this.state = 5836; + this.state = 4140; this.colid(); - this.state = 5838; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2) { - { - this.state = 5837; - this.opt_column_list(); - } - } - } break; default: throw new antlr.NoViableAltException(this); } + this.state = 4144; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 4143; + this.opt_column_list(); + } + } + + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -26670,227 +23247,267 @@ export class PostgreSqlParser extends SQLParserBase { } public privilege_target(): Privilege_targetContext { let localContext = new Privilege_targetContext(this.context, this.state); - this.enterRule(localContext, 600, PostgreSqlParser.RULE_privilege_target); + this.enterRule(localContext, 344, PostgreSqlParser.RULE_privilege_target); + let _la: number; try { - this.state = 5900; + this.state = 4191; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 537, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 502, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 5842; - this.qualified_name_list(); + this.state = 4146; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 4147; + this.table_name_list(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 5843; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 5844; - this.table_name_list(); + this.state = 4149; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 498, this.context) ) { + case 1: + { + this.state = 4148; + this.match(PostgreSqlParser.KW_SEQUENCE); + } + break; + } + this.state = 4151; + this.qualified_name_list(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 5845; - this.match(PostgreSqlParser.KW_SEQUENCE); - this.state = 5846; - this.qualified_name_list(); + this.state = 4159; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_FOREIGN: + { + this.state = 4152; + this.match(PostgreSqlParser.KW_FOREIGN); + this.state = 4156; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_DATA: + { + this.state = 4153; + this.match(PostgreSqlParser.KW_DATA); + this.state = 4154; + this.match(PostgreSqlParser.KW_WRAPPER); + } + break; + case PostgreSqlParser.KW_SERVER: + { + this.state = 4155; + this.match(PostgreSqlParser.KW_SERVER); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + case PostgreSqlParser.KW_LANGUAGE: + { + this.state = 4158; + this.match(PostgreSqlParser.KW_LANGUAGE); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 4161; + this.name_list(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 5847; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 5848; - this.match(PostgreSqlParser.KW_DATA); - this.state = 5849; - this.match(PostgreSqlParser.KW_WRAPPER); - this.state = 5850; - this.name_list(); + this.state = 4162; + this.match(PostgreSqlParser.KW_FUNCTION); + this.state = 4163; + this.function_with_argtypes_list(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 5851; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 5852; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 5853; - this.name_list(); + this.state = 4164; + this.match(PostgreSqlParser.KW_PROCEDURE); + this.state = 4165; + this.procedure_with_argtypes_list(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 5854; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 5855; - this.function_with_argtypes_list(); + this.state = 4166; + this.match(PostgreSqlParser.KW_ROUTINE); + this.state = 4167; + this.routine_with_argtypes_list(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 5856; - this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 5857; - this.procedure_with_argtypes_list(); + this.state = 4168; + this.match(PostgreSqlParser.KW_DATABASE); + this.state = 4169; + this.database_nameList(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 5858; - this.match(PostgreSqlParser.KW_ROUTINE); - this.state = 5859; - this.routine_with_argtypes_list(); + this.state = 4170; + _la = this.tokenStream.LA(1); + if(!(_la === 189 || _la === 360)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 4171; + this.any_name_list(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 5860; - this.match(PostgreSqlParser.KW_DATABASE); - this.state = 5861; - this.database_nameList(); + this.state = 4172; + this.match(PostgreSqlParser.KW_LARGE); + this.state = 4173; + this.match(PostgreSqlParser.KW_OBJECT); + this.state = 4174; + this.numericonly(); + this.state = 4179; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 4175; + this.match(PostgreSqlParser.COMMA); + this.state = 4176; + this.numericonly(); + } + } + this.state = 4181; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 5862; - this.match(PostgreSqlParser.KW_DOMAIN); - this.state = 5863; - this.any_name_list(); + this.state = 4182; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 4183; + this.schema_name_list(); } break; case 11: this.enterOuterAlt(localContext, 11); { - this.state = 5864; - this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 5865; - this.name_list(); + this.state = 4184; + this.match(PostgreSqlParser.KW_TABLESPACE); + this.state = 4185; + this.tablespace_name_list(); } break; case 12: this.enterOuterAlt(localContext, 12); { - this.state = 5866; - this.match(PostgreSqlParser.KW_LARGE); - this.state = 5867; - this.match(PostgreSqlParser.KW_OBJECT); - this.state = 5868; - this.numericonly_list(); + this.state = 4186; + this.match(PostgreSqlParser.KW_ALL); + this.state = 4187; + _la = this.tokenStream.LA(1); + if(!(_la === 212 || _la === 329 || _la === 350 || _la === 455 || _la === 457)) { + this.errorHandler.recoverInline(this); } - break; - case 13: - this.enterOuterAlt(localContext, 13); - { - this.state = 5869; + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 4188; + this.match(PostgreSqlParser.KW_IN); + this.state = 4189; this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 5870; + this.state = 4190; this.schema_name_list(); } break; - case 14: - this.enterOuterAlt(localContext, 14); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public grantee_list(): Grantee_listContext { + let localContext = new Grantee_listContext(this.context, this.state); + this.enterRule(localContext, 346, PostgreSqlParser.RULE_grantee_list); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + { + this.state = 4194; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 66) { { - this.state = 5871; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 5872; - this.tablespace_name_list(); + this.state = 4193; + this.match(PostgreSqlParser.KW_GROUP); } - break; - case 15: - this.enterOuterAlt(localContext, 15); + } + + this.state = 4196; + this.rolespec(); + } + this.state = 4205; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { { - this.state = 5873; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 5874; - this.any_name_list(); - } - break; - case 16: - this.enterOuterAlt(localContext, 16); { - this.state = 5875; - this.match(PostgreSqlParser.KW_ALL); - this.state = 5876; - this.match(PostgreSqlParser.KW_TABLES); - this.state = 5877; - this.match(PostgreSqlParser.KW_IN); - this.state = 5878; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 5879; - this.schema_name_list(); - } - break; - case 17: - this.enterOuterAlt(localContext, 17); + this.state = 4198; + this.match(PostgreSqlParser.COMMA); { - this.state = 5880; - this.match(PostgreSqlParser.KW_ALL); - this.state = 5881; - this.match(PostgreSqlParser.KW_SEQUENCES); - this.state = 5882; - this.match(PostgreSqlParser.KW_IN); - this.state = 5883; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 5884; - this.schema_name_list(); + this.state = 4200; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 66) { + { + this.state = 4199; + this.match(PostgreSqlParser.KW_GROUP); + } } - break; - case 18: - this.enterOuterAlt(localContext, 18); - { - this.state = 5885; - this.match(PostgreSqlParser.KW_ALL); - this.state = 5886; - this.match(PostgreSqlParser.KW_FUNCTIONS); - this.state = 5887; - this.match(PostgreSqlParser.KW_IN); - this.state = 5888; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 5889; - this.schema_name_list(); + + this.state = 4202; + this.rolespec(); } - break; - case 19: - this.enterOuterAlt(localContext, 19); - { - this.state = 5890; - this.match(PostgreSqlParser.KW_ALL); - this.state = 5891; - this.match(PostgreSqlParser.KW_PROCEDURES); - this.state = 5892; - this.match(PostgreSqlParser.KW_IN); - this.state = 5893; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 5894; - this.schema_name_list(); } - break; - case 20: - this.enterOuterAlt(localContext, 20); - { - this.state = 5895; - this.match(PostgreSqlParser.KW_ALL); - this.state = 5896; - this.match(PostgreSqlParser.KW_ROUTINES); - this.state = 5897; - this.match(PostgreSqlParser.KW_IN); - this.state = 5898; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 5899; - this.schema_name_list(); } - break; + this.state = 4207; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } } } catch (re) { @@ -26907,31 +23524,65 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public grantee_list(): Grantee_listContext { - let localContext = new Grantee_listContext(this.context, this.state); - this.enterRule(localContext, 602, PostgreSqlParser.RULE_grantee_list); + public grantrolestmt(): GrantrolestmtContext { + let localContext = new GrantrolestmtContext(this.context, this.state); + this.enterRule(localContext, 348, PostgreSqlParser.RULE_grantrolestmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 5902; - this.grantee(); - this.state = 5907; + this.state = 4208; + this.match(PostgreSqlParser.KW_GRANT); + this.state = 4209; + this.privilege(); + this.state = 4214; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 5903; + this.state = 4210; this.match(PostgreSqlParser.COMMA); - this.state = 5904; - this.grantee(); + this.state = 4211; + this.privilege(); } } - this.state = 5909; + this.state = 4216; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } + this.state = 4217; + this.match(PostgreSqlParser.KW_TO); + this.state = 4218; + this.role_list(); + this.state = 4222; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 507, this.context) ) { + case 1: + { + this.state = 4219; + this.match(PostgreSqlParser.KW_WITH); + this.state = 4220; + this.match(PostgreSqlParser.KW_ADMIN); + this.state = 4221; + this.match(PostgreSqlParser.KW_OPTION); + } + break; + } + this.state = 4227; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 508, this.context) ) { + case 1: + { + this.state = 4224; + this.match(PostgreSqlParser.KW_GRANTED); + this.state = 4225; + this.match(PostgreSqlParser.KW_BY); + this.state = 4226; + this.rolespec(); + } + break; + } } } catch (re) { @@ -26948,482 +23599,75 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public grantee(): GranteeContext { - let localContext = new GranteeContext(this.context, this.state); - this.enterRule(localContext, 604, PostgreSqlParser.RULE_grantee); + public revokerolestmt(): RevokerolestmtContext { + let localContext = new RevokerolestmtContext(this.context, this.state); + this.enterRule(localContext, 350, PostgreSqlParser.RULE_revokerolestmt); + let _la: number; try { - this.state = 5913; + this.enterOuterAlt(localContext, 1); + { + this.state = 4229; + this.match(PostgreSqlParser.KW_REVOKE); + this.state = 4233; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_CURRENT_ROLE: - case PostgreSqlParser.KW_CURRENT_USER: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_SESSION_USER: - case PostgreSqlParser.KW_AUTHORIZATION: - case PostgreSqlParser.KW_BINARY: - case PostgreSqlParser.KW_COLLATION: - case PostgreSqlParser.KW_CONCURRENTLY: - case PostgreSqlParser.KW_CROSS: - case PostgreSqlParser.KW_CURRENT_SCHEMA: - case PostgreSqlParser.KW_FREEZE: - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_ILIKE: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_ISNULL: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_LIKE: - case PostgreSqlParser.KW_NATURAL: - case PostgreSqlParser.KW_NOTNULL: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_OVERLAPS: - case PostgreSqlParser.KW_RIGHT: - case PostgreSqlParser.KW_SIMILAR: - case PostgreSqlParser.KW_VERBOSE: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_TABLESAMPLE: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_PUBLIC: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); + switch (this.interpreter.adaptivePredict(this.tokenStream, 509, this.context) ) { + case 1: { - this.state = 5910; - this.rolespec(); + this.state = 4230; + this.match(PostgreSqlParser.KW_ADMIN); + this.state = 4231; + this.match(PostgreSqlParser.KW_OPTION); + this.state = 4232; + this.match(PostgreSqlParser.KW_FOR); } break; - case PostgreSqlParser.KW_GROUP: - this.enterOuterAlt(localContext, 2); + } + this.state = 4235; + this.privilege(); + this.state = 4240; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { { - this.state = 5911; - this.match(PostgreSqlParser.KW_GROUP); - this.state = 5912; + { + this.state = 4236; + this.match(PostgreSqlParser.COMMA); + this.state = 4237; + this.privilege(); + } + } + this.state = 4242; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 4243; + this.match(PostgreSqlParser.KW_FROM); + this.state = 4244; + this.role_list(); + this.state = 4248; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 511, this.context) ) { + case 1: + { + this.state = 4245; + this.match(PostgreSqlParser.KW_GRANTED); + this.state = 4246; + this.match(PostgreSqlParser.KW_BY); + this.state = 4247; this.rolespec(); } break; - default: - throw new antlr.NoViableAltException(this); } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + this.state = 4251; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 512, this.context) ) { + case 1: + { + this.state = 4250; + this.opt_drop_behavior(); + } + break; } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_grant_grant_option(): Opt_grant_grant_optionContext { - let localContext = new Opt_grant_grant_optionContext(this.context, this.state); - this.enterRule(localContext, 606, PostgreSqlParser.RULE_opt_grant_grant_option); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5915; - this.match(PostgreSqlParser.KW_WITH); - this.state = 5916; - this.match(PostgreSqlParser.KW_GRANT); - this.state = 5917; - this.match(PostgreSqlParser.KW_OPTION); } } catch (re) { @@ -27440,40 +23684,64 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public grantrolestmt(): GrantrolestmtContext { - let localContext = new GrantrolestmtContext(this.context, this.state); - this.enterRule(localContext, 608, PostgreSqlParser.RULE_grantrolestmt); + public alterdefaultprivilegesstmt(): AlterdefaultprivilegesstmtContext { + let localContext = new AlterdefaultprivilegesstmtContext(this.context, this.state); + this.enterRule(localContext, 352, PostgreSqlParser.RULE_alterdefaultprivilegesstmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 5919; - this.match(PostgreSqlParser.KW_GRANT); - this.state = 5920; - this.privilege_list(); - this.state = 5921; - this.match(PostgreSqlParser.KW_TO); - this.state = 5922; - this.role_list(); - this.state = 5924; + this.state = 4253; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 4254; + this.match(PostgreSqlParser.KW_DEFAULT); + this.state = 4255; + this.match(PostgreSqlParser.KW_PRIVILEGES); + this.state = 4264; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 540, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + while (_la === 62 || _la === 68) { { - this.state = 5923; - this.opt_grant_admin_option(); + this.state = 4262; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_IN: + { + this.state = 4256; + this.match(PostgreSqlParser.KW_IN); + this.state = 4257; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 4258; + this.schema_name_list(); + } + break; + case PostgreSqlParser.KW_FOR: + { + this.state = 4259; + this.match(PostgreSqlParser.KW_FOR); + this.state = 4260; + _la = this.tokenStream.LA(1); + if(!(_la === 99 || _la === 318)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 4261; + this.role_list(); + } + break; + default: + throw new antlr.NoViableAltException(this); } - break; - } - this.state = 5927; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 541, this.context) ) { - case 1: - { - this.state = 5926; - this.opt_granted_by(); } - break; + this.state = 4266; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } + this.state = 4267; + this.defaclaction(); } } catch (re) { @@ -27490,376 +23758,88 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public revokerolestmt(): RevokerolestmtContext { - let localContext = new RevokerolestmtContext(this.context, this.state); - this.enterRule(localContext, 610, PostgreSqlParser.RULE_revokerolestmt); + public defaclaction(): DefaclactionContext { + let localContext = new DefaclactionContext(this.context, this.state); + this.enterRule(localContext, 354, PostgreSqlParser.RULE_defaclaction); + let _la: number; try { - this.state = 5952; + this.state = 4294; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 546, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_GRANT: this.enterOuterAlt(localContext, 1); { - this.state = 5929; - this.match(PostgreSqlParser.KW_REVOKE); - this.state = 5930; - this.privilege_list(); - this.state = 5931; - this.match(PostgreSqlParser.KW_FROM); - this.state = 5932; - this.role_list(); - this.state = 5934; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 542, this.context) ) { - case 1: - { - this.state = 5933; - this.opt_granted_by(); - } - break; - } - this.state = 5937; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 543, this.context) ) { - case 1: - { - this.state = 5936; - this.opt_drop_behavior(); - } - break; - } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 5939; - this.match(PostgreSqlParser.KW_REVOKE); - this.state = 5940; - this.match(PostgreSqlParser.KW_ADMIN); - this.state = 5941; - this.match(PostgreSqlParser.KW_OPTION); - this.state = 5942; - this.match(PostgreSqlParser.KW_FOR); - this.state = 5943; - this.privilege_list(); - this.state = 5944; - this.match(PostgreSqlParser.KW_FROM); - this.state = 5945; - this.role_list(); - this.state = 5947; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 544, this.context) ) { - case 1: - { - this.state = 5946; - this.opt_granted_by(); - } - break; - } - this.state = 5950; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 545, this.context) ) { - case 1: - { - this.state = 5949; - this.opt_drop_behavior(); - } - break; - } - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_grant_admin_option(): Opt_grant_admin_optionContext { - let localContext = new Opt_grant_admin_optionContext(this.context, this.state); - this.enterRule(localContext, 612, PostgreSqlParser.RULE_opt_grant_admin_option); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5954; - this.match(PostgreSqlParser.KW_WITH); - this.state = 5955; - this.match(PostgreSqlParser.KW_ADMIN); - this.state = 5956; - this.match(PostgreSqlParser.KW_OPTION); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_granted_by(): Opt_granted_byContext { - let localContext = new Opt_granted_byContext(this.context, this.state); - this.enterRule(localContext, 614, PostgreSqlParser.RULE_opt_granted_by); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5958; - this.match(PostgreSqlParser.KW_GRANTED); - this.state = 5959; - this.match(PostgreSqlParser.KW_BY); - this.state = 5960; - this.rolespec(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alterdefaultprivilegesstmt(): AlterdefaultprivilegesstmtContext { - let localContext = new AlterdefaultprivilegesstmtContext(this.context, this.state); - this.enterRule(localContext, 616, PostgreSqlParser.RULE_alterdefaultprivilegesstmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5962; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 5963; - this.match(PostgreSqlParser.KW_DEFAULT); - this.state = 5964; - this.match(PostgreSqlParser.KW_PRIVILEGES); - this.state = 5965; - this.defacloptionlist(); - this.state = 5966; - this.defaclaction(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public defacloptionlist(): DefacloptionlistContext { - let localContext = new DefacloptionlistContext(this.context, this.state); - this.enterRule(localContext, 618, PostgreSqlParser.RULE_defacloptionlist); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 5971; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 62 || _la === 68) { - { - { - this.state = 5968; - this.defacloption(); - } - } - this.state = 5973; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public defacloption(): DefacloptionContext { - let localContext = new DefacloptionContext(this.context, this.state); - this.enterRule(localContext, 620, PostgreSqlParser.RULE_defacloption); - try { - this.state = 5983; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 548, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 5974; - this.match(PostgreSqlParser.KW_IN); - this.state = 5975; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 5976; - this.schema_name_list(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 5977; - this.match(PostgreSqlParser.KW_FOR); - this.state = 5978; - this.match(PostgreSqlParser.KW_ROLE); - this.state = 5979; - this.role_list(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 5980; - this.match(PostgreSqlParser.KW_FOR); - this.state = 5981; - this.match(PostgreSqlParser.KW_USER); - this.state = 5982; - this.role_list(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public defaclaction(): DefaclactionContext { - let localContext = new DefaclactionContext(this.context, this.state); - this.enterRule(localContext, 622, PostgreSqlParser.RULE_defaclaction); - try { - this.state = 6015; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 552, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 5985; + this.state = 4269; this.match(PostgreSqlParser.KW_GRANT); - this.state = 5986; + this.state = 4270; this.privileges(); - this.state = 5987; + this.state = 4271; this.match(PostgreSqlParser.KW_ON); - this.state = 5988; + this.state = 4272; this.defacl_privilege_target(); - this.state = 5989; + this.state = 4273; this.match(PostgreSqlParser.KW_TO); - this.state = 5990; + this.state = 4274; this.grantee_list(); - this.state = 5992; + this.state = 4278; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 549, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 515, this.context) ) { case 1: { - this.state = 5991; - this.opt_grant_grant_option(); + this.state = 4275; + this.match(PostgreSqlParser.KW_WITH); + this.state = 4276; + this.match(PostgreSqlParser.KW_GRANT); + this.state = 4277; + this.match(PostgreSqlParser.KW_OPTION); } break; } } break; - case 2: + case PostgreSqlParser.KW_REVOKE: this.enterOuterAlt(localContext, 2); { - this.state = 5994; + this.state = 4280; this.match(PostgreSqlParser.KW_REVOKE); - this.state = 5995; - this.privileges(); - this.state = 5996; - this.match(PostgreSqlParser.KW_ON); - this.state = 5997; - this.defacl_privilege_target(); - this.state = 5998; - this.match(PostgreSqlParser.KW_FROM); - this.state = 5999; - this.grantee_list(); - this.state = 6001; + this.state = 4284; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 550, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 65) { { - this.state = 6000; - this.opt_drop_behavior(); + this.state = 4281; + this.match(PostgreSqlParser.KW_GRANT); + this.state = 4282; + this.match(PostgreSqlParser.KW_OPTION); + this.state = 4283; + this.match(PostgreSqlParser.KW_FOR); } - break; } - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 6003; - this.match(PostgreSqlParser.KW_REVOKE); - this.state = 6004; - this.match(PostgreSqlParser.KW_GRANT); - this.state = 6005; - this.match(PostgreSqlParser.KW_OPTION); - this.state = 6006; - this.match(PostgreSqlParser.KW_FOR); - this.state = 6007; + + this.state = 4286; this.privileges(); - this.state = 6008; + this.state = 4287; this.match(PostgreSqlParser.KW_ON); - this.state = 6009; + this.state = 4288; this.defacl_privilege_target(); - this.state = 6010; + this.state = 4289; this.match(PostgreSqlParser.KW_FROM); - this.state = 6011; + this.state = 4290; this.grantee_list(); - this.state = 6013; + this.state = 4292; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 551, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 517, this.context) ) { case 1: { - this.state = 6012; + this.state = 4291; this.opt_drop_behavior(); } break; } } break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -27878,12 +23858,12 @@ export class PostgreSqlParser extends SQLParserBase { } public defacl_privilege_target(): Defacl_privilege_targetContext { let localContext = new Defacl_privilege_targetContext(this.context, this.state); - this.enterRule(localContext, 624, PostgreSqlParser.RULE_defacl_privilege_target); + this.enterRule(localContext, 356, PostgreSqlParser.RULE_defacl_privilege_target); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6017; + this.state = 4296; _la = this.tokenStream.LA(1); if(!(_la === 212 || _la === 329 || _la === 350 || _la === 361 || _la === 455 || _la === 456)) { this.errorHandler.recoverInline(this); @@ -27910,121 +23890,131 @@ export class PostgreSqlParser extends SQLParserBase { } public indexstmt(): IndexstmtContext { let localContext = new IndexstmtContext(this.context, this.state); - this.enterRule(localContext, 626, PostgreSqlParser.RULE_indexstmt); + this.enterRule(localContext, 358, PostgreSqlParser.RULE_indexstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6019; + this.state = 4298; this.match(PostgreSqlParser.KW_CREATE); - this.state = 6021; + this.state = 4300; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 98) { { - this.state = 6020; - this.opt_unique(); + this.state = 4299; + this.match(PostgreSqlParser.KW_UNIQUE); } } - this.state = 6023; + this.state = 4302; this.match(PostgreSqlParser.KW_INDEX); - this.state = 6025; + this.state = 4304; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 109) { { - this.state = 6024; - this.opt_concurrently(); + this.state = 4303; + this.match(PostgreSqlParser.KW_CONCURRENTLY); } } - this.state = 6028; + this.state = 4307; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 555, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 521, this.context) ) { case 1: { - this.state = 6027; + this.state = 4306; this.opt_if_not_exists(); } break; } - this.state = 6031; + this.state = 4310; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { - this.state = 6030; - this.opt_index_name(); + this.state = 4309; + this.colid(); } } - this.state = 6033; + this.state = 4312; this.match(PostgreSqlParser.KW_ON); - this.state = 6034; + this.state = 4313; this.relation_expr(); - this.state = 6036; + this.state = 4315; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 100) { { - this.state = 6035; - this.access_method_clause(); + this.state = 4314; + this.table_access_method_clause(); } } - this.state = 6038; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6039; + this.state = 4317; this.index_params(); - this.state = 6040; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 6042; + this.state = 4320; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 558, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 524, this.context) ) { case 1: { - this.state = 6041; - this.opt_include(); + this.state = 4318; + this.match(PostgreSqlParser.KW_INCLUDE); + this.state = 4319; + this.index_params(); } break; } - this.state = 6045; + this.state = 4327; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 559, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 526, this.context) ) { case 1: { - this.state = 6044; - this.nulls_distinct(); + this.state = 4322; + this.match(PostgreSqlParser.KW_NULLS); + this.state = 4324; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { + { + this.state = 4323; + this.match(PostgreSqlParser.KW_NOT); + } + } + + this.state = 4326; + this.match(PostgreSqlParser.KW_DISTINCT); } break; } - this.state = 6048; + this.state = 4330; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 560, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 527, this.context) ) { case 1: { - this.state = 6047; + this.state = 4329; this.opt_reloptions(); } break; } - this.state = 6051; + this.state = 4333; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 561, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 528, this.context) ) { case 1: { - this.state = 6050; + this.state = 4332; this.opttablespace(); } break; } - this.state = 6054; + this.state = 4336; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 103) { { - this.state = 6053; + this.state = 4335; this.where_clause(); } } @@ -28045,129 +24035,35 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_unique(): Opt_uniqueContext { - let localContext = new Opt_uniqueContext(this.context, this.state); - this.enterRule(localContext, 628, PostgreSqlParser.RULE_opt_unique); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6056; - this.match(PostgreSqlParser.KW_UNIQUE); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_concurrently(): Opt_concurrentlyContext { - let localContext = new Opt_concurrentlyContext(this.context, this.state); - this.enterRule(localContext, 630, PostgreSqlParser.RULE_opt_concurrently); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6058; - this.match(PostgreSqlParser.KW_CONCURRENTLY); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_index_name(): Opt_index_nameContext { - let localContext = new Opt_index_nameContext(this.context, this.state); - this.enterRule(localContext, 632, PostgreSqlParser.RULE_opt_index_name); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6060; - this.name(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public access_method_clause(): Access_method_clauseContext { - let localContext = new Access_method_clauseContext(this.context, this.state); - this.enterRule(localContext, 634, PostgreSqlParser.RULE_access_method_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6062; - this.match(PostgreSqlParser.KW_USING); - this.state = 6063; - this.name(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public index_params(): Index_paramsContext { let localContext = new Index_paramsContext(this.context, this.state); - this.enterRule(localContext, 636, PostgreSqlParser.RULE_index_params); + this.enterRule(localContext, 360, PostgreSqlParser.RULE_index_params); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6065; + this.state = 4338; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 4339; this.index_elem(); - this.state = 6070; + this.state = 4344; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 6066; + this.state = 4340; this.match(PostgreSqlParser.COMMA); - this.state = 6067; + this.state = 4341; this.index_elem(); } } - this.state = 6072; + this.state = 4346; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } + this.state = 4347; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -28184,98 +24080,111 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public index_elem_options(): Index_elem_optionsContext { - let localContext = new Index_elem_optionsContext(this.context, this.state); - this.enterRule(localContext, 638, PostgreSqlParser.RULE_index_elem_options); + public index_elem(): Index_elemContext { + let localContext = new Index_elemContext(this.context, this.state); + this.enterRule(localContext, 362, PostgreSqlParser.RULE_index_elem); let _la: number; try { - this.state = 6096; + this.enterOuterAlt(localContext, 1); + { + this.state = 4355; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 571, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 531, this.context) ) { case 1: - this.enterOuterAlt(localContext, 1); { - this.state = 6074; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 564, this.context) ) { - case 1: - { - this.state = 6073; - this.opt_collate(); - } - break; - } - this.state = 6077; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 565, this.context) ) { - case 1: - { - this.state = 6076; - this.opt_class(); - } - break; + this.state = 4349; + this.column_name(); } - this.state = 6080; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 37 || _la === 55) { - { - this.state = 6079; - this.opt_asc_desc(); - } + break; + case 2: + { + this.state = 4350; + this.func_expr_windowless(); } - - this.state = 6083; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 273) { - { - this.state = 6082; - this.opt_nulls_order(); - } + break; + case 3: + { + this.state = 4351; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 4352; + this.expression(); + this.state = 4353; + this.match(PostgreSqlParser.CLOSE_PAREN); } - + break; + } + this.state = 4358; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 532, this.context) ) { + case 1: + { + this.state = 4357; + this.opt_collate_clause(); } break; - case 2: - this.enterOuterAlt(localContext, 2); + } + this.state = 4366; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 534, this.context) ) { + case 1: { - this.state = 6086; + this.state = 4361; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 568, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 533, this.context) ) { case 1: { - this.state = 6085; - this.opt_collate(); + this.state = 4360; + this.any_name(); } break; } - this.state = 6088; + } + break; + case 2: + { + this.state = 4363; this.any_name(); - this.state = 6089; + this.state = 4364; this.reloptions(); - this.state = 6091; - this.errorHandler.sync(this); + } + break; + } + this.state = 4369; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 37 || _la === 55) { + { + this.state = 4368; _la = this.tokenStream.LA(1); - if (_la === 37 || _la === 55) { - { - this.state = 6090; - this.opt_asc_desc(); - } + if(!(_la === 37 || _la === 55)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } } + } - this.state = 6094; - this.errorHandler.sync(this); + this.state = 4373; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 273) { + { + this.state = 4371; + this.match(PostgreSqlParser.KW_NULLS); + this.state = 4372; _la = this.tokenStream.LA(1); - if (_la === 273) { - { - this.state = 6093; - this.opt_nulls_order(); - } + if(!(_la === 207 || _la === 249)) { + this.errorHandler.recoverInline(this); } - + else { + this.errorHandler.reportMatch(this); + this.consume(); } - break; + } + } + } } catch (re) { @@ -28292,305 +24201,88 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public index_elem(): Index_elemContext { - let localContext = new Index_elemContext(this.context, this.state); - this.enterRule(localContext, 640, PostgreSqlParser.RULE_index_elem); + public createfunctionstmt(): CreatefunctionstmtContext { + let localContext = new CreatefunctionstmtContext(this.context, this.state); + this.enterRule(localContext, 364, PostgreSqlParser.RULE_createfunctionstmt); + let _la: number; try { - this.state = 6109; + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 4375; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 4377; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 572, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); + _la = this.tokenStream.LA(1); + if (_la === 82) { { - this.state = 6098; - this.column_name(); - this.state = 6099; - this.index_elem_options(); + this.state = 4376; + this.opt_or_replace(); } - break; - case 2: - this.enterOuterAlt(localContext, 2); + } + + this.state = 4383; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_FUNCTION: { - this.state = 6101; - this.func_expr_windowless(); - this.state = 6102; - this.index_elem_options(); + this.state = 4379; + this.match(PostgreSqlParser.KW_FUNCTION); + this.state = 4380; + this.function_name_create(); } break; - case 3: - this.enterOuterAlt(localContext, 3); + case PostgreSqlParser.KW_PROCEDURE: { - this.state = 6104; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6105; - this.a_expr(); - this.state = 6106; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 6107; - this.index_elem_options(); + this.state = 4381; + this.match(PostgreSqlParser.KW_PROCEDURE); + this.state = 4382; + this.procedure_name_create(); } break; + default: + throw new antlr.NoViableAltException(this); } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_include(): Opt_includeContext { - let localContext = new Opt_includeContext(this.context, this.state); - this.enterRule(localContext, 642, PostgreSqlParser.RULE_opt_include); - try { - this.enterOuterAlt(localContext, 1); { - this.state = 6111; - this.match(PostgreSqlParser.KW_INCLUDE); - this.state = 6112; + this.state = 4385; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6113; - this.index_including_params(); - this.state = 6114; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public index_including_params(): Index_including_paramsContext { - let localContext = new Index_including_paramsContext(this.context, this.state); - this.enterRule(localContext, 644, PostgreSqlParser.RULE_index_including_params); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6116; - this.index_elem(); - this.state = 6121; + this.state = 4394; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - while (_la === 6) { - { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || _la === 68 || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & 4294967265) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & 4294967295) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & 4294967295) !== 0) || ((((_la - 197)) & ~0x1F) === 0 && ((1 << (_la - 197)) & 4294967295) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { - this.state = 6117; - this.match(PostgreSqlParser.COMMA); - this.state = 6118; - this.index_elem(); - } - } - this.state = 6123; + this.state = 4386; + this.func_arg_with_default(); + this.state = 4391; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_collate(): Opt_collateContext { - let localContext = new Opt_collateContext(this.context, this.state); - this.enterRule(localContext, 646, PostgreSqlParser.RULE_opt_collate); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6124; - this.match(PostgreSqlParser.KW_COLLATE); - this.state = 6125; - this.any_name(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_class(): Opt_classContext { - let localContext = new Opt_classContext(this.context, this.state); - this.enterRule(localContext, 648, PostgreSqlParser.RULE_opt_class); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6127; - this.any_name(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_asc_desc(): Opt_asc_descContext { - let localContext = new Opt_asc_descContext(this.context, this.state); - this.enterRule(localContext, 650, PostgreSqlParser.RULE_opt_asc_desc); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6129; - _la = this.tokenStream.LA(1); - if(!(_la === 37 || _la === 55)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_nulls_order(): Opt_nulls_orderContext { - let localContext = new Opt_nulls_orderContext(this.context, this.state); - this.enterRule(localContext, 652, PostgreSqlParser.RULE_opt_nulls_order); - try { - this.state = 6135; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 574, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 6131; - this.match(PostgreSqlParser.KW_NULLS); - this.state = 6132; - this.match(PostgreSqlParser.KW_FIRST); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 6133; - this.match(PostgreSqlParser.KW_NULLS); - this.state = 6134; - this.match(PostgreSqlParser.KW_LAST); + while (_la === 6) { + { + { + this.state = 4387; + this.match(PostgreSqlParser.COMMA); + this.state = 4388; + this.func_arg_with_default(); + } + } + this.state = 4393; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createfunctionstmt(): CreatefunctionstmtContext { - let localContext = new CreatefunctionstmtContext(this.context, this.state); - this.enterRule(localContext, 654, PostgreSqlParser.RULE_createfunctionstmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6137; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 6139; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 82) { - { - this.state = 6138; - this.opt_or_replace(); } } - this.state = 6145; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_FUNCTION: - { - this.state = 6141; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6142; - this.function_name_create(); - } - break; - case PostgreSqlParser.KW_PROCEDURE: - { - this.state = 6143; - this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 6144; - this.procedure_name_create(); - } - break; - default: - throw new antlr.NoViableAltException(this); + this.state = 4396; + this.match(PostgreSqlParser.CLOSE_PAREN); } - this.state = 6147; - this.func_args_with_defaults(); - this.state = 6157; + this.state = 4414; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 578, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 543, this.context) ) { case 1: { - this.state = 6148; + this.state = 4398; this.match(PostgreSqlParser.KW_RETURNS); - this.state = 6155; + this.state = 4412; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_AND: @@ -29014,21 +24706,39 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 6149; - this.func_return(); + this.state = 4399; + this.func_type(); } break; case PostgreSqlParser.KW_TABLE: { - this.state = 6150; + this.state = 4400; this.match(PostgreSqlParser.KW_TABLE); - this.state = 6151; + { + this.state = 4401; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6152; - this.table_func_column_list(); - this.state = 6153; + this.state = 4402; + this.table_func_column(); + this.state = 4407; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 4403; + this.match(PostgreSqlParser.COMMA); + this.state = 4404; + this.table_func_column(); + } + } + this.state = 4409; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 4410; this.match(PostgreSqlParser.CLOSE_PAREN); } + } break; default: throw new antlr.NoViableAltException(this); @@ -29036,17 +24746,39 @@ export class PostgreSqlParser extends SQLParserBase { } break; } - this.state = 6159; - this.createfunc_opt_list(); - this.state = 6162; + this.state = 4417; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 579, this.context) ) { + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 4416; + this.createfunc_opt_item(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 4419; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 544, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + this.state = 4426; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 545, this.context) ) { case 1: { - this.state = 6160; + this.state = 4421; this.match(PostgreSqlParser.KW_WITH); - this.state = 6161; - this.attrilist(); + this.state = 4422; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 4423; + this.name_list(); + this.state = 4424; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; } @@ -29066,60 +24798,15 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public attrilist(): AttrilistContext { - let localContext = new AttrilistContext(this.context, this.state); - this.enterRule(localContext, 656, PostgreSqlParser.RULE_attrilist); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6164; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6165; - this.colid(); - this.state = 6170; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 6166; - this.match(PostgreSqlParser.COMMA); - this.state = 6167; - this.colid(); - } - } - this.state = 6172; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - this.state = 6173; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public opt_or_replace(): Opt_or_replaceContext { let localContext = new Opt_or_replaceContext(this.context, this.state); - this.enterRule(localContext, 658, PostgreSqlParser.RULE_opt_or_replace); + this.enterRule(localContext, 366, PostgreSqlParser.RULE_opt_or_replace); try { this.enterOuterAlt(localContext, 1); { - this.state = 6175; + this.state = 4428; this.match(PostgreSqlParser.KW_OR); - this.state = 6176; + this.state = 4429; this.match(PostgreSqlParser.KW_REPLACE); } } @@ -29139,24 +24826,24 @@ export class PostgreSqlParser extends SQLParserBase { } public func_args(): Func_argsContext { let localContext = new Func_argsContext(this.context, this.state); - this.enterRule(localContext, 660, PostgreSqlParser.RULE_func_args); + this.enterRule(localContext, 368, PostgreSqlParser.RULE_func_args); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6178; + this.state = 4431; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6180; + this.state = 4433; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || _la === 68 || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & 4294967265) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & 4294967295) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & 4294967295) !== 0) || ((((_la - 197)) & ~0x1F) === 0 && ((1 << (_la - 197)) & 4294967295) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { - this.state = 6179; + this.state = 4432; this.func_args_list(); } } - this.state = 6182; + this.state = 4435; this.match(PostgreSqlParser.CLOSE_PAREN); } } @@ -29176,26 +24863,26 @@ export class PostgreSqlParser extends SQLParserBase { } public func_args_list(): Func_args_listContext { let localContext = new Func_args_listContext(this.context, this.state); - this.enterRule(localContext, 662, PostgreSqlParser.RULE_func_args_list); + this.enterRule(localContext, 370, PostgreSqlParser.RULE_func_args_list); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6184; + this.state = 4437; this.func_arg(); - this.state = 6189; + this.state = 4442; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 6185; + this.state = 4438; this.match(PostgreSqlParser.COMMA); - this.state = 6186; + this.state = 4439; this.func_arg(); } } - this.state = 6191; + this.state = 4444; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -29217,26 +24904,26 @@ export class PostgreSqlParser extends SQLParserBase { } public routine_with_argtypes_list(): Routine_with_argtypes_listContext { let localContext = new Routine_with_argtypes_listContext(this.context, this.state); - this.enterRule(localContext, 664, PostgreSqlParser.RULE_routine_with_argtypes_list); + this.enterRule(localContext, 372, PostgreSqlParser.RULE_routine_with_argtypes_list); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6192; + this.state = 4445; this.routine_with_argtypes(); - this.state = 6197; + this.state = 4450; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 6193; + this.state = 4446; this.match(PostgreSqlParser.COMMA); - this.state = 6194; + this.state = 4447; this.routine_with_argtypes(); } } - this.state = 6199; + this.state = 4452; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -29258,43 +24945,32 @@ export class PostgreSqlParser extends SQLParserBase { } public routine_with_argtypes(): Routine_with_argtypesContext { let localContext = new Routine_with_argtypesContext(this.context, this.state); - this.enterRule(localContext, 666, PostgreSqlParser.RULE_routine_with_argtypes); - let _la: number; + this.enterRule(localContext, 374, PostgreSqlParser.RULE_routine_with_argtypes); try { - this.state = 6208; + this.state = 4458; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 585, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 549, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 6200; + this.state = 4453; this.routine_name(); - this.state = 6201; + this.state = 4454; this.func_args(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 6203; + this.state = 4456; this.type_func_name_keyword(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 6204; - this.colid(); - this.state = 6206; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 4 || _la === 11) { - { - this.state = 6205; - this.indirection(); - } - } - + this.state = 4457; + this.qualified_name(); } break; } @@ -29315,26 +24991,26 @@ export class PostgreSqlParser extends SQLParserBase { } public procedure_with_argtypes_list(): Procedure_with_argtypes_listContext { let localContext = new Procedure_with_argtypes_listContext(this.context, this.state); - this.enterRule(localContext, 668, PostgreSqlParser.RULE_procedure_with_argtypes_list); + this.enterRule(localContext, 376, PostgreSqlParser.RULE_procedure_with_argtypes_list); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6210; + this.state = 4460; this.procedure_with_argtypes(); - this.state = 6215; + this.state = 4465; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 6211; + this.state = 4461; this.match(PostgreSqlParser.COMMA); - this.state = 6212; + this.state = 4462; this.procedure_with_argtypes(); } } - this.state = 6217; + this.state = 4467; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -29356,43 +25032,32 @@ export class PostgreSqlParser extends SQLParserBase { } public procedure_with_argtypes(): Procedure_with_argtypesContext { let localContext = new Procedure_with_argtypesContext(this.context, this.state); - this.enterRule(localContext, 670, PostgreSqlParser.RULE_procedure_with_argtypes); - let _la: number; + this.enterRule(localContext, 378, PostgreSqlParser.RULE_procedure_with_argtypes); try { - this.state = 6226; + this.state = 4473; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 588, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 551, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 6218; + this.state = 4468; this.procedure_name(); - this.state = 6219; + this.state = 4469; this.func_args(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 6221; + this.state = 4471; this.type_func_name_keyword(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 6222; - this.colid(); - this.state = 6224; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 4 || _la === 11) { - { - this.state = 6223; - this.indirection(); - } - } - + this.state = 4472; + this.qualified_name(); } break; } @@ -29413,26 +25078,26 @@ export class PostgreSqlParser extends SQLParserBase { } public function_with_argtypes_list(): Function_with_argtypes_listContext { let localContext = new Function_with_argtypes_listContext(this.context, this.state); - this.enterRule(localContext, 672, PostgreSqlParser.RULE_function_with_argtypes_list); + this.enterRule(localContext, 380, PostgreSqlParser.RULE_function_with_argtypes_list); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6228; + this.state = 4475; this.function_with_argtypes(); - this.state = 6233; + this.state = 4480; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 6229; + this.state = 4476; this.match(PostgreSqlParser.COMMA); - this.state = 6230; + this.state = 4477; this.function_with_argtypes(); } } - this.state = 6235; + this.state = 4482; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -29454,43 +25119,32 @@ export class PostgreSqlParser extends SQLParserBase { } public function_with_argtypes(): Function_with_argtypesContext { let localContext = new Function_with_argtypesContext(this.context, this.state); - this.enterRule(localContext, 674, PostgreSqlParser.RULE_function_with_argtypes); - let _la: number; + this.enterRule(localContext, 382, PostgreSqlParser.RULE_function_with_argtypes); try { - this.state = 6244; + this.state = 4488; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 591, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 553, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 6236; + this.state = 4483; this.function_name(); - this.state = 6237; + this.state = 4484; this.func_args(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 6239; + this.state = 4486; this.type_func_name_keyword(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 6240; - this.colid(); - this.state = 6242; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 4 || _la === 11) { - { - this.state = 6241; - this.indirection(); - } - } - + this.state = 4487; + this.qualified_name(); } break; } @@ -29509,137 +25163,51 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public func_args_with_defaults(): Func_args_with_defaultsContext { - let localContext = new Func_args_with_defaultsContext(this.context, this.state); - this.enterRule(localContext, 676, PostgreSqlParser.RULE_func_args_with_defaults); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6246; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6248; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || _la === 68 || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & 4294967265) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & 4294967295) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & 4294967295) !== 0) || ((((_la - 197)) & ~0x1F) === 0 && ((1 << (_la - 197)) & 4294967295) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { - { - this.state = 6247; - this.func_args_with_defaults_list(); - } - } - - this.state = 6250; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public func_args_with_defaults_list(): Func_args_with_defaults_listContext { - let localContext = new Func_args_with_defaults_listContext(this.context, this.state); - this.enterRule(localContext, 678, PostgreSqlParser.RULE_func_args_with_defaults_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6252; - this.func_arg_with_default(); - this.state = 6257; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 6253; - this.match(PostgreSqlParser.COMMA); - this.state = 6254; - this.func_arg_with_default(); - } - } - this.state = 6259; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public func_arg(): Func_argContext { let localContext = new Func_argContext(this.context, this.state); - this.enterRule(localContext, 680, PostgreSqlParser.RULE_func_arg); + this.enterRule(localContext, 384, PostgreSqlParser.RULE_func_arg); try { - this.state = 6273; + this.enterOuterAlt(localContext, 1); + { + this.state = 4498; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 596, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 556, this.context) ) { case 1: - this.enterOuterAlt(localContext, 1); { - this.state = 6260; + this.state = 4490; this.arg_class(); - this.state = 6262; + this.state = 4492; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 594, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 554, this.context) ) { case 1: { - this.state = 6261; - this.param_name(); + this.state = 4491; + this.type_function_name(); } break; } - this.state = 6264; - this.func_type(); } break; case 2: - this.enterOuterAlt(localContext, 2); { - this.state = 6266; - this.param_name(); - this.state = 6268; + this.state = 4494; + this.type_function_name(); + this.state = 4496; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 595, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 555, this.context) ) { case 1: { - this.state = 6267; + this.state = 4495; this.arg_class(); } break; } - this.state = 6270; - this.func_type(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 6272; - this.func_type(); } break; } + this.state = 4500; + this.func_type(); + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -29657,22 +25225,22 @@ export class PostgreSqlParser extends SQLParserBase { } public arg_class(): Arg_classContext { let localContext = new Arg_classContext(this.context, this.state); - this.enterRule(localContext, 682, PostgreSqlParser.RULE_arg_class); + this.enterRule(localContext, 386, PostgreSqlParser.RULE_arg_class); try { - this.state = 6282; + this.state = 4509; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_IN: this.enterOuterAlt(localContext, 1); { - this.state = 6275; + this.state = 4502; this.match(PostgreSqlParser.KW_IN); - this.state = 6277; + this.state = 4504; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 597, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 557, this.context) ) { case 1: { - this.state = 6276; + this.state = 4503; this.match(PostgreSqlParser.KW_OUT); } break; @@ -29682,21 +25250,21 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_OUT: this.enterOuterAlt(localContext, 2); { - this.state = 6279; + this.state = 4506; this.match(PostgreSqlParser.KW_OUT); } break; case PostgreSqlParser.KW_INOUT: this.enterOuterAlt(localContext, 3); { - this.state = 6280; + this.state = 4507; this.match(PostgreSqlParser.KW_INOUT); } break; case PostgreSqlParser.KW_VARIADIC: this.enterOuterAlt(localContext, 4); { - this.state = 6281; + this.state = 4508; this.match(PostgreSqlParser.KW_VARIADIC); } break; @@ -29718,93 +25286,41 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public param_name(): Param_nameContext { - let localContext = new Param_nameContext(this.context, this.state); - this.enterRule(localContext, 684, PostgreSqlParser.RULE_param_name); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6284; - this.type_function_name(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public func_return(): Func_returnContext { - let localContext = new Func_returnContext(this.context, this.state); - this.enterRule(localContext, 686, PostgreSqlParser.RULE_func_return); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6286; - this.func_type(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public func_type(): Func_typeContext { let localContext = new Func_typeContext(this.context, this.state); - this.enterRule(localContext, 688, PostgreSqlParser.RULE_func_type); + this.enterRule(localContext, 388, PostgreSqlParser.RULE_func_type); + let _la: number; try { - this.state = 6300; + this.state = 4520; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 599, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 560, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 6288; + this.state = 4511; this.typename(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 6289; - this.type_function_name(); - this.state = 6290; - this.attrs(); - this.state = 6291; - this.match(PostgreSqlParser.PERCENT); - this.state = 6292; - this.match(PostgreSqlParser.KW_TYPE); + this.state = 4513; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 415) { + { + this.state = 4512; + this.match(PostgreSqlParser.KW_SETOF); + } } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 6294; - this.match(PostgreSqlParser.KW_SETOF); - this.state = 6295; + + this.state = 4515; this.type_function_name(); - this.state = 6296; + this.state = 4516; this.attrs(); - this.state = 6297; + this.state = 4517; this.match(PostgreSqlParser.PERCENT); - this.state = 6298; + this.state = 4518; this.match(PostgreSqlParser.KW_TYPE); } break; @@ -29826,19 +25342,19 @@ export class PostgreSqlParser extends SQLParserBase { } public func_arg_with_default(): Func_arg_with_defaultContext { let localContext = new Func_arg_with_defaultContext(this.context, this.state); - this.enterRule(localContext, 690, PostgreSqlParser.RULE_func_arg_with_default); + this.enterRule(localContext, 390, PostgreSqlParser.RULE_func_arg_with_default); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6302; + this.state = 4522; this.func_arg(); - this.state = 6305; + this.state = 4525; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 10 || _la === 53) { { - this.state = 6303; + this.state = 4523; _la = this.tokenStream.LA(1); if(!(_la === 10 || _la === 53)) { this.errorHandler.recoverInline(this); @@ -29847,8 +25363,8 @@ export class PostgreSqlParser extends SQLParserBase { this.errorHandler.reportMatch(this); this.consume(); } - this.state = 6304; - this.a_expr(); + this.state = 4524; + this.expression(); } } @@ -29868,407 +25384,480 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public aggr_arg(): Aggr_argContext { - let localContext = new Aggr_argContext(this.context, this.state); - this.enterRule(localContext, 692, PostgreSqlParser.RULE_aggr_arg); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6307; - this.func_arg(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public aggr_args(): Aggr_argsContext { let localContext = new Aggr_argsContext(this.context, this.state); - this.enterRule(localContext, 694, PostgreSqlParser.RULE_aggr_args); + this.enterRule(localContext, 392, PostgreSqlParser.RULE_aggr_args); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6309; + this.state = 4527; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6320; + this.state = 4537; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 601, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.STAR: { - this.state = 6310; + this.state = 4528; this.match(PostgreSqlParser.STAR); } break; - case 2: - { - this.state = 6311; - this.aggr_args_list(); - } - break; - case 3: - { - this.state = 6312; - this.match(PostgreSqlParser.KW_ORDER); - this.state = 6313; - this.match(PostgreSqlParser.KW_BY); - this.state = 6314; - this.aggr_args_list(); - } - break; - case 4: - { - this.state = 6315; - this.aggr_args_list(); - this.state = 6316; - this.match(PostgreSqlParser.KW_ORDER); - this.state = 6317; - this.match(PostgreSqlParser.KW_BY); - this.state = 6318; - this.aggr_args_list(); - } - break; - } - this.state = 6322; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public aggr_args_list(): Aggr_args_listContext { - let localContext = new Aggr_args_listContext(this.context, this.state); - this.enterRule(localContext, 696, PostgreSqlParser.RULE_aggr_args_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6324; - this.aggr_arg(); - this.state = 6329; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 6325; - this.match(PostgreSqlParser.COMMA); - this.state = 6326; - this.aggr_arg(); - } - } - this.state = 6331; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public aggregate_with_argtypes(): Aggregate_with_argtypesContext { - let localContext = new Aggregate_with_argtypesContext(this.context, this.state); - this.enterRule(localContext, 698, PostgreSqlParser.RULE_aggregate_with_argtypes); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6332; - this.function_name(); - this.state = 6333; - this.aggr_args(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public aggregate_with_argtypes_list(): Aggregate_with_argtypes_listContext { - let localContext = new Aggregate_with_argtypes_listContext(this.context, this.state); - this.enterRule(localContext, 700, PostgreSqlParser.RULE_aggregate_with_argtypes_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6335; - this.aggregate_with_argtypes(); - this.state = 6340; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 6336; - this.match(PostgreSqlParser.COMMA); - this.state = 6337; - this.aggregate_with_argtypes(); - } - } - this.state = 6342; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createfunc_opt_list(): Createfunc_opt_listContext { - let localContext = new Createfunc_opt_listContext(this.context, this.state); - this.enterRule(localContext, 702, PostgreSqlParser.RULE_createfunc_opt_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 6344; - this.errorHandler.sync(this); - alternative = 1; - do { - switch (alternative) { - case 1: - { - { - this.state = 6343; - this.createfunc_opt_item(); - } - } - break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 6346; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 604, this.context); - } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public common_func_opt_item(): Common_func_opt_itemContext { - let localContext = new Common_func_opt_itemContext(this.context, this.state); - this.enterRule(localContext, 704, PostgreSqlParser.RULE_common_func_opt_item); - try { - this.state = 6383; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 605, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 6348; - this.match(PostgreSqlParser.KW_CALLED); - this.state = 6349; - this.match(PostgreSqlParser.KW_ON); - this.state = 6350; - this.match(PostgreSqlParser.KW_NULL); - this.state = 6351; - this.match(PostgreSqlParser.KW_INPUT); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 6352; - this.match(PostgreSqlParser.KW_RETURNS); - this.state = 6353; - this.match(PostgreSqlParser.KW_NULL); - this.state = 6354; - this.match(PostgreSqlParser.KW_ON); - this.state = 6355; - this.match(PostgreSqlParser.KW_NULL); - this.state = 6356; - this.match(PostgreSqlParser.KW_INPUT); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 6357; - this.match(PostgreSqlParser.KW_STRICT); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 6358; - this.match(PostgreSqlParser.KW_IMMUTABLE); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 6359; - this.match(PostgreSqlParser.KW_STABLE); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 6360; - this.match(PostgreSqlParser.KW_VOLATILE); - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 6361; - this.match(PostgreSqlParser.KW_EXTERNAL); - this.state = 6362; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 6363; - this.match(PostgreSqlParser.KW_DEFINER); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 6364; - this.match(PostgreSqlParser.KW_EXTERNAL); - this.state = 6365; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 6366; - this.match(PostgreSqlParser.KW_INVOKER); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 6367; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 6368; - this.match(PostgreSqlParser.KW_DEFINER); - } - break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 6369; - this.match(PostgreSqlParser.KW_SECURITY); - this.state = 6370; - this.match(PostgreSqlParser.KW_INVOKER); - } - break; - case 11: - this.enterOuterAlt(localContext, 11); - { - this.state = 6371; - this.match(PostgreSqlParser.KW_LEAKPROOF); - } - break; - case 12: - this.enterOuterAlt(localContext, 12); - { - this.state = 6372; - this.match(PostgreSqlParser.KW_NOT); - this.state = 6373; - this.match(PostgreSqlParser.KW_LEAKPROOF); - } - break; - case 13: - this.enterOuterAlt(localContext, 13); - { - this.state = 6374; - this.match(PostgreSqlParser.KW_COST); - this.state = 6375; - this.numericonly(); - } - break; - case 14: - this.enterOuterAlt(localContext, 14); - { - this.state = 6376; - this.match(PostgreSqlParser.KW_ROWS); - this.state = 6377; - this.numericonly(); - } - break; - case 15: - this.enterOuterAlt(localContext, 15); - { - this.state = 6378; - this.match(PostgreSqlParser.KW_SUPPORT); - this.state = 6379; - this.any_name(); - } - break; - case 16: - this.enterOuterAlt(localContext, 16); + case PostgreSqlParser.CLOSE_PAREN: + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IN: + case PostgreSqlParser.KW_ORDER: + case PostgreSqlParser.KW_VARIADIC: + case PostgreSqlParser.KW_AUTHORIZATION: + case PostgreSqlParser.KW_BINARY: + case PostgreSqlParser.KW_COLLATION: + case PostgreSqlParser.KW_CONCURRENTLY: + case PostgreSqlParser.KW_CROSS: + case PostgreSqlParser.KW_CURRENT_SCHEMA: + case PostgreSqlParser.KW_FREEZE: + case PostgreSqlParser.KW_FULL: + case PostgreSqlParser.KW_ILIKE: + case PostgreSqlParser.KW_INNER: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_ISNULL: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_LIKE: + case PostgreSqlParser.KW_NATURAL: + case PostgreSqlParser.KW_NOTNULL: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_OVERLAPS: + case PostgreSqlParser.KW_RIGHT: + case PostgreSqlParser.KW_SIMILAR: + case PostgreSqlParser.KW_VERBOSE: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_TABLESAMPLE: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: { - this.state = 6380; - this.functionsetresetclause(); + this.state = 4530; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || _la === 68 || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & 4294967265) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & 4294967295) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & 4294967295) !== 0) || ((((_la - 197)) & ~0x1F) === 0 && ((1 << (_la - 197)) & 4294967295) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { + { + this.state = 4529; + this.func_args_list(); + } } - break; - case 17: - this.enterOuterAlt(localContext, 17); - { - this.state = 6381; - this.match(PostgreSqlParser.KW_PARALLEL); - this.state = 6382; - this.colid(); + + this.state = 4535; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 83) { + { + this.state = 4532; + this.match(PostgreSqlParser.KW_ORDER); + this.state = 4533; + this.match(PostgreSqlParser.KW_BY); + this.state = 4534; + this.func_args_list(); + } + } + } break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 4539; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -30285,82 +25874,311 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public createfunc_opt_item(): Createfunc_opt_itemContext { - let localContext = new Createfunc_opt_itemContext(this.context, this.state); - this.enterRule(localContext, 706, PostgreSqlParser.RULE_createfunc_opt_item); + public aggregate_with_argtypes(): Aggregate_with_argtypesContext { + let localContext = new Aggregate_with_argtypesContext(this.context, this.state); + this.enterRule(localContext, 394, PostgreSqlParser.RULE_aggregate_with_argtypes); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 4541; + this.function_name(); + this.state = 4542; + this.aggr_args(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public common_func_opt_item(): Common_func_opt_itemContext { + let localContext = new Common_func_opt_itemContext(this.context, this.state); + this.enterRule(localContext, 396, PostgreSqlParser.RULE_common_func_opt_item); + let _la: number; try { - this.state = 6410; + this.state = 4573; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 607, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_RETURNS: this.enterOuterAlt(localContext, 1); { - this.state = 6385; - this.match(PostgreSqlParser.KW_AS); - this.state = 6386; - this.sconst(); - this.state = 6387; - this.match(PostgreSqlParser.COMMA); - this.state = 6388; - this.sconst(); + this.state = 4547; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_RETURNS: + { + this.state = 4544; + this.match(PostgreSqlParser.KW_RETURNS); + this.state = 4545; + this.match(PostgreSqlParser.KW_NULL); + } + break; + case PostgreSqlParser.KW_CALLED: + { + this.state = 4546; + this.match(PostgreSqlParser.KW_CALLED); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 4549; + this.match(PostgreSqlParser.KW_ON); + this.state = 4550; + this.match(PostgreSqlParser.KW_NULL); + this.state = 4551; + this.match(PostgreSqlParser.KW_INPUT); } break; - case 2: + case PostgreSqlParser.KW_STRICT: this.enterOuterAlt(localContext, 2); { - this.state = 6390; + this.state = 4552; + this.match(PostgreSqlParser.KW_STRICT); + } + break; + case PostgreSqlParser.KW_IMMUTABLE: + this.enterOuterAlt(localContext, 3); + { + this.state = 4553; + this.match(PostgreSqlParser.KW_IMMUTABLE); + } + break; + case PostgreSqlParser.KW_STABLE: + this.enterOuterAlt(localContext, 4); + { + this.state = 4554; + this.match(PostgreSqlParser.KW_STABLE); + } + break; + case PostgreSqlParser.KW_VOLATILE: + this.enterOuterAlt(localContext, 5); + { + this.state = 4555; + this.match(PostgreSqlParser.KW_VOLATILE); + } + break; + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_SECURITY: + this.enterOuterAlt(localContext, 6); + { + this.state = 4557; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 205) { + { + this.state = 4556; + this.match(PostgreSqlParser.KW_EXTERNAL); + } + } + + this.state = 4559; + this.match(PostgreSqlParser.KW_SECURITY); + this.state = 4560; + _la = this.tokenStream.LA(1); + if(!(_la === 181 || _la === 243)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case PostgreSqlParser.KW_LEAKPROOF: + this.enterOuterAlt(localContext, 7); + { + this.state = 4561; + this.match(PostgreSqlParser.KW_LEAKPROOF); + } + break; + case PostgreSqlParser.KW_NOT: + this.enterOuterAlt(localContext, 8); + { + this.state = 4562; + this.match(PostgreSqlParser.KW_NOT); + this.state = 4563; + this.match(PostgreSqlParser.KW_LEAKPROOF); + } + break; + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_ROWS: + this.enterOuterAlt(localContext, 9); + { + this.state = 4564; + _la = this.tokenStream.LA(1); + if(!(_la === 170 || _la === 320)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 4565; + this.numericonly(); + } + break; + case PostgreSqlParser.KW_SUPPORT: + this.enterOuterAlt(localContext, 10); + { + this.state = 4566; + this.match(PostgreSqlParser.KW_SUPPORT); + this.state = 4567; + this.any_name(); + } + break; + case PostgreSqlParser.KW_SET: + this.enterOuterAlt(localContext, 11); + { + this.state = 4568; + this.match(PostgreSqlParser.KW_SET); + this.state = 4569; + this.set_rest_more(); + } + break; + case PostgreSqlParser.KW_RESET: + this.enterOuterAlt(localContext, 12); + { + this.state = 4570; + this.variableresetstmt(); + } + break; + case PostgreSqlParser.KW_PARALLEL: + this.enterOuterAlt(localContext, 13); + { + this.state = 4571; + this.match(PostgreSqlParser.KW_PARALLEL); + this.state = 4572; + this.colid(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public createfunc_opt_item(): Createfunc_opt_itemContext { + let localContext = new Createfunc_opt_itemContext(this.context, this.state); + this.enterRule(localContext, 398, PostgreSqlParser.RULE_createfunc_opt_item); + let _la: number; + try { + this.state = 4610; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 570, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 4575; + this.match(PostgreSqlParser.KW_AS); + this.state = 4576; + this.sconst(); + this.state = 4577; + this.notify_payload(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 4579; this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 6391; + this.state = 4580; this.nonreservedword_or_sconst(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 6392; + this.state = 4581; this.match(PostgreSqlParser.KW_TRANSFORM); - this.state = 6393; - this.transform_type_list(); + this.state = 4582; + this.match(PostgreSqlParser.KW_FOR); + this.state = 4583; + this.match(PostgreSqlParser.KW_TYPE); + this.state = 4584; + this.typename(); + this.state = 4591; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 4585; + this.match(PostgreSqlParser.COMMA); + this.state = 4586; + this.match(PostgreSqlParser.KW_FOR); + this.state = 4587; + this.match(PostgreSqlParser.KW_TYPE); + this.state = 4588; + this.typename(); + } + } + this.state = 4593; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 6394; + this.state = 4594; this.match(PostgreSqlParser.KW_WINDOW); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 6395; + this.state = 4595; this.match(PostgreSqlParser.KW_SET); - this.state = 6396; + this.state = 4596; this.colid(); - this.state = 6403; + this.state = 4603; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_TO: { - this.state = 6397; + this.state = 4597; this.match(PostgreSqlParser.KW_TO); - this.state = 6398; + this.state = 4598; this.colid(); } break; case PostgreSqlParser.EQUAL: { - this.state = 6399; + this.state = 4599; this.match(PostgreSqlParser.EQUAL); - this.state = 6400; + this.state = 4600; this.colid(); } break; case PostgreSqlParser.KW_FROM: { - this.state = 6401; + this.state = 4601; this.match(PostgreSqlParser.KW_FROM); - this.state = 6402; + this.state = 4602; this.match(PostgreSqlParser.KW_CURRENT); } break; @@ -30372,30 +26190,30 @@ export class PostgreSqlParser extends SQLParserBase { case 6: this.enterOuterAlt(localContext, 6); { - this.state = 6405; + this.state = 4605; this.match(PostgreSqlParser.KW_AS); - this.state = 6406; + this.state = 4606; this.colid(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 6407; + this.state = 4607; this.stmt(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 6408; + this.state = 4608; this.common_func_opt_item(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 6409; + this.state = 4609; this.colid(); } break; @@ -30415,64 +26233,15 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public transform_type_list(): Transform_type_listContext { - let localContext = new Transform_type_listContext(this.context, this.state); - this.enterRule(localContext, 708, PostgreSqlParser.RULE_transform_type_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6412; - this.match(PostgreSqlParser.KW_FOR); - this.state = 6413; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 6414; - this.typename(); - this.state = 6421; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 6415; - this.match(PostgreSqlParser.COMMA); - this.state = 6416; - this.match(PostgreSqlParser.KW_FOR); - this.state = 6417; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 6418; - this.typename(); - } - } - this.state = 6423; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public opt_definition(): Opt_definitionContext { let localContext = new Opt_definitionContext(this.context, this.state); - this.enterRule(localContext, 710, PostgreSqlParser.RULE_opt_definition); + this.enterRule(localContext, 400, PostgreSqlParser.RULE_opt_definition); try { this.enterOuterAlt(localContext, 1); { - this.state = 6424; + this.state = 4612; this.match(PostgreSqlParser.KW_WITH); - this.state = 6425; + this.state = 4613; this.definition(); } } @@ -30492,13 +26261,13 @@ export class PostgreSqlParser extends SQLParserBase { } public table_func_column(): Table_func_columnContext { let localContext = new Table_func_columnContext(this.context, this.state); - this.enterRule(localContext, 712, PostgreSqlParser.RULE_table_func_column); + this.enterRule(localContext, 402, PostgreSqlParser.RULE_table_func_column); try { this.enterOuterAlt(localContext, 1); { - this.state = 6427; + this.state = 4615; this.column_name(); - this.state = 6428; + this.state = 4616; this.func_type(); } } @@ -30516,145 +26285,46 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public table_func_column_list(): Table_func_column_listContext { - let localContext = new Table_func_column_listContext(this.context, this.state); - this.enterRule(localContext, 714, PostgreSqlParser.RULE_table_func_column_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6430; - this.table_func_column(); - this.state = 6435; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 6431; - this.match(PostgreSqlParser.COMMA); - this.state = 6432; - this.table_func_column(); - } - } - this.state = 6437; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public alterfunctionstmt(): AlterfunctionstmtContext { let localContext = new AlterfunctionstmtContext(this.context, this.state); - this.enterRule(localContext, 716, PostgreSqlParser.RULE_alterfunctionstmt); + this.enterRule(localContext, 404, PostgreSqlParser.RULE_alterfunctionstmt); try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 6438; + this.state = 4618; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6439; - this.alterFunctionTypeClause(); - this.state = 6440; - this.alterfunc_opt_list(); - this.state = 6442; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 610, this.context) ) { - case 1: - { - this.state = 6441; - this.opt_restrict(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alterFunctionTypeClause(): AlterFunctionTypeClauseContext { - let localContext = new AlterFunctionTypeClauseContext(this.context, this.state); - this.enterRule(localContext, 718, PostgreSqlParser.RULE_alterFunctionTypeClause); - try { - this.state = 6450; + this.state = 4625; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_FUNCTION: - this.enterOuterAlt(localContext, 1); { - this.state = 6444; + this.state = 4619; this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6445; + this.state = 4620; this.function_with_argtypes(); } break; case PostgreSqlParser.KW_PROCEDURE: - this.enterOuterAlt(localContext, 2); { - this.state = 6446; + this.state = 4621; this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 6447; + this.state = 4622; this.procedure_with_argtypes(); } break; case PostgreSqlParser.KW_ROUTINE: - this.enterOuterAlt(localContext, 3); { - this.state = 6448; + this.state = 4623; this.match(PostgreSqlParser.KW_ROUTINE); - this.state = 6449; + this.state = 4624; this.routine_with_argtypes(); } break; default: throw new antlr.NoViableAltException(this); } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alterfunc_opt_list(): Alterfunc_opt_listContext { - let localContext = new Alterfunc_opt_listContext(this.context, this.state); - this.enterRule(localContext, 720, PostgreSqlParser.RULE_alterfunc_opt_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 6453; + this.state = 4628; this.errorHandler.sync(this); alternative = 1; do { @@ -30662,7 +26332,7 @@ export class PostgreSqlParser extends SQLParserBase { case 1: { { - this.state = 6452; + this.state = 4627; this.common_func_opt_item(); } } @@ -30670,34 +26340,20 @@ export class PostgreSqlParser extends SQLParserBase { default: throw new antlr.NoViableAltException(this); } - this.state = 6455; + this.state = 4630; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 612, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 572, this.context); } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + this.state = 4633; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 573, this.context) ) { + case 1: + { + this.state = 4632; + this.match(PostgreSqlParser.KW_RESTRICT); + } + break; } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_restrict(): Opt_restrictContext { - let localContext = new Opt_restrictContext(this.context, this.state); - this.enterRule(localContext, 722, PostgreSqlParser.RULE_opt_restrict); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6457; - this.match(PostgreSqlParser.KW_RESTRICT); } } catch (re) { @@ -30716,105 +26372,83 @@ export class PostgreSqlParser extends SQLParserBase { } public removefuncstmt(): RemovefuncstmtContext { let localContext = new RemovefuncstmtContext(this.context, this.state); - this.enterRule(localContext, 724, PostgreSqlParser.RULE_removefuncstmt); + this.enterRule(localContext, 406, PostgreSqlParser.RULE_removefuncstmt); try { - this.state = 6486; + this.enterOuterAlt(localContext, 1); + { + this.state = 4635; + this.match(PostgreSqlParser.KW_DROP); + this.state = 4651; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 619, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_FUNCTION: { - this.state = 6459; - this.match(PostgreSqlParser.KW_DROP); - this.state = 6460; + this.state = 4636; this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6462; + this.state = 4638; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 613, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 574, this.context) ) { case 1: { - this.state = 6461; + this.state = 4637; this.opt_if_exists(); } break; } - this.state = 6464; + this.state = 4640; this.function_with_argtypes_list(); - this.state = 6466; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 614, this.context) ) { - case 1: - { - this.state = 6465; - this.opt_drop_behavior(); - } - break; - } } break; - case 2: - this.enterOuterAlt(localContext, 2); + case PostgreSqlParser.KW_PROCEDURE: { - this.state = 6468; - this.match(PostgreSqlParser.KW_DROP); - this.state = 6469; + this.state = 4641; this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 6471; + this.state = 4643; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 615, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 575, this.context) ) { case 1: { - this.state = 6470; + this.state = 4642; this.opt_if_exists(); } break; } - this.state = 6473; + this.state = 4645; this.procedure_with_argtypes_list(); - this.state = 6475; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 616, this.context) ) { - case 1: - { - this.state = 6474; - this.opt_drop_behavior(); - } - break; - } } break; - case 3: - this.enterOuterAlt(localContext, 3); + case PostgreSqlParser.KW_ROUTINE: { - this.state = 6477; - this.match(PostgreSqlParser.KW_DROP); - this.state = 6478; + this.state = 4646; this.match(PostgreSqlParser.KW_ROUTINE); - this.state = 6480; + this.state = 4648; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 617, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 576, this.context) ) { case 1: { - this.state = 6479; + this.state = 4647; this.opt_if_exists(); } break; } - this.state = 6482; + this.state = 4650; this.routine_with_argtypes_list(); - this.state = 6484; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 618, this.context) ) { - case 1: - { - this.state = 6483; - this.opt_drop_behavior(); - } - break; } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 4654; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 578, this.context) ) { + case 1: + { + this.state = 4653; + this.opt_drop_behavior(); } break; } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -30832,32 +26466,51 @@ export class PostgreSqlParser extends SQLParserBase { } public removeaggrstmt(): RemoveaggrstmtContext { let localContext = new RemoveaggrstmtContext(this.context, this.state); - this.enterRule(localContext, 726, PostgreSqlParser.RULE_removeaggrstmt); + this.enterRule(localContext, 408, PostgreSqlParser.RULE_removeaggrstmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6488; + this.state = 4656; this.match(PostgreSqlParser.KW_DROP); - this.state = 6489; + this.state = 4657; this.match(PostgreSqlParser.KW_AGGREGATE); - this.state = 6491; + this.state = 4659; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 620, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 579, this.context) ) { case 1: { - this.state = 6490; + this.state = 4658; this.opt_if_exists(); } break; } - this.state = 6493; - this.aggregate_with_argtypes_list(); - this.state = 6495; + { + this.state = 4661; + this.aggregate_with_argtypes(); + this.state = 4666; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 4662; + this.match(PostgreSqlParser.COMMA); + this.state = 4663; + this.aggregate_with_argtypes(); + } + } + this.state = 4668; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + this.state = 4670; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 621, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 581, this.context) ) { case 1: { - this.state = 6494; + this.state = 4669; this.opt_drop_behavior(); } break; @@ -30880,32 +26533,51 @@ export class PostgreSqlParser extends SQLParserBase { } public removeoperstmt(): RemoveoperstmtContext { let localContext = new RemoveoperstmtContext(this.context, this.state); - this.enterRule(localContext, 728, PostgreSqlParser.RULE_removeoperstmt); + this.enterRule(localContext, 410, PostgreSqlParser.RULE_removeoperstmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6497; + this.state = 4672; this.match(PostgreSqlParser.KW_DROP); - this.state = 6498; + this.state = 4673; this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 6500; + this.state = 4675; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 622, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 582, this.context) ) { case 1: { - this.state = 6499; + this.state = 4674; this.opt_if_exists(); } break; } - this.state = 6502; - this.operator_with_argtypes_list(); - this.state = 6504; + { + this.state = 4677; + this.operator_with_argtypes(); + this.state = 4682; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 4678; + this.match(PostgreSqlParser.COMMA); + this.state = 4679; + this.operator_with_argtypes(); + } + } + this.state = 4684; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + this.state = 4686; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 623, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 584, this.context) ) { case 1: { - this.state = 6503; + this.state = 4685; this.opt_drop_behavior(); } break; @@ -30928,68 +26600,58 @@ export class PostgreSqlParser extends SQLParserBase { } public oper_argtypes(): Oper_argtypesContext { let localContext = new Oper_argtypesContext(this.context, this.state); - this.enterRule(localContext, 730, PostgreSqlParser.RULE_oper_argtypes); + this.enterRule(localContext, 412, PostgreSqlParser.RULE_oper_argtypes); + let _la: number; try { - this.state = 6528; + this.enterOuterAlt(localContext, 1); + { + this.state = 4688; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 4701; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 624, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 586, this.context) ) { case 1: - this.enterOuterAlt(localContext, 1); { - this.state = 6506; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6507; + this.state = 4689; this.typename(); - this.state = 6508; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 4692; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 6) { + { + this.state = 4690; + this.match(PostgreSqlParser.COMMA); + this.state = 4691; + this.typename(); + } } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 6510; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6511; - this.typename(); - this.state = 6512; - this.match(PostgreSqlParser.COMMA); - this.state = 6513; - this.typename(); - this.state = 6514; - this.match(PostgreSqlParser.CLOSE_PAREN); + } break; - case 3: - this.enterOuterAlt(localContext, 3); + case 2: { - this.state = 6516; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6517; + this.state = 4694; this.match(PostgreSqlParser.KW_NONE); - this.state = 6518; + this.state = 4695; this.match(PostgreSqlParser.COMMA); - this.state = 6519; + this.state = 4696; this.typename(); - this.state = 6520; - this.match(PostgreSqlParser.CLOSE_PAREN); } break; - case 4: - this.enterOuterAlt(localContext, 4); + case 3: { - this.state = 6522; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6523; + this.state = 4697; this.typename(); - this.state = 6524; + this.state = 4698; this.match(PostgreSqlParser.COMMA); - this.state = 6525; + this.state = 4699; this.match(PostgreSqlParser.KW_NONE); - this.state = 6526; - this.match(PostgreSqlParser.CLOSE_PAREN); } break; } + this.state = 4703; + this.match(PostgreSqlParser.CLOSE_PAREN); + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -31007,28 +26669,28 @@ export class PostgreSqlParser extends SQLParserBase { } public any_operator(): Any_operatorContext { let localContext = new Any_operatorContext(this.context, this.state); - this.enterRule(localContext, 732, PostgreSqlParser.RULE_any_operator); + this.enterRule(localContext, 414, PostgreSqlParser.RULE_any_operator); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6535; + this.state = 4710; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { { { - this.state = 6530; + this.state = 4705; this.colid(); - this.state = 6531; + this.state = 4706; this.match(PostgreSqlParser.DOT); } } - this.state = 6537; + this.state = 4712; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 6538; + this.state = 4713; this.all_op(); } } @@ -31046,31 +26708,16 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public operator_with_argtypes_list(): Operator_with_argtypes_listContext { - let localContext = new Operator_with_argtypes_listContext(this.context, this.state); - this.enterRule(localContext, 734, PostgreSqlParser.RULE_operator_with_argtypes_list); - let _la: number; + public operator_with_argtypes(): Operator_with_argtypesContext { + let localContext = new Operator_with_argtypesContext(this.context, this.state); + this.enterRule(localContext, 416, PostgreSqlParser.RULE_operator_with_argtypes); try { this.enterOuterAlt(localContext, 1); { - this.state = 6540; - this.operator_with_argtypes(); - this.state = 6545; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 6541; - this.match(PostgreSqlParser.COMMA); - this.state = 6542; - this.operator_with_argtypes(); - } - } - this.state = 6547; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } + this.state = 4715; + this.any_operator(); + this.state = 4716; + this.oper_argtypes(); } } catch (re) { @@ -31087,84 +26734,53 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public operator_with_argtypes(): Operator_with_argtypesContext { - let localContext = new Operator_with_argtypesContext(this.context, this.state); - this.enterRule(localContext, 736, PostgreSqlParser.RULE_operator_with_argtypes); + public dostmt(): DostmtContext { + let localContext = new DostmtContext(this.context, this.state); + this.enterRule(localContext, 418, PostgreSqlParser.RULE_dostmt); try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 6548; - this.any_operator(); - this.state = 6549; - this.oper_argtypes(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public dostmt(): DostmtContext { - let localContext = new DostmtContext(this.context, this.state); - this.enterRule(localContext, 738, PostgreSqlParser.RULE_dostmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6551; + this.state = 4718; this.match(PostgreSqlParser.KW_DO); - this.state = 6552; - this.dostmt_opt_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public dostmt_opt_list(): Dostmt_opt_listContext { - let localContext = new Dostmt_opt_listContext(this.context, this.state); - this.enterRule(localContext, 740, PostgreSqlParser.RULE_dostmt_opt_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 6555; + this.state = 4722; this.errorHandler.sync(this); alternative = 1; do { switch (alternative) { case 1: { - { - this.state = 6554; - this.dostmt_opt_item(); + this.state = 4722; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 4719; + this.sconst(); + } + break; + case PostgreSqlParser.KW_LANGUAGE: + { + this.state = 4720; + this.match(PostgreSqlParser.KW_LANGUAGE); + this.state = 4721; + this.nonreservedword_or_sconst(); + } + break; + default: + throw new antlr.NoViableAltException(this); } } break; default: throw new antlr.NoViableAltException(this); } - this.state = 6557; + this.state = 4724; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 627, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 589, this.context); } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); } } @@ -31182,199 +26798,109 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public dostmt_opt_item(): Dostmt_opt_itemContext { - let localContext = new Dostmt_opt_itemContext(this.context, this.state); - this.enterRule(localContext, 742, PostgreSqlParser.RULE_dostmt_opt_item); - try { - this.state = 6562; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); - { - this.state = 6559; - this.sconst(); - } - break; - case PostgreSqlParser.KW_LANGUAGE: - this.enterOuterAlt(localContext, 2); - { - this.state = 6560; - this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 6561; - this.nonreservedword_or_sconst(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } public createcaststmt(): CreatecaststmtContext { let localContext = new CreatecaststmtContext(this.context, this.state); - this.enterRule(localContext, 744, PostgreSqlParser.RULE_createcaststmt); + this.enterRule(localContext, 420, PostgreSqlParser.RULE_createcaststmt); + let _la: number; try { - this.state = 6601; + this.enterOuterAlt(localContext, 1); + { + this.state = 4726; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 4727; + this.match(PostgreSqlParser.KW_CAST); + this.state = 4728; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 4729; + this.typename(); + this.state = 4730; + this.match(PostgreSqlParser.KW_AS); + this.state = 4731; + this.typename(); + this.state = 4732; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 4749; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 632, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_WITHOUT: { - this.state = 6564; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 6565; - this.match(PostgreSqlParser.KW_CAST); - this.state = 6566; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6567; - this.typename(); - this.state = 6568; - this.match(PostgreSqlParser.KW_AS); - this.state = 6569; - this.typename(); - this.state = 6570; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 6571; - this.match(PostgreSqlParser.KW_WITH); - this.state = 6572; + { + this.state = 4733; + this.match(PostgreSqlParser.KW_WITHOUT); + this.state = 4734; this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6573; - this.function_with_argtypes(); - this.state = 6575; + this.state = 4737; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 629, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 590, this.context) ) { case 1: { - this.state = 6574; - this.cast_context(); + this.state = 4735; + this.match(PostgreSqlParser.KW_AS); + this.state = 4736; + _la = this.tokenStream.LA(1); + if(!(_la === 141 || _la === 223)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } } break; } } + } break; - case 2: - this.enterOuterAlt(localContext, 2); + case PostgreSqlParser.KW_WITH: { - this.state = 6577; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 6578; - this.match(PostgreSqlParser.KW_CAST); - this.state = 6579; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6580; - this.typename(); - this.state = 6581; - this.match(PostgreSqlParser.KW_AS); - this.state = 6582; - this.typename(); - this.state = 6583; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 6584; - this.match(PostgreSqlParser.KW_WITHOUT); - this.state = 6585; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6587; + { + this.state = 4739; + this.match(PostgreSqlParser.KW_WITH); + this.state = 4743; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 630, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_FUNCTION: { - this.state = 6586; - this.cast_context(); + this.state = 4740; + this.match(PostgreSqlParser.KW_FUNCTION); + this.state = 4741; + this.function_with_argtypes(); } break; + case PostgreSqlParser.KW_INOUT: + { + this.state = 4742; + this.match(PostgreSqlParser.KW_INOUT); + } + break; + default: + throw new antlr.NoViableAltException(this); } - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 6589; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 6590; - this.match(PostgreSqlParser.KW_CAST); - this.state = 6591; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6592; - this.typename(); - this.state = 6593; - this.match(PostgreSqlParser.KW_AS); - this.state = 6594; - this.typename(); - this.state = 6595; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 6596; - this.match(PostgreSqlParser.KW_WITH); - this.state = 6597; - this.match(PostgreSqlParser.KW_INOUT); - this.state = 6599; + this.state = 4747; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 631, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 592, this.context) ) { case 1: { - this.state = 6598; - this.cast_context(); + this.state = 4745; + this.match(PostgreSqlParser.KW_AS); + this.state = 4746; + _la = this.tokenStream.LA(1); + if(!(_la === 141 || _la === 223)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } } break; } } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public cast_context(): Cast_contextContext { - let localContext = new Cast_contextContext(this.context, this.state); - this.enterRule(localContext, 746, PostgreSqlParser.RULE_cast_context); - try { - this.state = 6607; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 633, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 6603; - this.match(PostgreSqlParser.KW_AS); - this.state = 6604; - this.match(PostgreSqlParser.KW_IMPLICIT); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 6605; - this.match(PostgreSqlParser.KW_AS); - this.state = 6606; - this.match(PostgreSqlParser.KW_ASSIGNMENT); } break; + default: + throw new antlr.NoViableAltException(this); + } } } catch (re) { @@ -31393,13 +26919,13 @@ export class PostgreSqlParser extends SQLParserBase { } public opt_if_exists(): Opt_if_existsContext { let localContext = new Opt_if_existsContext(this.context, this.state); - this.enterRule(localContext, 748, PostgreSqlParser.RULE_opt_if_exists); + this.enterRule(localContext, 422, PostgreSqlParser.RULE_opt_if_exists); try { this.enterOuterAlt(localContext, 1); { - this.state = 6609; + this.state = 4751; this.match(PostgreSqlParser.KW_IF); - this.state = 6610; + this.state = 4752; this.match(PostgreSqlParser.KW_EXISTS); } } @@ -31419,146 +26945,87 @@ export class PostgreSqlParser extends SQLParserBase { } public createtransformstmt(): CreatetransformstmtContext { let localContext = new CreatetransformstmtContext(this.context, this.state); - this.enterRule(localContext, 750, PostgreSqlParser.RULE_createtransformstmt); + this.enterRule(localContext, 424, PostgreSqlParser.RULE_createtransformstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6612; + this.state = 4754; this.match(PostgreSqlParser.KW_CREATE); - this.state = 6614; + this.state = 4756; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 82) { { - this.state = 6613; + this.state = 4755; this.opt_or_replace(); } } - this.state = 6616; + this.state = 4758; this.match(PostgreSqlParser.KW_TRANSFORM); - this.state = 6617; + this.state = 4759; this.match(PostgreSqlParser.KW_FOR); - this.state = 6618; + this.state = 4760; this.typename(); - this.state = 6619; + this.state = 4761; this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 6620; - this.name(); - this.state = 6621; + this.state = 4762; + this.colid(); + this.state = 4763; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6622; - this.transform_element_list(); - this.state = 6623; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public transform_element_list(): Transform_element_listContext { - let localContext = new Transform_element_listContext(this.context, this.state); - this.enterRule(localContext, 752, PostgreSqlParser.RULE_transform_element_list); - try { - this.state = 6659; + this.state = 4778; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 635, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 6625; - this.match(PostgreSqlParser.KW_FROM); - this.state = 6626; - this.match(PostgreSqlParser.KW_SQL); - this.state = 6627; - this.match(PostgreSqlParser.KW_WITH); - this.state = 6628; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6629; - this.function_with_argtypes(); - this.state = 6630; - this.match(PostgreSqlParser.COMMA); - this.state = 6631; - this.match(PostgreSqlParser.KW_TO); - this.state = 6632; - this.match(PostgreSqlParser.KW_SQL); - this.state = 6633; - this.match(PostgreSqlParser.KW_WITH); - this.state = 6634; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6635; - this.function_with_argtypes(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_FROM: { - this.state = 6637; - this.match(PostgreSqlParser.KW_TO); - this.state = 6638; - this.match(PostgreSqlParser.KW_SQL); - this.state = 6639; - this.match(PostgreSqlParser.KW_WITH); - this.state = 6640; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6641; - this.function_with_argtypes(); - this.state = 6642; - this.match(PostgreSqlParser.COMMA); - this.state = 6643; + this.state = 4764; this.match(PostgreSqlParser.KW_FROM); - this.state = 6644; - this.match(PostgreSqlParser.KW_SQL); - this.state = 6645; - this.match(PostgreSqlParser.KW_WITH); - this.state = 6646; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6647; - this.function_with_argtypes(); + this.state = 4765; + this.sql_with_function(); + this.state = 4769; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 6) { + { + this.state = 4766; + this.match(PostgreSqlParser.COMMA); + this.state = 4767; + this.match(PostgreSqlParser.KW_TO); + this.state = 4768; + this.sql_with_function(); + } } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 6649; - this.match(PostgreSqlParser.KW_FROM); - this.state = 6650; - this.match(PostgreSqlParser.KW_SQL); - this.state = 6651; - this.match(PostgreSqlParser.KW_WITH); - this.state = 6652; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6653; - this.function_with_argtypes(); + } break; - case 4: - this.enterOuterAlt(localContext, 4); + case PostgreSqlParser.KW_TO: { - this.state = 6654; + this.state = 4771; this.match(PostgreSqlParser.KW_TO); - this.state = 6655; - this.match(PostgreSqlParser.KW_SQL); - this.state = 6656; - this.match(PostgreSqlParser.KW_WITH); - this.state = 6657; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6658; - this.function_with_argtypes(); + this.state = 4772; + this.sql_with_function(); + this.state = 4776; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 6) { + { + this.state = 4773; + this.match(PostgreSqlParser.COMMA); + this.state = 4774; + this.match(PostgreSqlParser.KW_FROM); + this.state = 4775; + this.sql_with_function(); + } + } + } break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 4780; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -31575,61 +27042,20 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public reindexstmt(): ReindexstmtContext { - let localContext = new ReindexstmtContext(this.context, this.state); - this.enterRule(localContext, 754, PostgreSqlParser.RULE_reindexstmt); + public sql_with_function(): Sql_with_functionContext { + let localContext = new Sql_with_functionContext(this.context, this.state); + this.enterRule(localContext, 426, PostgreSqlParser.RULE_sql_with_function); try { - this.state = 6677; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 636, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 6661; - this.match(PostgreSqlParser.KW_REINDEX); - this.state = 6662; - this.reindex_target_type(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 6663; - this.match(PostgreSqlParser.KW_REINDEX); - this.state = 6664; - this.reindex_target_multitable(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 6665; - this.match(PostgreSqlParser.KW_REINDEX); - this.state = 6666; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6667; - this.reindex_option_list(); - this.state = 6668; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 6669; - this.reindex_target_type(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 6671; - this.match(PostgreSqlParser.KW_REINDEX); - this.state = 6672; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 6673; - this.reindex_option_list(); - this.state = 6674; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 6675; - this.reindex_target_multitable(); - } - break; + this.enterOuterAlt(localContext, 1); + { + this.state = 4782; + this.match(PostgreSqlParser.KW_SQL); + this.state = 4783; + this.match(PostgreSqlParser.KW_WITH); + this.state = 4784; + this.match(PostgreSqlParser.KW_FUNCTION); + this.state = 4785; + this.function_with_argtypes(); } } catch (re) { @@ -31646,148 +27072,144 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public reindex_target_type(): Reindex_target_typeContext { - let localContext = new Reindex_target_typeContext(this.context, this.state); - this.enterRule(localContext, 756, PostgreSqlParser.RULE_reindex_target_type); + public reindexstmt(): ReindexstmtContext { + let localContext = new ReindexstmtContext(this.context, this.state); + this.enterRule(localContext, 428, PostgreSqlParser.RULE_reindexstmt); let _la: number; try { - this.state = 6689; + this.enterOuterAlt(localContext, 1); + { + this.state = 4787; + this.match(PostgreSqlParser.KW_REINDEX); + this.state = 4798; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 4788; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 4789; + this.match(PostgreSqlParser.KW_VERBOSE); + this.state = 4794; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 4790; + this.match(PostgreSqlParser.COMMA); + this.state = 4791; + this.match(PostgreSqlParser.KW_VERBOSE); + } + } + this.state = 4796; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 4797; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + } + + { + this.state = 4825; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_INDEX: - this.enterOuterAlt(localContext, 1); { - { - this.state = 6679; + this.state = 4800; this.match(PostgreSqlParser.KW_INDEX); - this.state = 6681; + this.state = 4802; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 109) { { - this.state = 6680; - this.opt_concurrently(); + this.state = 4801; + this.match(PostgreSqlParser.KW_CONCURRENTLY); } } - this.state = 6683; + this.state = 4804; this.qualified_name(); } - } break; case PostgreSqlParser.KW_TABLE: - this.enterOuterAlt(localContext, 2); - { { - this.state = 6684; + this.state = 4805; this.match(PostgreSqlParser.KW_TABLE); - this.state = 6686; + this.state = 4807; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 109) { { - this.state = 6685; - this.opt_concurrently(); + this.state = 4806; + this.match(PostgreSqlParser.KW_CONCURRENTLY); } } - this.state = 6688; + this.state = 4809; this.table_name(); } - } break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public reindex_target_multitable(): Reindex_target_multitableContext { - let localContext = new Reindex_target_multitableContext(this.context, this.state); - this.enterRule(localContext, 758, PostgreSqlParser.RULE_reindex_target_multitable); - let _la: number; - try { - this.state = 6706; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_SCHEMA: - this.enterOuterAlt(localContext, 1); - { { - this.state = 6691; + this.state = 4810; this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 6693; + this.state = 4812; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 109) { { - this.state = 6692; - this.opt_concurrently(); + this.state = 4811; + this.match(PostgreSqlParser.KW_CONCURRENTLY); } } - this.state = 6695; + this.state = 4814; this.schema_name(); } - } break; case PostgreSqlParser.KW_SYSTEM: - this.enterOuterAlt(localContext, 2); - { { - this.state = 6696; + this.state = 4815; this.match(PostgreSqlParser.KW_SYSTEM); - this.state = 6698; + this.state = 4817; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 109) { { - this.state = 6697; - this.opt_concurrently(); + this.state = 4816; + this.match(PostgreSqlParser.KW_CONCURRENTLY); } } - this.state = 6700; - this.name(); - } + this.state = 4819; + this.colid(); } break; case PostgreSqlParser.KW_DATABASE: - this.enterOuterAlt(localContext, 3); - { { - this.state = 6701; + this.state = 4820; this.match(PostgreSqlParser.KW_DATABASE); - this.state = 6703; + this.state = 4822; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); if (_la === 109) { { - this.state = 6702; - this.opt_concurrently(); + this.state = 4821; + this.match(PostgreSqlParser.KW_CONCURRENTLY); } } - this.state = 6705; + this.state = 4824; this.database_name(); } - } break; default: throw new antlr.NoViableAltException(this); } + } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -31803,55 +27225,28 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public reindex_option_list(): Reindex_option_listContext { - let localContext = new Reindex_option_listContext(this.context, this.state); - this.enterRule(localContext, 760, PostgreSqlParser.RULE_reindex_option_list); + public altertblspcstmt(): AltertblspcstmtContext { + let localContext = new AltertblspcstmtContext(this.context, this.state); + this.enterRule(localContext, 430, PostgreSqlParser.RULE_altertblspcstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 6708; - this.reindex_option_elem(); - this.state = 6713; - this.errorHandler.sync(this); + this.state = 4827; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 4828; + this.opttablespace(); + this.state = 4829; _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 6709; - this.match(PostgreSqlParser.COMMA); - this.state = 6710; - this.reindex_option_elem(); - } - } - this.state = 6715; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } + if(!(_la === 313 || _la === 333)) { + this.errorHandler.recoverInline(this); } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + else { + this.errorHandler.reportMatch(this); + this.consume(); } - } - finally { - this.exitRule(); - } - return localContext; - } - public reindex_option_elem(): Reindex_option_elemContext { - let localContext = new Reindex_option_elemContext(this.context, this.state); - this.enterRule(localContext, 762, PostgreSqlParser.RULE_reindex_option_elem); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 6716; - this.match(PostgreSqlParser.KW_VERBOSE); + this.state = 4830; + this.reloptions(); } } catch (re) { @@ -31868,1050 +27263,1005 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public altertblspcstmt(): AltertblspcstmtContext { - let localContext = new AltertblspcstmtContext(this.context, this.state); - this.enterRule(localContext, 764, PostgreSqlParser.RULE_altertblspcstmt); + public renamestmt(): RenamestmtContext { + let localContext = new RenamestmtContext(this.context, this.state); + this.enterRule(localContext, 432, PostgreSqlParser.RULE_renamestmt); + let _la: number; try { - this.state = 6730; + this.state = 5039; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 645, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 626, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 6718; + this.state = 4832; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6719; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 6720; - this.tablespace_name(); - this.state = 6721; - this.match(PostgreSqlParser.KW_SET); - this.state = 6722; - this.reloptions(); + this.state = 4837; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AGGREGATE: + { + this.state = 4833; + this.match(PostgreSqlParser.KW_AGGREGATE); + this.state = 4834; + this.aggregate_with_argtypes(); + } + break; + case PostgreSqlParser.KW_ROUTINE: + { + this.state = 4835; + this.match(PostgreSqlParser.KW_ROUTINE); + this.state = 4836; + this.routine_with_argtypes(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 4839; + this.match(PostgreSqlParser.KW_RENAME); + this.state = 4840; + this.match(PostgreSqlParser.KW_TO); + this.state = 4841; + this.colid(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 6724; + this.state = 4843; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6725; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 6726; - this.tablespace_name(); - this.state = 6727; - this.match(PostgreSqlParser.KW_RESET); - this.state = 6728; - this.reloptions(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public renamestmt(): RenamestmtContext { - let localContext = new RenamestmtContext(this.context, this.state); - this.enterRule(localContext, 766, PostgreSqlParser.RULE_renamestmt); - let _la: number; - try { - this.state = 7123; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 664, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 6732; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6733; - this.match(PostgreSqlParser.KW_AGGREGATE); - this.state = 6734; - this.aggregate_with_argtypes(); - this.state = 6735; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6736; - this.match(PostgreSqlParser.KW_TO); - this.state = 6737; - this.name(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 6739; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6740; - this.match(PostgreSqlParser.KW_COLLATION); - this.state = 6741; - this.any_name(); - this.state = 6742; + this.state = 4844; + this.match(PostgreSqlParser.KW_DATABASE); + this.state = 4845; + this.database_name(); + this.state = 4846; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6743; + this.state = 4847; this.match(PostgreSqlParser.KW_TO); - this.state = 6744; - this.name(); + this.state = 4848; + this.database_name_create(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 6746; + this.state = 4850; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6747; - this.match(PostgreSqlParser.KW_CONVERSION); - this.state = 6748; + this.state = 4851; + _la = this.tokenStream.LA(1); + if(!(_la === 108 || _la === 168 || _la === 189 || _la === 342 || _la === 360)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 4852; this.any_name(); - this.state = 6749; + this.state = 4853; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6750; + this.state = 4854; this.match(PostgreSqlParser.KW_TO); - this.state = 6751; - this.name(); + this.state = 4855; + this.colid(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 6753; + this.state = 4857; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6754; - this.match(PostgreSqlParser.KW_DATABASE); - this.state = 6755; - this.database_name(); - this.state = 6756; + this.state = 4858; + this.match(PostgreSqlParser.KW_FUNCTION); + this.state = 4859; + this.function_with_argtypes(); + this.state = 4860; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6757; + this.state = 4861; this.match(PostgreSqlParser.KW_TO); - this.state = 6758; - this.database_name_create(); + this.state = 4862; + this.function_name_create(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 6760; + this.state = 4864; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6761; - this.match(PostgreSqlParser.KW_DOMAIN); - this.state = 6762; + this.state = 4865; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 4866; + _la = this.tokenStream.LA(1); + if(!(_la === 156 || _la === 206)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 4867; this.any_name(); - this.state = 6763; + this.state = 4868; + this.table_access_method_clause(); + this.state = 4869; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6764; + this.state = 4870; this.match(PostgreSqlParser.KW_TO); - this.state = 6765; - this.name(); + this.state = 4871; + this.colid(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 6767; + this.state = 4873; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6768; - this.match(PostgreSqlParser.KW_DOMAIN); - this.state = 6769; - this.any_name(); - this.state = 6770; + this.state = 4874; + this.match(PostgreSqlParser.KW_PROCEDURE); + this.state = 4875; + this.procedure_with_argtypes(); + this.state = 4876; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6771; - this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 6772; - this.name(); - this.state = 6773; + this.state = 4877; this.match(PostgreSqlParser.KW_TO); - this.state = 6774; - this.name(); + this.state = 4878; + this.procedure_name_create(); } break; case 7: this.enterOuterAlt(localContext, 7); { - this.state = 6776; + this.state = 4880; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6777; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 6778; - this.match(PostgreSqlParser.KW_DATA); - this.state = 6779; - this.match(PostgreSqlParser.KW_WRAPPER); - this.state = 6780; - this.name(); - this.state = 6781; + this.state = 4881; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 4882; + this.schema_name(); + this.state = 4883; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6782; + this.state = 4884; this.match(PostgreSqlParser.KW_TO); - this.state = 6783; - this.name(); + this.state = 4885; + this.schema_name_create(); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 6785; + this.state = 4887; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6786; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 6787; - this.function_with_argtypes(); - this.state = 6788; + this.state = 4888; + _la = this.tokenStream.LA(1); + if(!(_la === 226 || _la === 328)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 4890; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 607, this.context) ) { + case 1: + { + this.state = 4889; + this.opt_if_exists(); + } + break; + } + this.state = 4892; + this.qualified_name(); + this.state = 4893; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6789; + this.state = 4894; this.match(PostgreSqlParser.KW_TO); - this.state = 6790; - this.function_name_create(); + this.state = 4895; + this.colid(); } break; case 9: this.enterOuterAlt(localContext, 9); { - this.state = 6792; + this.state = 4897; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6793; - this.match(PostgreSqlParser.KW_GROUP); - this.state = 6794; - this.roleid(); - this.state = 6795; + this.state = 4899; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 259) { + { + this.state = 4898; + this.match(PostgreSqlParser.KW_MATERIALIZED); + } + } + + this.state = 4901; + this.match(PostgreSqlParser.KW_VIEW); + this.state = 4903; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 609, this.context) ) { + case 1: + { + this.state = 4902; + this.opt_if_exists(); + } + break; + } + this.state = 4905; + this.view_name(); + this.state = 4906; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6796; + this.state = 4907; this.match(PostgreSqlParser.KW_TO); - this.state = 6797; - this.roleid(); + this.state = 4908; + this.view_name_create(); } break; case 10: this.enterOuterAlt(localContext, 10); { - this.state = 6799; + this.state = 4910; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6801; + this.state = 4912; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 295) { + if (_la === 63) { { - this.state = 6800; - this.opt_procedural(); + this.state = 4911; + this.match(PostgreSqlParser.KW_FOREIGN); } } - this.state = 6803; - this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 6804; - this.name(); - this.state = 6805; + this.state = 4914; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 4916; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 611, this.context) ) { + case 1: + { + this.state = 4915; + this.opt_if_exists(); + } + break; + } + this.state = 4918; + this.relation_expr(); + this.state = 4919; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6806; + this.state = 4920; this.match(PostgreSqlParser.KW_TO); - this.state = 6807; - this.name(); + this.state = 4921; + this.table_name_create(); } break; case 11: this.enterOuterAlt(localContext, 11); { - this.state = 6809; + this.state = 4923; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6810; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 6811; - this.match(PostgreSqlParser.KW_CLASS); - this.state = 6812; - this.any_name(); - this.state = 6813; - this.match(PostgreSqlParser.KW_USING); - this.state = 6814; - this.name(); - this.state = 6815; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6816; + this.state = 4948; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_FOREIGN: + case PostgreSqlParser.KW_TABLE: + { + this.state = 4925; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 63) { + { + this.state = 4924; + this.match(PostgreSqlParser.KW_FOREIGN); + } + } + + this.state = 4927; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 4929; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 613, this.context) ) { + case 1: + { + this.state = 4928; + this.opt_if_exists(); + } + break; + } + this.state = 4931; + this.relation_expr(); + this.state = 4932; + this.match(PostgreSqlParser.KW_RENAME); + this.state = 4934; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 614, this.context) ) { + case 1: + { + this.state = 4933; + this.match(PostgreSqlParser.KW_COLUMN); + } + break; + } + } + break; + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_VIEW: + { + this.state = 4937; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 259) { + { + this.state = 4936; + this.match(PostgreSqlParser.KW_MATERIALIZED); + } + } + + this.state = 4939; + this.match(PostgreSqlParser.KW_VIEW); + this.state = 4941; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 616, this.context) ) { + case 1: + { + this.state = 4940; + this.opt_if_exists(); + } + break; + } + this.state = 4943; + this.view_name(); + this.state = 4944; + this.match(PostgreSqlParser.KW_RENAME); + this.state = 4946; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 617, this.context) ) { + case 1: + { + this.state = 4945; + this.match(PostgreSqlParser.KW_COLUMN); + } + break; + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 4950; + this.column_name(); + this.state = 4951; this.match(PostgreSqlParser.KW_TO); - this.state = 6817; - this.name(); + this.state = 4952; + this.column_name_create(); } break; case 12: this.enterOuterAlt(localContext, 12); { - this.state = 6819; + this.state = 4954; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6820; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 6821; - this.match(PostgreSqlParser.KW_FAMILY); - this.state = 6822; - this.any_name(); - this.state = 6823; - this.match(PostgreSqlParser.KW_USING); - this.state = 6824; - this.name(); - this.state = 6825; + this.state = 4962; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_TABLE: + { + this.state = 4955; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 4957; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 619, this.context) ) { + case 1: + { + this.state = 4956; + this.opt_if_exists(); + } + break; + } + this.state = 4959; + this.relation_expr(); + } + break; + case PostgreSqlParser.KW_DOMAIN: + { + this.state = 4960; + this.match(PostgreSqlParser.KW_DOMAIN); + this.state = 4961; + this.any_name(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 4964; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6826; + this.state = 4965; + this.match(PostgreSqlParser.KW_CONSTRAINT); + this.state = 4966; + this.colid(); + this.state = 4967; this.match(PostgreSqlParser.KW_TO); - this.state = 6827; - this.name(); + this.state = 4968; + this.colid(); } break; case 13: this.enterOuterAlt(localContext, 13); { - this.state = 6829; + this.state = 4970; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6830; - this.match(PostgreSqlParser.KW_POLICY); - this.state = 6832; + this.state = 4977; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 647, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_POLICY: { - this.state = 6831; - this.opt_if_exists(); + { + this.state = 4971; + this.match(PostgreSqlParser.KW_POLICY); + this.state = 4973; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 621, this.context) ) { + case 1: + { + this.state = 4972; + this.opt_if_exists(); + } + break; + } + } + } + break; + case PostgreSqlParser.KW_RULE: + { + this.state = 4975; + this.match(PostgreSqlParser.KW_RULE); + } + break; + case PostgreSqlParser.KW_TRIGGER: + { + this.state = 4976; + this.match(PostgreSqlParser.KW_TRIGGER); } break; + default: + throw new antlr.NoViableAltException(this); } - this.state = 6834; - this.name(); - this.state = 6835; + this.state = 4979; + this.colid(); + this.state = 4980; this.match(PostgreSqlParser.KW_ON); - this.state = 6836; + this.state = 4981; this.qualified_name(); - this.state = 6837; + this.state = 4982; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6838; + this.state = 4983; this.match(PostgreSqlParser.KW_TO); - this.state = 6839; - this.name(); + this.state = 4984; + this.colid(); } break; case 14: this.enterOuterAlt(localContext, 14); { - this.state = 6841; + this.state = 4986; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6842; - this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 6843; - this.procedure_with_argtypes(); - this.state = 6844; + this.state = 4999; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_FOREIGN: + { + this.state = 4987; + this.match(PostgreSqlParser.KW_FOREIGN); + this.state = 4988; + this.match(PostgreSqlParser.KW_DATA); + this.state = 4989; + this.match(PostgreSqlParser.KW_WRAPPER); + } + break; + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_PROCEDURAL: + { + this.state = 4991; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 295) { + { + this.state = 4990; + this.match(PostgreSqlParser.KW_PROCEDURAL); + } + } + + this.state = 4993; + this.match(PostgreSqlParser.KW_LANGUAGE); + } + break; + case PostgreSqlParser.KW_PUBLICATION: + { + this.state = 4994; + this.match(PostgreSqlParser.KW_PUBLICATION); + } + break; + case PostgreSqlParser.KW_SERVER: + { + this.state = 4995; + this.match(PostgreSqlParser.KW_SERVER); + } + break; + case PostgreSqlParser.KW_SUBSCRIPTION: + { + this.state = 4996; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); + } + break; + case PostgreSqlParser.KW_EVENT: + { + this.state = 4997; + this.match(PostgreSqlParser.KW_EVENT); + this.state = 4998; + this.match(PostgreSqlParser.KW_TRIGGER); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 5001; + this.colid(); + this.state = 5002; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6845; + this.state = 5003; this.match(PostgreSqlParser.KW_TO); - this.state = 6846; - this.procedure_name_create(); + this.state = 5004; + this.colid(); } break; case 15: this.enterOuterAlt(localContext, 15); { - this.state = 6848; + this.state = 5006; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6849; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 6850; - this.name(); - this.state = 6851; + this.state = 5007; + _la = this.tokenStream.LA(1); + if(!(_la === 66 || _la === 99 || _la === 318)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5008; + this.rolespec(); + this.state = 5009; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6852; + this.state = 5010; this.match(PostgreSqlParser.KW_TO); - this.state = 6853; - this.name(); + this.state = 5011; + this.rolespec(); } break; case 16: this.enterOuterAlt(localContext, 16); { - this.state = 6855; + this.state = 5013; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6856; - this.match(PostgreSqlParser.KW_ROUTINE); - this.state = 6857; - this.routine_with_argtypes(); - this.state = 6858; + this.state = 5014; + this.opttablespace(); + this.state = 5015; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6859; + this.state = 5016; this.match(PostgreSqlParser.KW_TO); - this.state = 6860; - this.name(); + this.state = 5017; + this.tablespace_name_create(); } break; case 17: this.enterOuterAlt(localContext, 17); { - this.state = 6862; + this.state = 5019; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6863; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 6864; - this.schema_name(); - this.state = 6865; + this.state = 5020; + this.match(PostgreSqlParser.KW_TEXT); + this.state = 5021; + this.match(PostgreSqlParser.KW_SEARCH); + this.state = 5022; + _la = this.tokenStream.LA(1); + if(!(_la === 163 || _la === 185 || _la === 283 || _la === 353)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5023; + this.any_name(); + this.state = 5024; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6866; + this.state = 5025; this.match(PostgreSqlParser.KW_TO); - this.state = 6867; - this.schema_name_create(); + this.state = 5026; + this.colid(); } break; case 18: this.enterOuterAlt(localContext, 18); { - this.state = 6869; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6870; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 6871; - this.name(); - this.state = 6872; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6873; - this.match(PostgreSqlParser.KW_TO); - this.state = 6874; - this.name(); - } - break; - case 19: - this.enterOuterAlt(localContext, 19); - { - this.state = 6876; + this.state = 5028; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6877; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 6878; - this.name(); - this.state = 6879; + this.state = 5029; + this.match(PostgreSqlParser.KW_TYPE); + this.state = 5030; + this.any_name(); + this.state = 5031; this.match(PostgreSqlParser.KW_RENAME); - this.state = 6880; + this.state = 5032; + this.match(PostgreSqlParser.KW_ATTRIBUTE); + this.state = 5033; + this.colid(); + this.state = 5034; this.match(PostgreSqlParser.KW_TO); - this.state = 6881; - this.name(); - } - break; - case 20: - this.enterOuterAlt(localContext, 20); - { - this.state = 6883; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6884; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 6886; + this.state = 5035; + this.colid(); + this.state = 5037; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 648, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 625, this.context) ) { case 1: { - this.state = 6885; - this.opt_if_exists(); + this.state = 5036; + this.opt_drop_behavior(); } break; } - this.state = 6888; - this.relation_expr(); - this.state = 6889; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6890; - this.match(PostgreSqlParser.KW_TO); - this.state = 6891; - this.table_name_create(); } break; - case 21: - this.enterOuterAlt(localContext, 21); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public alterobjectdependsstmt(): AlterobjectdependsstmtContext { + let localContext = new AlterobjectdependsstmtContext(this.context, this.state); + this.enterRule(localContext, 434, PostgreSqlParser.RULE_alterobjectdependsstmt); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 5041; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5058; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_FUNCTION: { - this.state = 6893; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6894; - this.match(PostgreSqlParser.KW_SEQUENCE); - this.state = 6896; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 649, this.context) ) { - case 1: - { - this.state = 6895; - this.opt_if_exists(); - } - break; - } - this.state = 6898; - this.qualified_name(); - this.state = 6899; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6900; - this.match(PostgreSqlParser.KW_TO); - this.state = 6901; - this.name(); + this.state = 5042; + this.match(PostgreSqlParser.KW_FUNCTION); + this.state = 5043; + this.function_with_argtypes(); } break; - case 22: - this.enterOuterAlt(localContext, 22); + case PostgreSqlParser.KW_PROCEDURE: { - this.state = 6903; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6904; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 6906; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 650, this.context) ) { - case 1: - { - this.state = 6905; - this.opt_if_exists(); - } - break; + this.state = 5044; + this.match(PostgreSqlParser.KW_PROCEDURE); + this.state = 5045; + this.procedure_with_argtypes(); } - this.state = 6908; - this.view_name(); - this.state = 6909; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6910; - this.match(PostgreSqlParser.KW_TO); - this.state = 6911; - this.view_name_create(); + break; + case PostgreSqlParser.KW_ROUTINE: + { + this.state = 5046; + this.match(PostgreSqlParser.KW_ROUTINE); + this.state = 5047; + this.routine_with_argtypes(); } break; - case 23: - this.enterOuterAlt(localContext, 23); + case PostgreSqlParser.KW_TRIGGER: { - this.state = 6913; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6914; + this.state = 5048; + this.match(PostgreSqlParser.KW_TRIGGER); + this.state = 5049; + this.colid(); + this.state = 5050; + this.match(PostgreSqlParser.KW_ON); + this.state = 5051; + this.qualified_name(); + } + break; + case PostgreSqlParser.KW_MATERIALIZED: + { + this.state = 5053; this.match(PostgreSqlParser.KW_MATERIALIZED); - this.state = 6915; + this.state = 5054; this.match(PostgreSqlParser.KW_VIEW); - this.state = 6917; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 651, this.context) ) { - case 1: - { - this.state = 6916; - this.opt_if_exists(); - } - break; - } - this.state = 6919; + this.state = 5055; this.view_name(); - this.state = 6920; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6921; - this.match(PostgreSqlParser.KW_TO); - this.state = 6922; - this.view_name_create(); } break; - case 24: - this.enterOuterAlt(localContext, 24); + case PostgreSqlParser.KW_INDEX: { - this.state = 6924; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6925; + this.state = 5056; this.match(PostgreSqlParser.KW_INDEX); - this.state = 6927; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 652, this.context) ) { - case 1: - { - this.state = 6926; - this.opt_if_exists(); - } - break; - } - this.state = 6929; + this.state = 5057; this.qualified_name(); - this.state = 6930; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6931; - this.match(PostgreSqlParser.KW_TO); - this.state = 6932; - this.name(); } break; - case 25: - this.enterOuterAlt(localContext, 25); + default: + throw new antlr.NoViableAltException(this); + } + this.state = 5061; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269) { { - this.state = 6934; + this.state = 5060; + this.match(PostgreSqlParser.KW_NO); + } + } + + this.state = 5063; + this.match(PostgreSqlParser.KW_DEPENDS); + this.state = 5064; + this.match(PostgreSqlParser.KW_ON); + this.state = 5065; + this.match(PostgreSqlParser.KW_EXTENSION); + this.state = 5066; + this.colid(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public alterobjectschemastmt(): AlterobjectschemastmtContext { + let localContext = new AlterobjectschemastmtContext(this.context, this.state); + this.enterRule(localContext, 436, PostgreSqlParser.RULE_alterobjectschemastmt); + let _la: number; + try { + this.state = 5129; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 636, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 5068; this.match(PostgreSqlParser.KW_ALTER); - this.state = 6935; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 6936; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 6938; + this.state = 5107; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 653, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 634, this.context) ) { case 1: { - this.state = 6937; - this.opt_if_exists(); + this.state = 5069; + this.match(PostgreSqlParser.KW_AGGREGATE); + this.state = 5070; + this.aggregate_with_argtypes(); } break; - } - this.state = 6940; - this.relation_expr(); - this.state = 6941; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6942; - this.match(PostgreSqlParser.KW_TO); - this.state = 6943; - this.table_name_create(); - } - break; - case 26: - this.enterOuterAlt(localContext, 26); - { - this.state = 6945; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6946; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 6948; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 654, this.context) ) { - case 1: + case 2: { - this.state = 6947; - this.opt_if_exists(); + this.state = 5071; + this.match(PostgreSqlParser.KW_EXTENSION); + this.state = 5072; + this.colid(); } break; - } - this.state = 6950; - this.relation_expr(); - this.state = 6951; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6953; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 655, this.context) ) { - case 1: + case 3: { - this.state = 6952; - this.match(PostgreSqlParser.KW_COLUMN); + this.state = 5073; + this.match(PostgreSqlParser.KW_FUNCTION); + this.state = 5074; + this.function_with_argtypes(); } break; - } - this.state = 6955; - this.column_name(); - this.state = 6956; - this.match(PostgreSqlParser.KW_TO); - this.state = 6957; - this.column_name_create(); - } - break; - case 27: - this.enterOuterAlt(localContext, 27); - { - this.state = 6959; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6960; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 6962; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 656, this.context) ) { - case 1: + case 4: { - this.state = 6961; - this.opt_if_exists(); + this.state = 5075; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 5076; + this.operator_with_argtypes(); } break; - } - this.state = 6964; - this.view_name(); - this.state = 6965; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6967; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 657, this.context) ) { - case 1: + case 5: { - this.state = 6966; - this.match(PostgreSqlParser.KW_COLUMN); + this.state = 5077; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 5078; + _la = this.tokenStream.LA(1); + if(!(_la === 156 || _la === 206)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5079; + this.any_name(); + this.state = 5080; + this.table_access_method_clause(); } break; - } - this.state = 6969; - this.column_name(); - this.state = 6970; - this.match(PostgreSqlParser.KW_TO); - this.state = 6971; - this.column_name_create(); - } - break; - case 28: - this.enterOuterAlt(localContext, 28); - { - this.state = 6973; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6974; - this.match(PostgreSqlParser.KW_MATERIALIZED); - this.state = 6975; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 6977; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 658, this.context) ) { - case 1: + case 6: { - this.state = 6976; - this.opt_if_exists(); + this.state = 5082; + this.match(PostgreSqlParser.KW_PROCEDURE); + this.state = 5083; + this.procedure_with_argtypes(); } break; - } - this.state = 6979; - this.view_name(); - this.state = 6980; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6982; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 659, this.context) ) { - case 1: + case 7: { - this.state = 6981; - this.match(PostgreSqlParser.KW_COLUMN); + this.state = 5084; + this.match(PostgreSqlParser.KW_ROUTINE); + this.state = 5085; + this.routine_with_argtypes(); } break; - } - this.state = 6984; - this.column_name(); - this.state = 6985; - this.match(PostgreSqlParser.KW_TO); - this.state = 6986; - this.column_name_create(); - } - break; - case 29: - this.enterOuterAlt(localContext, 29); - { - this.state = 6988; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 6989; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 6991; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 660, this.context) ) { - case 1: + case 8: { - this.state = 6990; - this.opt_if_exists(); + this.state = 5086; + this.match(PostgreSqlParser.KW_SEQUENCE); + this.state = 5088; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 629, this.context) ) { + case 1: + { + this.state = 5087; + this.opt_if_exists(); + } + break; + } + this.state = 5090; + this.qualified_name(); } break; - } - this.state = 6993; - this.relation_expr(); - this.state = 6994; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 6995; - this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 6996; - this.name(); - this.state = 6997; - this.match(PostgreSqlParser.KW_TO); - this.state = 6998; - this.name(); - } - break; - case 30: - this.enterOuterAlt(localContext, 30); - { - this.state = 7000; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7001; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 7002; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 7004; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 661, this.context) ) { - case 1: + case 9: { - this.state = 7003; - this.opt_if_exists(); + this.state = 5092; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 259) { + { + this.state = 5091; + this.match(PostgreSqlParser.KW_MATERIALIZED); + } + } + + this.state = 5094; + this.match(PostgreSqlParser.KW_VIEW); + this.state = 5096; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 631, this.context) ) { + case 1: + { + this.state = 5095; + this.opt_if_exists(); + } + break; + } + this.state = 5098; + this.view_name(); } break; - } - this.state = 7006; - this.relation_expr(); - this.state = 7007; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7009; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 662, this.context) ) { - case 1: + case 10: { - this.state = 7008; - this.match(PostgreSqlParser.KW_COLUMN); + this.state = 5100; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 63) { + { + this.state = 5099; + this.match(PostgreSqlParser.KW_FOREIGN); + } + } + + this.state = 5102; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 5104; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 633, this.context) ) { + case 1: + { + this.state = 5103; + this.opt_if_exists(); + } + break; + } + this.state = 5106; + this.relation_expr(); } break; } - this.state = 7011; - this.column_name(); - this.state = 7012; - this.match(PostgreSqlParser.KW_TO); - this.state = 7013; - this.column_name_create(); - } - break; - case 31: - this.enterOuterAlt(localContext, 31); - { - this.state = 7015; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7016; - this.match(PostgreSqlParser.KW_RULE); - this.state = 7017; - this.name(); - this.state = 7018; - this.match(PostgreSqlParser.KW_ON); - this.state = 7019; - this.qualified_name(); - this.state = 7020; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7021; - this.match(PostgreSqlParser.KW_TO); - this.state = 7022; - this.name(); - } - break; - case 32: - this.enterOuterAlt(localContext, 32); - { - this.state = 7024; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7025; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 7026; - this.name(); - this.state = 7027; - this.match(PostgreSqlParser.KW_ON); - this.state = 7028; - this.qualified_name(); - this.state = 7029; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7030; - this.match(PostgreSqlParser.KW_TO); - this.state = 7031; - this.name(); - } - break; - case 33: - this.enterOuterAlt(localContext, 33); - { - this.state = 7033; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7034; - this.match(PostgreSqlParser.KW_EVENT); - this.state = 7035; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 7036; - this.name(); - this.state = 7037; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7038; - this.match(PostgreSqlParser.KW_TO); - this.state = 7039; - this.name(); - } - break; - case 34: - this.enterOuterAlt(localContext, 34); - { - this.state = 7041; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7042; - this.match(PostgreSqlParser.KW_ROLE); - this.state = 7043; - this.roleid(); - this.state = 7044; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7045; - this.match(PostgreSqlParser.KW_TO); - this.state = 7046; - this.roleid(); - } - break; - case 35: - this.enterOuterAlt(localContext, 35); - { - this.state = 7048; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7049; - this.match(PostgreSqlParser.KW_USER); - this.state = 7050; - this.roleid(); - this.state = 7051; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7052; - this.match(PostgreSqlParser.KW_TO); - this.state = 7053; - this.roleid(); - } - break; - case 36: - this.enterOuterAlt(localContext, 36); - { - this.state = 7055; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7056; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 7057; - this.tablespace_name(); - this.state = 7058; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7059; - this.match(PostgreSqlParser.KW_TO); - this.state = 7060; - this.tablespace_name_create(); - } - break; - case 37: - this.enterOuterAlt(localContext, 37); - { - this.state = 7062; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7063; - this.match(PostgreSqlParser.KW_STATISTICS); - this.state = 7064; - this.any_name(); - this.state = 7065; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7066; - this.match(PostgreSqlParser.KW_TO); - this.state = 7067; - this.name(); - } - break; - case 38: - this.enterOuterAlt(localContext, 38); - { - this.state = 7069; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7070; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 7071; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 7072; - this.match(PostgreSqlParser.KW_PARSER); - this.state = 7073; - this.any_name(); - this.state = 7074; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7075; - this.match(PostgreSqlParser.KW_TO); - this.state = 7076; - this.name(); - } - break; - case 39: - this.enterOuterAlt(localContext, 39); - { - this.state = 7078; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7079; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 7080; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 7081; - this.match(PostgreSqlParser.KW_DICTIONARY); - this.state = 7082; - this.any_name(); - this.state = 7083; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7084; - this.match(PostgreSqlParser.KW_TO); - this.state = 7085; - this.name(); - } - break; - case 40: - this.enterOuterAlt(localContext, 40); - { - this.state = 7087; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7088; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 7089; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 7090; - this.match(PostgreSqlParser.KW_TEMPLATE); - this.state = 7091; - this.any_name(); - this.state = 7092; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7093; - this.match(PostgreSqlParser.KW_TO); - this.state = 7094; - this.name(); - } - break; - case 41: - this.enterOuterAlt(localContext, 41); - { - this.state = 7096; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7097; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 7098; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 7099; - this.match(PostgreSqlParser.KW_CONFIGURATION); - this.state = 7100; - this.any_name(); - this.state = 7101; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7102; - this.match(PostgreSqlParser.KW_TO); - this.state = 7103; - this.name(); - } - break; - case 42: - this.enterOuterAlt(localContext, 42); - { - this.state = 7105; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7106; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 7107; - this.any_name(); - this.state = 7108; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7109; - this.match(PostgreSqlParser.KW_TO); - this.state = 7110; - this.name(); + this.state = 5109; + this.match(PostgreSqlParser.KW_SET); + this.state = 5110; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 5111; + this.schema_name(); } break; - case 43: - this.enterOuterAlt(localContext, 43); + case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 7112; + this.state = 5113; this.match(PostgreSqlParser.KW_ALTER); - this.state = 7113; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 7114; - this.any_name(); - this.state = 7115; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7116; - this.match(PostgreSqlParser.KW_ATTRIBUTE); - this.state = 7117; - this.name(); - this.state = 7118; - this.match(PostgreSqlParser.KW_TO); - this.state = 7119; - this.name(); - this.state = 7121; + this.state = 5122; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 663, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_TEXT: { - this.state = 7120; - this.opt_drop_behavior(); + this.state = 5114; + this.match(PostgreSqlParser.KW_TEXT); + this.state = 5115; + this.match(PostgreSqlParser.KW_SEARCH); + this.state = 5116; + _la = this.tokenStream.LA(1); + if(!(_la === 163 || _la === 185 || _la === 283 || _la === 353)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case PostgreSqlParser.KW_COLLATION: + { + this.state = 5117; + this.match(PostgreSqlParser.KW_COLLATION); + } + break; + case PostgreSqlParser.KW_CONVERSION: + { + this.state = 5118; + this.match(PostgreSqlParser.KW_CONVERSION); + } + break; + case PostgreSqlParser.KW_DOMAIN: + { + this.state = 5119; + this.match(PostgreSqlParser.KW_DOMAIN); + } + break; + case PostgreSqlParser.KW_STATISTICS: + { + this.state = 5120; + this.match(PostgreSqlParser.KW_STATISTICS); + } + break; + case PostgreSqlParser.KW_TYPE: + { + this.state = 5121; + this.match(PostgreSqlParser.KW_TYPE); } break; + default: + throw new antlr.NoViableAltException(this); } + this.state = 5124; + this.any_name(); + this.state = 5125; + this.match(PostgreSqlParser.KW_SET); + this.state = 5126; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 5127; + this.schema_name(); } break; } @@ -32930,16 +28280,22 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_set_data(): Opt_set_dataContext { - let localContext = new Opt_set_dataContext(this.context, this.state); - this.enterRule(localContext, 768, PostgreSqlParser.RULE_opt_set_data); + public alteroperatorstmt(): AlteroperatorstmtContext { + let localContext = new AlteroperatorstmtContext(this.context, this.state); + this.enterRule(localContext, 438, PostgreSqlParser.RULE_alteroperatorstmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 7125; + this.state = 5131; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5132; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 5133; + this.operator_with_argtypes(); + this.state = 5134; this.match(PostgreSqlParser.KW_SET); - this.state = 7126; - this.match(PostgreSqlParser.KW_DATA); + this.state = 5135; + this.operator_def_list(); } } catch (re) { @@ -32956,195 +28312,102 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alterobjectdependsstmt(): AlterobjectdependsstmtContext { - let localContext = new AlterobjectdependsstmtContext(this.context, this.state); - this.enterRule(localContext, 770, PostgreSqlParser.RULE_alterobjectdependsstmt); + public operator_def_list(): Operator_def_listContext { + let localContext = new Operator_def_listContext(this.context, this.state); + this.enterRule(localContext, 440, PostgreSqlParser.RULE_operator_def_list); let _la: number; try { - this.state = 7197; + this.enterOuterAlt(localContext, 1); + { + this.state = 5137; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 5138; + this.operator_def_elem(); + this.state = 5143; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 671, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 7128; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7129; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 7130; - this.function_with_argtypes(); - this.state = 7132; + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 5139; + this.match(PostgreSqlParser.COMMA); + this.state = 5140; + this.operator_def_elem(); + } + } + this.state = 5145; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 269) { - { - this.state = 7131; - this.opt_no(); - } - } - - this.state = 7134; - this.match(PostgreSqlParser.KW_DEPENDS); - this.state = 7135; - this.match(PostgreSqlParser.KW_ON); - this.state = 7136; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 7137; - this.name(); + } + this.state = 5146; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public operator_def_elem(): Operator_def_elemContext { + let localContext = new Operator_def_elemContext(this.context, this.state); + this.enterRule(localContext, 442, PostgreSqlParser.RULE_operator_def_elem); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 5148; + this.collabel(); + this.state = 5149; + this.match(PostgreSqlParser.EQUAL); + this.state = 5156; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 638, this.context) ) { + case 1: + { + this.state = 5150; + this.match(PostgreSqlParser.KW_NONE); } break; case 2: - this.enterOuterAlt(localContext, 2); { - this.state = 7139; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7140; - this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 7141; - this.procedure_with_argtypes(); - this.state = 7143; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 269) { - { - this.state = 7142; - this.opt_no(); - } - } - - this.state = 7145; - this.match(PostgreSqlParser.KW_DEPENDS); - this.state = 7146; - this.match(PostgreSqlParser.KW_ON); - this.state = 7147; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 7148; - this.name(); + this.state = 5151; + this.func_type(); } break; case 3: - this.enterOuterAlt(localContext, 3); { - this.state = 7150; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7151; - this.match(PostgreSqlParser.KW_ROUTINE); - this.state = 7152; - this.routine_with_argtypes(); - this.state = 7154; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 269) { - { - this.state = 7153; - this.opt_no(); - } - } - - this.state = 7156; - this.match(PostgreSqlParser.KW_DEPENDS); - this.state = 7157; - this.match(PostgreSqlParser.KW_ON); - this.state = 7158; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 7159; - this.name(); + this.state = 5152; + this.reserved_keyword(); } break; case 4: - this.enterOuterAlt(localContext, 4); { - this.state = 7161; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7162; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 7163; - this.name(); - this.state = 7164; - this.match(PostgreSqlParser.KW_ON); - this.state = 7165; - this.qualified_name(); - this.state = 7167; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 269) { - { - this.state = 7166; - this.opt_no(); - } - } - - this.state = 7169; - this.match(PostgreSqlParser.KW_DEPENDS); - this.state = 7170; - this.match(PostgreSqlParser.KW_ON); - this.state = 7171; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 7172; - this.name(); + this.state = 5153; + this.qual_all_op(); } break; case 5: - this.enterOuterAlt(localContext, 5); { - this.state = 7174; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7175; - this.match(PostgreSqlParser.KW_MATERIALIZED); - this.state = 7176; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 7177; - this.view_name(); - this.state = 7179; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 269) { - { - this.state = 7178; - this.opt_no(); - } - } - - this.state = 7181; - this.match(PostgreSqlParser.KW_DEPENDS); - this.state = 7182; - this.match(PostgreSqlParser.KW_ON); - this.state = 7183; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 7184; - this.name(); + this.state = 5154; + this.numericonly(); } break; case 6: - this.enterOuterAlt(localContext, 6); { - this.state = 7186; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7187; - this.match(PostgreSqlParser.KW_INDEX); - this.state = 7188; - this.qualified_name(); - this.state = 7190; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 269) { - { - this.state = 7189; - this.opt_no(); - } - } - - this.state = 7192; - this.match(PostgreSqlParser.KW_DEPENDS); - this.state = 7193; - this.match(PostgreSqlParser.KW_ON); - this.state = 7194; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 7195; - this.name(); + this.state = 5155; + this.sconst(); } break; } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -33160,14 +28423,22 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_no(): Opt_noContext { - let localContext = new Opt_noContext(this.context, this.state); - this.enterRule(localContext, 772, PostgreSqlParser.RULE_opt_no); + public altertypestmt(): AltertypestmtContext { + let localContext = new AltertypestmtContext(this.context, this.state); + this.enterRule(localContext, 444, PostgreSqlParser.RULE_altertypestmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 7199; - this.match(PostgreSqlParser.KW_NO); + this.state = 5158; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5159; + this.match(PostgreSqlParser.KW_TYPE); + this.state = 5160; + this.any_name(); + this.state = 5161; + this.match(PostgreSqlParser.KW_SET); + this.state = 5162; + this.operator_def_list(); } } catch (re) { @@ -33184,467 +28455,698 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alterobjectschemastmt(): AlterobjectschemastmtContext { - let localContext = new AlterobjectschemastmtContext(this.context, this.state); - this.enterRule(localContext, 774, PostgreSqlParser.RULE_alterobjectschemastmt); + public alterownerstmt(): AlterownerstmtContext { + let localContext = new AlterownerstmtContext(this.context, this.state); + this.enterRule(localContext, 446, PostgreSqlParser.RULE_alterownerstmt); + let _la: number; try { - this.state = 7386; + this.state = 5238; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 677, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 643, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7201; + this.state = 5164; this.match(PostgreSqlParser.KW_ALTER); - this.state = 7202; - this.match(PostgreSqlParser.KW_AGGREGATE); - this.state = 7203; - this.aggregate_with_argtypes(); - this.state = 7204; - this.match(PostgreSqlParser.KW_SET); - this.state = 7205; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7206; - this.schema_name(); + this.state = 5165; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 5166; + _la = this.tokenStream.LA(1); + if(!(_la === 156 || _la === 206)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5167; + this.any_name(); + this.state = 5168; + this.table_access_method_clause(); + this.state = 5169; + this.match(PostgreSqlParser.KW_OWNER); + this.state = 5170; + this.match(PostgreSqlParser.KW_TO); + this.state = 5171; + this.rolespec(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7208; + this.state = 5173; this.match(PostgreSqlParser.KW_ALTER); - this.state = 7209; - this.match(PostgreSqlParser.KW_COLLATION); - this.state = 7210; - this.any_name(); - this.state = 7211; - this.match(PostgreSqlParser.KW_SET); - this.state = 7212; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7213; - this.schema_name(); + this.state = 5200; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 640, this.context) ) { + case 1: + { + this.state = 5174; + this.match(PostgreSqlParser.KW_AGGREGATE); + this.state = 5175; + this.aggregate_with_argtypes(); + } + break; + case 2: + { + this.state = 5176; + this.match(PostgreSqlParser.KW_DATABASE); + this.state = 5177; + this.database_name(); + } + break; + case 3: + { + this.state = 5178; + this.match(PostgreSqlParser.KW_FUNCTION); + this.state = 5179; + this.function_with_argtypes(); + } + break; + case 4: + { + this.state = 5181; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 295) { + { + this.state = 5180; + this.match(PostgreSqlParser.KW_PROCEDURAL); + } + } + + this.state = 5183; + this.match(PostgreSqlParser.KW_LANGUAGE); + this.state = 5184; + this.colid(); + } + break; + case 5: + { + this.state = 5185; + this.match(PostgreSqlParser.KW_LARGE); + this.state = 5186; + this.match(PostgreSqlParser.KW_OBJECT); + this.state = 5187; + this.numericonly(); + } + break; + case 6: + { + this.state = 5188; + this.match(PostgreSqlParser.KW_LARGE); + this.state = 5189; + this.match(PostgreSqlParser.KW_OBJECT); + this.state = 5190; + this.numericonly(); + } + break; + case 7: + { + this.state = 5191; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 5192; + this.operator_with_argtypes(); + } + break; + case 8: + { + this.state = 5193; + this.match(PostgreSqlParser.KW_PROCEDURE); + this.state = 5194; + this.procedure_with_argtypes(); + } + break; + case 9: + { + this.state = 5195; + this.match(PostgreSqlParser.KW_ROUTINE); + this.state = 5196; + this.routine_with_argtypes(); + } + break; + case 10: + { + this.state = 5197; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 5198; + this.schema_name(); + } + break; + case 11: + { + this.state = 5199; + this.opttablespace(); + } + break; + } + this.state = 5202; + this.match(PostgreSqlParser.KW_OWNER); + this.state = 5203; + this.match(PostgreSqlParser.KW_TO); + this.state = 5204; + this.rolespec(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 7215; + this.state = 5206; this.match(PostgreSqlParser.KW_ALTER); - this.state = 7216; - this.match(PostgreSqlParser.KW_CONVERSION); - this.state = 7217; + this.state = 5215; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_TEXT: + { + this.state = 5207; + this.match(PostgreSqlParser.KW_TEXT); + this.state = 5208; + this.match(PostgreSqlParser.KW_SEARCH); + this.state = 5209; + _la = this.tokenStream.LA(1); + if(!(_la === 163 || _la === 185)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case PostgreSqlParser.KW_COLLATION: + { + this.state = 5210; + this.match(PostgreSqlParser.KW_COLLATION); + } + break; + case PostgreSqlParser.KW_CONVERSION: + { + this.state = 5211; + this.match(PostgreSqlParser.KW_CONVERSION); + } + break; + case PostgreSqlParser.KW_DOMAIN: + { + this.state = 5212; + this.match(PostgreSqlParser.KW_DOMAIN); + } + break; + case PostgreSqlParser.KW_TYPE: + { + this.state = 5213; + this.match(PostgreSqlParser.KW_TYPE); + } + break; + case PostgreSqlParser.KW_STATISTICS: + { + this.state = 5214; + this.match(PostgreSqlParser.KW_STATISTICS); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 5217; this.any_name(); - this.state = 7218; - this.match(PostgreSqlParser.KW_SET); - this.state = 7219; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7220; - this.schema_name(); + this.state = 5218; + this.match(PostgreSqlParser.KW_OWNER); + this.state = 5219; + this.match(PostgreSqlParser.KW_TO); + this.state = 5220; + this.rolespec(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 7222; + this.state = 5222; this.match(PostgreSqlParser.KW_ALTER); - this.state = 7223; - this.match(PostgreSqlParser.KW_DOMAIN); - this.state = 7224; - this.any_name(); - this.state = 7225; - this.match(PostgreSqlParser.KW_SET); - this.state = 7226; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7227; - this.schema_name(); + this.state = 5231; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_SERVER: + { + this.state = 5223; + this.match(PostgreSqlParser.KW_SERVER); + } + break; + case PostgreSqlParser.KW_FOREIGN: + { + { + this.state = 5224; + this.match(PostgreSqlParser.KW_FOREIGN); + this.state = 5225; + this.match(PostgreSqlParser.KW_DATA); + this.state = 5226; + this.match(PostgreSqlParser.KW_WRAPPER); + } + } + break; + case PostgreSqlParser.KW_EVENT: + { + { + this.state = 5227; + this.match(PostgreSqlParser.KW_EVENT); + this.state = 5228; + this.match(PostgreSqlParser.KW_TRIGGER); + } + } + break; + case PostgreSqlParser.KW_PUBLICATION: + { + this.state = 5229; + this.match(PostgreSqlParser.KW_PUBLICATION); + } + break; + case PostgreSqlParser.KW_SUBSCRIPTION: + { + this.state = 5230; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 5233; + this.colid(); + this.state = 5234; + this.match(PostgreSqlParser.KW_OWNER); + this.state = 5235; + this.match(PostgreSqlParser.KW_TO); + this.state = 5236; + this.rolespec(); } break; - case 5: - this.enterOuterAlt(localContext, 5); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public createpublicationstmt(): CreatepublicationstmtContext { + let localContext = new CreatepublicationstmtContext(this.context, this.state); + this.enterRule(localContext, 448, PostgreSqlParser.RULE_createpublicationstmt); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 5240; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 5241; + this.match(PostgreSqlParser.KW_PUBLICATION); + this.state = 5242; + this.colid(); + this.state = 5249; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 644, this.context) ) { + case 1: { - this.state = 7229; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7230; - this.match(PostgreSqlParser.KW_EXTENSION); - this.state = 7231; - this.name(); - this.state = 7232; - this.match(PostgreSqlParser.KW_SET); - this.state = 7233; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7234; - this.schema_name(); + this.state = 5243; + this.match(PostgreSqlParser.KW_FOR); + this.state = 5244; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 5245; + this.relation_expr_list(); } break; - case 6: - this.enterOuterAlt(localContext, 6); + case 2: { - this.state = 7236; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7237; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 7238; - this.function_with_argtypes(); - this.state = 7239; - this.match(PostgreSqlParser.KW_SET); - this.state = 7240; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7241; - this.schema_name(); + this.state = 5246; + this.match(PostgreSqlParser.KW_FOR); + this.state = 5247; + this.match(PostgreSqlParser.KW_ALL); + this.state = 5248; + this.match(PostgreSqlParser.KW_TABLES); } break; - case 7: - this.enterOuterAlt(localContext, 7); + } + this.state = 5252; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 645, this.context) ) { + case 1: { - this.state = 7243; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7244; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 7245; - this.operator_with_argtypes(); - this.state = 7246; - this.match(PostgreSqlParser.KW_SET); - this.state = 7247; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7248; - this.schema_name(); + this.state = 5251; + this.opt_definition(); } break; - case 8: - this.enterOuterAlt(localContext, 8); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public alterpublicationstmt(): AlterpublicationstmtContext { + let localContext = new AlterpublicationstmtContext(this.context, this.state); + this.enterRule(localContext, 450, PostgreSqlParser.RULE_alterpublicationstmt); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 5254; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5255; + this.match(PostgreSqlParser.KW_PUBLICATION); + this.state = 5256; + this.colid(); + this.state = 5274; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 647, this.context) ) { + case 1: { - this.state = 7250; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7251; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 7252; - this.match(PostgreSqlParser.KW_CLASS); - this.state = 7253; - this.any_name(); - this.state = 7254; - this.match(PostgreSqlParser.KW_USING); - this.state = 7255; - this.name(); - this.state = 7256; - this.match(PostgreSqlParser.KW_SET); - this.state = 7257; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7258; - this.schema_name(); + { + this.state = 5257; + this.match(PostgreSqlParser.KW_OWNER); + this.state = 5258; + this.match(PostgreSqlParser.KW_TO); + this.state = 5259; + this.rolespec(); + } } break; - case 9: - this.enterOuterAlt(localContext, 9); + case 2: { - this.state = 7260; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7261; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 7262; - this.match(PostgreSqlParser.KW_FAMILY); - this.state = 7263; - this.any_name(); - this.state = 7264; - this.match(PostgreSqlParser.KW_USING); - this.state = 7265; - this.name(); - this.state = 7266; + { + this.state = 5260; this.match(PostgreSqlParser.KW_SET); - this.state = 7267; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7268; - this.schema_name(); + this.state = 5261; + this.definition(); + } } break; - case 10: - this.enterOuterAlt(localContext, 10); + case 3: { - this.state = 7270; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7271; - this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 7272; - this.procedure_with_argtypes(); - this.state = 7273; - this.match(PostgreSqlParser.KW_SET); - this.state = 7274; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7275; - this.schema_name(); - } - break; - case 11: - this.enterOuterAlt(localContext, 11); { - this.state = 7277; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7278; - this.match(PostgreSqlParser.KW_ROUTINE); - this.state = 7279; - this.routine_with_argtypes(); - this.state = 7280; - this.match(PostgreSqlParser.KW_SET); - this.state = 7281; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7282; - this.schema_name(); + this.state = 5262; + this.match(PostgreSqlParser.KW_RENAME); + this.state = 5263; + this.match(PostgreSqlParser.KW_TO); + this.state = 5264; + this.colid(); + } } break; - case 12: - this.enterOuterAlt(localContext, 12); + case 4: { - this.state = 7284; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7285; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 7287; + this.state = 5265; + _la = this.tokenStream.LA(1); + if(!(_la === 133 || _la === 191 || _la === 333)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5266; + this.publication_relation_expr(); + this.state = 5271; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 672, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + while (_la === 6) { { - this.state = 7286; - this.opt_if_exists(); + { + this.state = 5267; + this.match(PostgreSqlParser.COMMA); + this.state = 5268; + this.publication_relation_expr(); } - break; + } + this.state = 5273; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - this.state = 7289; - this.relation_expr(); - this.state = 7290; - this.match(PostgreSqlParser.KW_SET); - this.state = 7291; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7292; - this.schema_name(); } break; - case 13: - this.enterOuterAlt(localContext, 13); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public createsubscriptionstmt(): CreatesubscriptionstmtContext { + let localContext = new CreatesubscriptionstmtContext(this.context, this.state); + this.enterRule(localContext, 452, PostgreSqlParser.RULE_createsubscriptionstmt); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 5276; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 5277; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); + this.state = 5278; + this.colid(); + this.state = 5279; + this.match(PostgreSqlParser.KW_CONNECTION); + this.state = 5280; + this.sconst(); + this.state = 5281; + this.match(PostgreSqlParser.KW_PUBLICATION); + { + this.state = 5282; + this.collabel(); + this.state = 5287; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { { - this.state = 7294; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7295; - this.match(PostgreSqlParser.KW_STATISTICS); - this.state = 7296; - this.any_name(); - this.state = 7297; - this.match(PostgreSqlParser.KW_SET); - this.state = 7298; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7299; - this.schema_name(); - } - break; - case 14: - this.enterOuterAlt(localContext, 14); { - this.state = 7301; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7302; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 7303; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 7304; - this.match(PostgreSqlParser.KW_PARSER); - this.state = 7305; - this.any_name(); - this.state = 7306; - this.match(PostgreSqlParser.KW_SET); - this.state = 7307; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7308; - this.schema_name(); + this.state = 5283; + this.match(PostgreSqlParser.COMMA); + this.state = 5284; + this.collabel(); } - break; - case 15: - this.enterOuterAlt(localContext, 15); + } + this.state = 5289; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + this.state = 5291; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 649, this.context) ) { + case 1: { - this.state = 7310; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7311; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 7312; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 7313; - this.match(PostgreSqlParser.KW_DICTIONARY); - this.state = 7314; - this.any_name(); - this.state = 7315; - this.match(PostgreSqlParser.KW_SET); - this.state = 7316; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7317; - this.schema_name(); + this.state = 5290; + this.opt_definition(); } break; - case 16: - this.enterOuterAlt(localContext, 16); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public altersubscriptionstmt(): AltersubscriptionstmtContext { + let localContext = new AltersubscriptionstmtContext(this.context, this.state); + this.enterRule(localContext, 454, PostgreSqlParser.RULE_altersubscriptionstmt); + let _la: number; + try { + this.state = 5349; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 653, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); { - this.state = 7319; + this.state = 5293; this.match(PostgreSqlParser.KW_ALTER); - this.state = 7320; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 7321; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 7322; - this.match(PostgreSqlParser.KW_TEMPLATE); - this.state = 7323; - this.any_name(); - this.state = 7324; + this.state = 5294; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); + this.state = 5295; + this.colid(); + this.state = 5296; this.match(PostgreSqlParser.KW_SET); - this.state = 7325; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7326; - this.schema_name(); + this.state = 5297; + this.definition(); } break; - case 17: - this.enterOuterAlt(localContext, 17); + case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 7328; + this.state = 5299; this.match(PostgreSqlParser.KW_ALTER); - this.state = 7329; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 7330; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 7331; - this.match(PostgreSqlParser.KW_CONFIGURATION); - this.state = 7332; - this.any_name(); - this.state = 7333; - this.match(PostgreSqlParser.KW_SET); - this.state = 7334; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7335; - this.schema_name(); + this.state = 5300; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); + this.state = 5301; + this.colid(); + this.state = 5302; + this.match(PostgreSqlParser.KW_CONNECTION); + this.state = 5303; + this.sconst(); } break; - case 18: - this.enterOuterAlt(localContext, 18); + case 3: + this.enterOuterAlt(localContext, 3); { - this.state = 7337; + this.state = 5305; this.match(PostgreSqlParser.KW_ALTER); - this.state = 7338; - this.match(PostgreSqlParser.KW_SEQUENCE); - this.state = 7340; + this.state = 5306; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); + this.state = 5307; + this.colid(); + this.state = 5308; + this.match(PostgreSqlParser.KW_REFRESH); + this.state = 5309; + this.match(PostgreSqlParser.KW_PUBLICATION); + this.state = 5311; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 673, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 650, this.context) ) { case 1: { - this.state = 7339; - this.opt_if_exists(); + this.state = 5310; + this.opt_definition(); } break; } - this.state = 7342; - this.qualified_name(); - this.state = 7343; - this.match(PostgreSqlParser.KW_SET); - this.state = 7344; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7345; - this.schema_name(); } break; - case 19: - this.enterOuterAlt(localContext, 19); + case 4: + this.enterOuterAlt(localContext, 4); { - this.state = 7347; + this.state = 5313; this.match(PostgreSqlParser.KW_ALTER); - this.state = 7348; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 7350; + this.state = 5314; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); + this.state = 5315; + this.colid(); + this.state = 5316; + _la = this.tokenStream.LA(1); + if(!(_la === 133 || _la === 191 || _la === 333)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5317; + this.match(PostgreSqlParser.KW_PUBLICATION); + { + this.state = 5318; + this.collabel(); + this.state = 5323; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 674, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + while (_la === 6) { { - this.state = 7349; - this.opt_if_exists(); + { + this.state = 5319; + this.match(PostgreSqlParser.COMMA); + this.state = 5320; + this.collabel(); } - break; + } + this.state = 5325; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - this.state = 7352; - this.view_name(); - this.state = 7353; - this.match(PostgreSqlParser.KW_SET); - this.state = 7354; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7355; - this.schema_name(); } - break; - case 20: - this.enterOuterAlt(localContext, 20); - { - this.state = 7357; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7358; - this.match(PostgreSqlParser.KW_MATERIALIZED); - this.state = 7359; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 7361; + this.state = 5327; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 675, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 652, this.context) ) { case 1: { - this.state = 7360; - this.opt_if_exists(); + this.state = 5326; + this.opt_definition(); } break; } - this.state = 7363; - this.view_name(); - this.state = 7364; - this.match(PostgreSqlParser.KW_SET); - this.state = 7365; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7366; - this.schema_name(); } break; - case 21: - this.enterOuterAlt(localContext, 21); + case 5: + this.enterOuterAlt(localContext, 5); { - this.state = 7368; + this.state = 5329; this.match(PostgreSqlParser.KW_ALTER); - this.state = 7369; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 7370; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 7372; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 676, this.context) ) { - case 1: - { - this.state = 7371; - this.opt_if_exists(); - } - break; + this.state = 5330; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); + this.state = 5331; + this.colid(); + this.state = 5332; + _la = this.tokenStream.LA(1); + if(!(_la === 186 || _la === 193)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); } - this.state = 7374; - this.relation_expr(); - this.state = 7375; - this.match(PostgreSqlParser.KW_SET); - this.state = 7376; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7377; - this.schema_name(); } break; - case 22: - this.enterOuterAlt(localContext, 22); + case 6: + this.enterOuterAlt(localContext, 6); { - this.state = 7379; + this.state = 5334; this.match(PostgreSqlParser.KW_ALTER); - this.state = 7380; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 7381; - this.any_name(); - this.state = 7382; - this.match(PostgreSqlParser.KW_SET); - this.state = 7383; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7384; - this.schema_name(); + this.state = 5335; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); + this.state = 5336; + this.colid(); + this.state = 5337; + this.match(PostgreSqlParser.KW_SKIP); + this.state = 5338; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 5339; + this.old_aggr_elem(); + this.state = 5340; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 5342; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5343; + this.match(PostgreSqlParser.KW_SUBSCRIPTION); + this.state = 5344; + this.colid(); + this.state = 5345; + this.match(PostgreSqlParser.KW_OWNER); + this.state = 5346; + this.match(PostgreSqlParser.KW_TO); + this.state = 5347; + this.rolespec(); } break; } @@ -33663,113 +29165,136 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alteroperatorstmt(): AlteroperatorstmtContext { - let localContext = new AlteroperatorstmtContext(this.context, this.state); - this.enterRule(localContext, 776, PostgreSqlParser.RULE_alteroperatorstmt); + public rulestmt(): RulestmtContext { + let localContext = new RulestmtContext(this.context, this.state); + this.enterRule(localContext, 456, PostgreSqlParser.RULE_rulestmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 7388; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7389; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 7390; - this.operator_with_argtypes(); - this.state = 7391; - this.match(PostgreSqlParser.KW_SET); - this.state = 7392; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 7393; - this.operator_def_list(); - this.state = 7394; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 5351; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 5353; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 82) { + { + this.state = 5352; + this.opt_or_replace(); + } } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + + this.state = 5355; + this.match(PostgreSqlParser.KW_RULE); + this.state = 5356; + this.colid(); + this.state = 5357; + this.match(PostgreSqlParser.KW_AS); + this.state = 5358; + this.match(PostgreSqlParser.KW_ON); + this.state = 5359; + _la = this.tokenStream.LA(1); + if(!(_la === 88 || _la === 182 || _la === 241 || _la === 369)) { + this.errorHandler.recoverInline(this); } - } - finally { - this.exitRule(); - } - return localContext; - } - public operator_def_list(): Operator_def_listContext { - let localContext = new Operator_def_listContext(this.context, this.state); - this.enterRule(localContext, 778, PostgreSqlParser.RULE_operator_def_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 7396; - this.operator_def_elem(); - this.state = 7401; + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5360; + this.match(PostgreSqlParser.KW_TO); + this.state = 5361; + this.qualified_name(); + this.state = 5363; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - while (_la === 6) { + if (_la === 103) { { + this.state = 5362; + this.where_clause(); + } + } + + this.state = 5365; + this.match(PostgreSqlParser.KW_DO); + this.state = 5367; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 137 || _la === 242) { { - this.state = 7397; - this.match(PostgreSqlParser.COMMA); - this.state = 7398; - this.operator_def_elem(); + this.state = 5366; + _la = this.tokenStream.LA(1); + if(!(_la === 137 || _la === 242)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); } } - this.state = 7403; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; } - } - finally { - this.exitRule(); - } - return localContext; - } - public operator_def_elem(): Operator_def_elemContext { - let localContext = new Operator_def_elemContext(this.context, this.state); - this.enterRule(localContext, 780, PostgreSqlParser.RULE_operator_def_elem); - try { - this.state = 7412; + + this.state = 5385; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 679, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 660, this.context) ) { case 1: - this.enterOuterAlt(localContext, 1); { - this.state = 7404; - this.collabel(); - this.state = 7405; - this.match(PostgreSqlParser.EQUAL); - this.state = 7406; - this.match(PostgreSqlParser.KW_NONE); + this.state = 5369; + this.match(PostgreSqlParser.KW_NOTHING); } break; case 2: - this.enterOuterAlt(localContext, 2); { - this.state = 7408; - this.collabel(); - this.state = 7409; - this.match(PostgreSqlParser.EQUAL); - this.state = 7410; - this.operator_def_arg(); + this.state = 5370; + this.ruleactionstmt(); + } + break; + case 3: + { + this.state = 5371; + this.match(PostgreSqlParser.OPEN_PAREN); + { + this.state = 5373; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2 || ((((_la - 88)) & ~0x1F) === 0 && ((1 << (_la - 88)) & 131089) !== 0) || _la === 182 || _la === 241 || _la === 271 || _la === 369 || _la === 422) { + { + this.state = 5372; + this.ruleactionstmt(); + } + } + + this.state = 5381; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 7) { + { + { + this.state = 5375; + this.match(PostgreSqlParser.SEMI); + this.state = 5377; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2 || ((((_la - 88)) & ~0x1F) === 0 && ((1 << (_la - 88)) & 131089) !== 0) || _la === 182 || _la === 241 || _la === 271 || _la === 369 || _la === 422) { + { + this.state = 5376; + this.ruleactionstmt(); + } + } + + } + } + this.state = 5383; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + this.state = 5384; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -33785,46 +29310,46 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public operator_def_arg(): Operator_def_argContext { - let localContext = new Operator_def_argContext(this.context, this.state); - this.enterRule(localContext, 782, PostgreSqlParser.RULE_operator_def_arg); + public ruleactionstmt(): RuleactionstmtContext { + let localContext = new RuleactionstmtContext(this.context, this.state); + this.enterRule(localContext, 458, PostgreSqlParser.RULE_ruleactionstmt); try { - this.state = 7419; + this.state = 5392; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 680, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 661, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7414; - this.func_type(); + this.state = 5387; + this.selectstmt(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7415; - this.reserved_keyword(); + this.state = 5388; + this.insertstmt(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 7416; - this.qual_all_op(); + this.state = 5389; + this.updatestmt(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 7417; - this.numericonly(); + this.state = 5390; + this.deletestmt(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 7418; - this.sconst(); + this.state = 5391; + this.notifystmt(); } break; } @@ -33843,545 +29368,27 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public altertypestmt(): AltertypestmtContext { - let localContext = new AltertypestmtContext(this.context, this.state); - this.enterRule(localContext, 784, PostgreSqlParser.RULE_altertypestmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 7421; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7422; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 7423; - this.any_name(); - this.state = 7424; - this.match(PostgreSqlParser.KW_SET); - this.state = 7425; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 7426; - this.operator_def_list(); - this.state = 7427; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alterownerstmt(): AlterownerstmtContext { - let localContext = new AlterownerstmtContext(this.context, this.state); - this.enterRule(localContext, 786, PostgreSqlParser.RULE_alterownerstmt); - let _la: number; - try { - this.state = 7614; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 682, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 7429; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7430; - this.match(PostgreSqlParser.KW_AGGREGATE); - this.state = 7431; - this.aggregate_with_argtypes(); - this.state = 7432; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7433; - this.match(PostgreSqlParser.KW_TO); - this.state = 7434; - this.rolespec(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 7436; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7437; - this.match(PostgreSqlParser.KW_COLLATION); - this.state = 7438; - this.any_name(); - this.state = 7439; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7440; - this.match(PostgreSqlParser.KW_TO); - this.state = 7441; - this.rolespec(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 7443; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7444; - this.match(PostgreSqlParser.KW_CONVERSION); - this.state = 7445; - this.any_name(); - this.state = 7446; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7447; - this.match(PostgreSqlParser.KW_TO); - this.state = 7448; - this.rolespec(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 7450; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7451; - this.match(PostgreSqlParser.KW_DATABASE); - this.state = 7452; - this.database_name(); - this.state = 7453; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7454; - this.match(PostgreSqlParser.KW_TO); - this.state = 7455; - this.rolespec(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 7457; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7458; - this.match(PostgreSqlParser.KW_DOMAIN); - this.state = 7459; - this.any_name(); - this.state = 7460; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7461; - this.match(PostgreSqlParser.KW_TO); - this.state = 7462; - this.rolespec(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 7464; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7465; - this.match(PostgreSqlParser.KW_FUNCTION); - this.state = 7466; - this.function_with_argtypes(); - this.state = 7467; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7468; - this.match(PostgreSqlParser.KW_TO); - this.state = 7469; - this.rolespec(); - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 7471; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7473; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 295) { - { - this.state = 7472; - this.opt_procedural(); - } - } - - this.state = 7475; - this.match(PostgreSqlParser.KW_LANGUAGE); - this.state = 7476; - this.name(); - this.state = 7477; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7478; - this.match(PostgreSqlParser.KW_TO); - this.state = 7479; - this.rolespec(); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 7481; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7482; - this.match(PostgreSqlParser.KW_LARGE); - this.state = 7483; - this.match(PostgreSqlParser.KW_OBJECT); - this.state = 7484; - this.numericonly(); - this.state = 7485; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7486; - this.match(PostgreSqlParser.KW_TO); - this.state = 7487; - this.rolespec(); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 7489; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7490; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 7491; - this.operator_with_argtypes(); - this.state = 7492; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7493; - this.match(PostgreSqlParser.KW_TO); - this.state = 7494; - this.rolespec(); - } - break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 7496; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7497; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 7498; - this.match(PostgreSqlParser.KW_CLASS); - this.state = 7499; - this.any_name(); - this.state = 7500; - this.match(PostgreSqlParser.KW_USING); - this.state = 7501; - this.name(); - this.state = 7502; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7503; - this.match(PostgreSqlParser.KW_TO); - this.state = 7504; - this.rolespec(); - } - break; - case 11: - this.enterOuterAlt(localContext, 11); - { - this.state = 7506; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7507; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 7508; - this.match(PostgreSqlParser.KW_FAMILY); - this.state = 7509; - this.any_name(); - this.state = 7510; - this.match(PostgreSqlParser.KW_USING); - this.state = 7511; - this.name(); - this.state = 7512; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7513; - this.match(PostgreSqlParser.KW_TO); - this.state = 7514; - this.rolespec(); - } - break; - case 12: - this.enterOuterAlt(localContext, 12); - { - this.state = 7516; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7517; - this.match(PostgreSqlParser.KW_PROCEDURE); - this.state = 7518; - this.procedure_with_argtypes(); - this.state = 7519; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7520; - this.match(PostgreSqlParser.KW_TO); - this.state = 7521; - this.rolespec(); - } - break; - case 13: - this.enterOuterAlt(localContext, 13); - { - this.state = 7523; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7524; - this.match(PostgreSqlParser.KW_ROUTINE); - this.state = 7525; - this.routine_with_argtypes(); - this.state = 7526; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7527; - this.match(PostgreSqlParser.KW_TO); - this.state = 7528; - this.rolespec(); - } - break; - case 14: - this.enterOuterAlt(localContext, 14); - { - this.state = 7530; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7531; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 7532; - this.schema_name(); - this.state = 7533; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7534; - this.match(PostgreSqlParser.KW_TO); - this.state = 7535; - this.rolespec(); - } - break; - case 15: - this.enterOuterAlt(localContext, 15); - { - this.state = 7537; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7538; - this.match(PostgreSqlParser.KW_TYPE); - this.state = 7539; - this.any_name(); - this.state = 7540; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7541; - this.match(PostgreSqlParser.KW_TO); - this.state = 7542; - this.rolespec(); - } - break; - case 16: - this.enterOuterAlt(localContext, 16); - { - this.state = 7544; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7545; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 7546; - this.tablespace_name(); - this.state = 7547; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7548; - this.match(PostgreSqlParser.KW_TO); - this.state = 7549; - this.rolespec(); - } - break; - case 17: - this.enterOuterAlt(localContext, 17); - { - this.state = 7551; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7552; - this.match(PostgreSqlParser.KW_STATISTICS); - this.state = 7553; - this.any_name(); - this.state = 7554; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7555; - this.match(PostgreSqlParser.KW_TO); - this.state = 7556; - this.rolespec(); - } - break; - case 18: - this.enterOuterAlt(localContext, 18); - { - this.state = 7558; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7559; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 7560; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 7561; - this.match(PostgreSqlParser.KW_DICTIONARY); - this.state = 7562; - this.any_name(); - this.state = 7563; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7564; - this.match(PostgreSqlParser.KW_TO); - this.state = 7565; - this.rolespec(); - } - break; - case 19: - this.enterOuterAlt(localContext, 19); - { - this.state = 7567; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7568; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 7569; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 7570; - this.match(PostgreSqlParser.KW_CONFIGURATION); - this.state = 7571; - this.any_name(); - this.state = 7572; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7573; - this.match(PostgreSqlParser.KW_TO); - this.state = 7574; - this.rolespec(); - } - break; - case 20: - this.enterOuterAlt(localContext, 20); - { - this.state = 7576; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7577; - this.match(PostgreSqlParser.KW_FOREIGN); - this.state = 7578; - this.match(PostgreSqlParser.KW_DATA); - this.state = 7579; - this.match(PostgreSqlParser.KW_WRAPPER); - this.state = 7580; - this.name(); - this.state = 7581; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7582; - this.match(PostgreSqlParser.KW_TO); - this.state = 7583; - this.rolespec(); - } - break; - case 21: - this.enterOuterAlt(localContext, 21); - { - this.state = 7585; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7586; - this.match(PostgreSqlParser.KW_SERVER); - this.state = 7587; - this.name(); - this.state = 7588; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7589; - this.match(PostgreSqlParser.KW_TO); - this.state = 7590; - this.rolespec(); - } - break; - case 22: - this.enterOuterAlt(localContext, 22); - { - this.state = 7592; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7593; - this.match(PostgreSqlParser.KW_EVENT); - this.state = 7594; - this.match(PostgreSqlParser.KW_TRIGGER); - this.state = 7595; - this.name(); - this.state = 7596; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7597; - this.match(PostgreSqlParser.KW_TO); - this.state = 7598; - this.rolespec(); - } - break; - case 23: - this.enterOuterAlt(localContext, 23); - { - this.state = 7600; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7601; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7602; - this.name(); - this.state = 7603; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7604; - this.match(PostgreSqlParser.KW_TO); - this.state = 7605; - this.rolespec(); - } - break; - case 24: - this.enterOuterAlt(localContext, 24); - { - this.state = 7607; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7608; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7609; - this.name(); - this.state = 7610; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7611; - this.match(PostgreSqlParser.KW_TO); - this.state = 7612; - this.rolespec(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createpublicationstmt(): CreatepublicationstmtContext { - let localContext = new CreatepublicationstmtContext(this.context, this.state); - this.enterRule(localContext, 788, PostgreSqlParser.RULE_createpublicationstmt); + public notifystmt(): NotifystmtContext { + let localContext = new NotifystmtContext(this.context, this.state); + this.enterRule(localContext, 460, PostgreSqlParser.RULE_notifystmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 7616; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 7617; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7618; - this.name(); - this.state = 7620; + this.state = 5394; + this.match(PostgreSqlParser.KW_NOTIFY); + this.state = 5395; + this.colid(); + this.state = 5397; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 62) { + if (_la === 6) { { - this.state = 7619; - this.opt_publication_for_tables(); + this.state = 5396; + this.notify_payload(); } } - this.state = 7623; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 684, this.context) ) { - case 1: - { - this.state = 7622; - this.opt_definition(); - } - break; - } } } catch (re) { @@ -34398,14 +29405,16 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_publication_for_tables(): Opt_publication_for_tablesContext { - let localContext = new Opt_publication_for_tablesContext(this.context, this.state); - this.enterRule(localContext, 790, PostgreSqlParser.RULE_opt_publication_for_tables); + public notify_payload(): Notify_payloadContext { + let localContext = new Notify_payloadContext(this.context, this.state); + this.enterRule(localContext, 462, PostgreSqlParser.RULE_notify_payload); try { this.enterOuterAlt(localContext, 1); { - this.state = 7625; - this.publication_for_tables(); + this.state = 5399; + this.match(PostgreSqlParser.COMMA); + this.state = 5400; + this.sconst(); } } catch (re) { @@ -34422,35 +29431,16 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public publication_for_tables(): Publication_for_tablesContext { - let localContext = new Publication_for_tablesContext(this.context, this.state); - this.enterRule(localContext, 792, PostgreSqlParser.RULE_publication_for_tables); + public listenstmt(): ListenstmtContext { + let localContext = new ListenstmtContext(this.context, this.state); + this.enterRule(localContext, 464, PostgreSqlParser.RULE_listenstmt); try { - this.state = 7633; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 685, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 7627; - this.match(PostgreSqlParser.KW_FOR); - this.state = 7628; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 7629; - this.relation_expr_list(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 7630; - this.match(PostgreSqlParser.KW_FOR); - this.state = 7631; - this.match(PostgreSqlParser.KW_ALL); - this.state = 7632; - this.match(PostgreSqlParser.KW_TABLES); - } - break; + this.enterOuterAlt(localContext, 1); + { + this.state = 5402; + this.match(PostgreSqlParser.KW_LISTEN); + this.state = 5403; + this.colid(); } } catch (re) { @@ -34467,218 +29457,430 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alterpublicationstmt(): AlterpublicationstmtContext { - let localContext = new AlterpublicationstmtContext(this.context, this.state); - this.enterRule(localContext, 794, PostgreSqlParser.RULE_alterpublicationstmt); + public unlistenstmt(): UnlistenstmtContext { + let localContext = new UnlistenstmtContext(this.context, this.state); + this.enterRule(localContext, 466, PostgreSqlParser.RULE_unlistenstmt); try { - this.state = 7673; + this.enterOuterAlt(localContext, 1); + { + this.state = 5405; + this.match(PostgreSqlParser.KW_UNLISTEN); + this.state = 5408; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 686, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 7635; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7636; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7637; - this.name(); - this.state = 7638; - this.match(PostgreSqlParser.KW_SET); - this.state = 7639; - this.definition(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 7641; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7642; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7643; - this.name(); - this.state = 7644; - this.match(PostgreSqlParser.KW_ADD); - this.state = 7645; - this.publication_relation_expr_list(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 7647; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7648; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7649; - this.name(); - this.state = 7650; - this.match(PostgreSqlParser.KW_SET); - this.state = 7651; - this.publication_relation_expr_list(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 7653; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7654; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7655; - this.name(); - this.state = 7656; - this.match(PostgreSqlParser.KW_DROP); - this.state = 7657; - this.publication_relation_expr_list(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 7659; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7660; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7661; - this.name(); - this.state = 7662; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7663; - this.match(PostgreSqlParser.KW_TO); - this.state = 7664; - this.rolespec(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 7666; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7667; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7668; - this.name(); - this.state = 7669; - this.match(PostgreSqlParser.KW_RENAME); - this.state = 7670; - this.match(PostgreSqlParser.KW_TO); - this.state = 7671; - this.name(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createsubscriptionstmt(): CreatesubscriptionstmtContext { - let localContext = new CreatesubscriptionstmtContext(this.context, this.state); - this.enterRule(localContext, 796, PostgreSqlParser.RULE_createsubscriptionstmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 7675; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 7676; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7677; - this.name(); - this.state = 7678; - this.match(PostgreSqlParser.KW_CONNECTION); - this.state = 7679; - this.sconst(); - this.state = 7680; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7681; - this.publication_name_list(); - this.state = 7683; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 687, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: { - this.state = 7682; - this.opt_definition(); + this.state = 5406; + this.colid(); } break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public publication_name_list(): Publication_name_listContext { - let localContext = new Publication_name_listContext(this.context, this.state); - this.enterRule(localContext, 798, PostgreSqlParser.RULE_publication_name_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 7685; - this.publication_name_item(); - this.state = 7690; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { + case PostgreSqlParser.STAR: { - this.state = 7686; - this.match(PostgreSqlParser.COMMA); - this.state = 7687; - this.publication_name_item(); - } + this.state = 5407; + this.match(PostgreSqlParser.STAR); } - this.state = 7692; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + break; + default: + throw new antlr.NoViableAltException(this); } - } - finally { - this.exitRule(); - } - return localContext; - } - public publication_name_item(): Publication_name_itemContext { - let localContext = new Publication_name_itemContext(this.context, this.state); - this.enterRule(localContext, 800, PostgreSqlParser.RULE_publication_name_item); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 7693; - this.collabel(); } } catch (re) { @@ -34695,224 +29897,192 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public altersubscriptionstmt(): AltersubscriptionstmtContext { - let localContext = new AltersubscriptionstmtContext(this.context, this.state); - this.enterRule(localContext, 802, PostgreSqlParser.RULE_altersubscriptionstmt); + public transactionstmt(): TransactionstmtContext { + let localContext = new TransactionstmtContext(this.context, this.state); + this.enterRule(localContext, 468, PostgreSqlParser.RULE_transactionstmt); + let _la: number; try { - this.state = 7773; + this.state = 5455; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 693, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 673, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7695; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7696; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7697; - this.name(); - this.state = 7698; - this.match(PostgreSqlParser.KW_SET); - this.state = 7699; - this.definition(); + this.state = 5410; + this.match(PostgreSqlParser.KW_BEGIN); + this.state = 5412; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 664, this.context) ) { + case 1: + { + this.state = 5411; + this.opt_transaction(); + } + break; + } + this.state = 5415; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 665, this.context) ) { + case 1: + { + this.state = 5414; + this.transaction_mode_list(); + } + break; + } } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7701; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7702; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7703; - this.name(); - this.state = 7704; - this.match(PostgreSqlParser.KW_CONNECTION); - this.state = 7705; - this.sconst(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 7707; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7708; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7709; - this.name(); - this.state = 7710; - this.match(PostgreSqlParser.KW_REFRESH); - this.state = 7711; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7713; + this.state = 5417; + this.match(PostgreSqlParser.KW_START); + this.state = 5418; + this.match(PostgreSqlParser.KW_TRANSACTION); + this.state = 5420; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 689, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 666, this.context) ) { case 1: { - this.state = 7712; - this.opt_definition(); + this.state = 5419; + this.transaction_mode_list(); } break; } } break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 5422; + this.match(PostgreSqlParser.KW_SAVEPOINT); + this.state = 5423; + this.colid(); + } + break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 7715; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7716; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7717; - this.name(); - this.state = 7718; - this.match(PostgreSqlParser.KW_SET); - this.state = 7719; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7720; - this.publication_name_list(); - this.state = 7722; + this.state = 5424; + this.match(PostgreSqlParser.KW_RELEASE); + this.state = 5426; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 690, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 667, this.context) ) { case 1: { - this.state = 7721; - this.opt_definition(); + this.state = 5425; + this.match(PostgreSqlParser.KW_SAVEPOINT); } break; } + this.state = 5428; + this.colid(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 7724; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7725; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7726; - this.name(); - this.state = 7727; - this.match(PostgreSqlParser.KW_ADD); - this.state = 7728; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7729; - this.publication_name_list(); - this.state = 7731; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 691, this.context) ) { - case 1: - { - this.state = 7730; - this.opt_definition(); - } - break; - } + this.state = 5429; + this.match(PostgreSqlParser.KW_PREPARE); + this.state = 5430; + this.match(PostgreSqlParser.KW_TRANSACTION); + this.state = 5431; + this.sconst(); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 7733; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7734; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7735; - this.name(); - this.state = 7736; - this.match(PostgreSqlParser.KW_DROP); - this.state = 7737; - this.match(PostgreSqlParser.KW_PUBLICATION); - this.state = 7738; - this.publication_name_list(); - this.state = 7740; + this.state = 5432; + _la = this.tokenStream.LA(1); + if(!(_la === 161 || _la === 319)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5433; + this.match(PostgreSqlParser.KW_PREPARED); + this.state = 5434; + this.sconst(); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 5435; + _la = this.tokenStream.LA(1); + if(!(_la === 129 || _la === 161 || _la === 319 || _la === 454)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5437; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 692, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 668, this.context) ) { case 1: { - this.state = 7739; - this.opt_definition(); + this.state = 5436; + this.opt_transaction(); } break; } + this.state = 5444; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 670, this.context) ) { + case 1: + { + this.state = 5439; + this.match(PostgreSqlParser.KW_AND); + this.state = 5441; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269) { + { + this.state = 5440; + this.match(PostgreSqlParser.KW_NO); + } + } + + this.state = 5443; + this.match(PostgreSqlParser.KW_CHAIN); + } + break; } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 7742; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7743; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7744; - this.name(); - this.state = 7745; - this.match(PostgreSqlParser.KW_ENABLE); } break; case 8: this.enterOuterAlt(localContext, 8); { - this.state = 7747; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7748; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7749; - this.name(); - this.state = 7750; - this.match(PostgreSqlParser.KW_DISABLE); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 7752; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7753; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7754; - this.name(); - this.state = 7755; - this.match(PostgreSqlParser.KW_SET); - this.state = 7756; - this.definition(); - } - break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 7758; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7759; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7760; - this.name(); - this.state = 7761; - this.match(PostgreSqlParser.KW_SKIP); - this.state = 7762; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 7763; - this.old_aggr_elem(); - this.state = 7764; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 5446; + this.match(PostgreSqlParser.KW_ROLLBACK); + this.state = 5448; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 356 || _la === 380) { + { + this.state = 5447; + this.opt_transaction(); + } } - break; - case 11: - this.enterOuterAlt(localContext, 11); - { - this.state = 7766; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 7767; - this.match(PostgreSqlParser.KW_SUBSCRIPTION); - this.state = 7768; - this.name(); - this.state = 7769; - this.match(PostgreSqlParser.KW_OWNER); - this.state = 7770; + + this.state = 5450; this.match(PostgreSqlParser.KW_TO); - this.state = 7771; - this.rolespec(); + this.state = 5452; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 672, this.context) ) { + case 1: + { + this.state = 5451; + this.match(PostgreSqlParser.KW_SAVEPOINT); + } + break; + } + this.state = 5454; + this.colid(); } break; } @@ -34931,63 +30101,22 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public rulestmt(): RulestmtContext { - let localContext = new RulestmtContext(this.context, this.state); - this.enterRule(localContext, 804, PostgreSqlParser.RULE_rulestmt); + public opt_transaction(): Opt_transactionContext { + let localContext = new Opt_transactionContext(this.context, this.state); + this.enterRule(localContext, 470, PostgreSqlParser.RULE_opt_transaction); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 7775; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 7777; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 82) { - { - this.state = 7776; - this.opt_or_replace(); - } - } - - this.state = 7779; - this.match(PostgreSqlParser.KW_RULE); - this.state = 7780; - this.name(); - this.state = 7781; - this.match(PostgreSqlParser.KW_AS); - this.state = 7782; - this.match(PostgreSqlParser.KW_ON); - this.state = 7783; - this.event(); - this.state = 7784; - this.match(PostgreSqlParser.KW_TO); - this.state = 7785; - this.qualified_name(); - this.state = 7787; - this.errorHandler.sync(this); + this.state = 5457; _la = this.tokenStream.LA(1); - if (_la === 103) { - { - this.state = 7786; - this.where_clause(); - } + if(!(_la === 356 || _la === 380)) { + this.errorHandler.recoverInline(this); } - - this.state = 7789; - this.match(PostgreSqlParser.KW_DO); - this.state = 7791; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 137 || _la === 242) { - { - this.state = 7790; - this.opt_instead(); - } + else { + this.errorHandler.reportMatch(this); + this.consume(); } - - this.state = 7793; - this.ruleactionlist(); } } catch (re) { @@ -35004,38 +30133,61 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public ruleactionlist(): RuleactionlistContext { - let localContext = new RuleactionlistContext(this.context, this.state); - this.enterRule(localContext, 806, PostgreSqlParser.RULE_ruleactionlist); + public transaction_mode_item(): Transaction_mode_itemContext { + let localContext = new Transaction_mode_itemContext(this.context, this.state); + this.enterRule(localContext, 472, PostgreSqlParser.RULE_transaction_mode_item); + let _la: number; try { - this.state = 7801; + this.state = 5468; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 697, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_ISOLATION: this.enterOuterAlt(localContext, 1); { - this.state = 7795; - this.match(PostgreSqlParser.KW_NOTHING); + this.state = 5459; + this.match(PostgreSqlParser.KW_ISOLATION); + this.state = 5460; + this.match(PostgreSqlParser.KW_LEVEL); + this.state = 5461; + this.iso_level(); } break; - case 2: + case PostgreSqlParser.KW_READ: this.enterOuterAlt(localContext, 2); { - this.state = 7796; - this.ruleactionstmt(); + this.state = 5462; + this.match(PostgreSqlParser.KW_READ); + this.state = 5463; + _la = this.tokenStream.LA(1); + if(!(_la === 81 || _la === 382)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } } break; - case 3: + case PostgreSqlParser.KW_DEFERRABLE: + case PostgreSqlParser.KW_NOT: this.enterOuterAlt(localContext, 3); { - this.state = 7797; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 7798; - this.ruleactionmulti(); - this.state = 7799; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 5465; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { + { + this.state = 5464; + this.match(PostgreSqlParser.KW_NOT); + } + } + + this.state = 5467; + this.match(PostgreSqlParser.KW_DEFERRABLE); } break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -35052,46 +30204,41 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public ruleactionmulti(): RuleactionmultiContext { - let localContext = new RuleactionmultiContext(this.context, this.state); - this.enterRule(localContext, 808, PostgreSqlParser.RULE_ruleactionmulti); + public transaction_mode_list(): Transaction_mode_listContext { + let localContext = new Transaction_mode_listContext(this.context, this.state); + this.enterRule(localContext, 474, PostgreSqlParser.RULE_transaction_mode_list); let _la: number; try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 7804; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2 || ((((_la - 88)) & ~0x1F) === 0 && ((1 << (_la - 88)) & 131089) !== 0) || _la === 182 || _la === 241 || _la === 271 || _la === 369 || _la === 422) { - { - this.state = 7803; - this.ruleactionstmtOrEmpty(); - } - } - - this.state = 7812; + this.state = 5470; + this.transaction_mode_item(); + this.state = 5477; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 7) { - { - { - this.state = 7806; - this.match(PostgreSqlParser.SEMI); - this.state = 7808; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2 || ((((_la - 88)) & ~0x1F) === 0 && ((1 << (_la - 88)) & 131089) !== 0) || _la === 182 || _la === 241 || _la === 271 || _la === 369 || _la === 422) { + alternative = this.interpreter.adaptivePredict(this.tokenStream, 677, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { { - this.state = 7807; - this.ruleactionstmtOrEmpty(); + this.state = 5472; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 6) { + { + this.state = 5471; + this.match(PostgreSqlParser.COMMA); + } } - } + this.state = 5474; + this.transaction_mode_item(); + } + } } - } - this.state = 7814; + this.state = 5479; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 677, this.context); } } } @@ -35109,72 +30256,129 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public ruleactionstmt(): RuleactionstmtContext { - let localContext = new RuleactionstmtContext(this.context, this.state); - this.enterRule(localContext, 810, PostgreSqlParser.RULE_ruleactionstmt); + public viewstmt(): ViewstmtContext { + let localContext = new ViewstmtContext(this.context, this.state); + this.enterRule(localContext, 476, PostgreSqlParser.RULE_viewstmt); + let _la: number; try { - this.state = 7820; + localContext = new CreateViewContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 5480; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 5483; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 701, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); + _la = this.tokenStream.LA(1); + if (_la === 82) { { - this.state = 7815; - this.selectstmt(); + this.state = 5481; + this.match(PostgreSqlParser.KW_OR); + this.state = 5482; + this.match(PostgreSqlParser.KW_REPLACE); } - break; - case 2: - this.enterOuterAlt(localContext, 2); + } + + this.state = 5486; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 213 || _la === 254 || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & 32773) !== 0)) { { - this.state = 7816; - this.insertstmt(); + this.state = 5485; + this.opttemp(); } - break; - case 3: - this.enterOuterAlt(localContext, 3); + } + + this.state = 5503; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_VIEW: { - this.state = 7817; - this.updatestmt(); + this.state = 5488; + this.match(PostgreSqlParser.KW_VIEW); + this.state = 5489; + this.view_name_create(); + this.state = 5491; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 5490; + this.opt_column_list_create(); + } + } + + this.state = 5494; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 105) { + { + this.state = 5493; + this.opt_reloptions(); + } + } + } break; - case 4: - this.enterOuterAlt(localContext, 4); + case PostgreSqlParser.KW_RECURSIVE: { - this.state = 7818; - this.deletestmt(); + this.state = 5496; + this.match(PostgreSqlParser.KW_RECURSIVE); + this.state = 5497; + this.match(PostgreSqlParser.KW_VIEW); + this.state = 5498; + this.view_name_create(); + this.state = 5499; + this.opt_column_list(); + this.state = 5501; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 105) { + { + this.state = 5500; + this.opt_reloptions(); + } + } + } break; - case 5: - this.enterOuterAlt(localContext, 5); + default: + throw new antlr.NoViableAltException(this); + } + this.state = 5505; + this.match(PostgreSqlParser.KW_AS); + this.state = 5506; + this.selectstmt(); + this.state = 5513; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 685, this.context) ) { + case 1: { - this.state = 7819; - this.notifystmt(); + this.state = 5507; + this.match(PostgreSqlParser.KW_WITH); + this.state = 5509; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 151 || _la === 254) { + { + this.state = 5508; + _la = this.tokenStream.LA(1); + if(!(_la === 151 || _la === 254)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 5511; + this.match(PostgreSqlParser.KW_CHECK); + this.state = 5512; + this.match(PostgreSqlParser.KW_OPTION); } break; } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public ruleactionstmtOrEmpty(): RuleactionstmtOrEmptyContext { - let localContext = new RuleactionstmtOrEmptyContext(this.context, this.state); - this.enterRule(localContext, 812, PostgreSqlParser.RULE_ruleactionstmtOrEmpty); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 7822; - this.ruleactionstmt(); } } catch (re) { @@ -35191,22 +30395,16 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public event(): EventContext { - let localContext = new EventContext(this.context, this.state); - this.enterRule(localContext, 814, PostgreSqlParser.RULE_event); - let _la: number; + public loadstmt(): LoadstmtContext { + let localContext = new LoadstmtContext(this.context, this.state); + this.enterRule(localContext, 478, PostgreSqlParser.RULE_loadstmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 7824; - _la = this.tokenStream.LA(1); - if(!(_la === 88 || _la === 182 || _la === 241 || _la === 369)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } + this.state = 5515; + this.match(PostgreSqlParser.KW_LOAD); + this.state = 5516; + this.sconst(); } } catch (re) { @@ -35223,21 +30421,57 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_instead(): Opt_insteadContext { - let localContext = new Opt_insteadContext(this.context, this.state); - this.enterRule(localContext, 816, PostgreSqlParser.RULE_opt_instead); - let _la: number; + public createdbstmt(): CreatedbstmtContext { + let localContext = new CreatedbstmtContext(this.context, this.state); + this.enterRule(localContext, 480, PostgreSqlParser.RULE_createdbstmt); try { + let alternative: number; + localContext = new CreateDatabaseContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7826; - _la = this.tokenStream.LA(1); - if(!(_la === 137 || _la === 242)) { - this.errorHandler.recoverInline(this); + this.state = 5518; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 5519; + this.match(PostgreSqlParser.KW_DATABASE); + this.state = 5520; + this.database_name_create(); + this.state = 5522; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 686, this.context) ) { + case 1: + { + this.state = 5521; + this.match(PostgreSqlParser.KW_WITH); + } + break; } - else { - this.errorHandler.reportMatch(this); - this.consume(); + this.state = 5529; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 688, this.context) ) { + case 1: + { + this.state = 5525; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 5524; + this.createdb_opt_item(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 5527; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 687, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + } + break; } } } @@ -35255,27 +30489,260 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public notifystmt(): NotifystmtContext { - let localContext = new NotifystmtContext(this.context, this.state); - this.enterRule(localContext, 818, PostgreSqlParser.RULE_notifystmt); + public createdb_opt_item(): Createdb_opt_itemContext { + let localContext = new Createdb_opt_itemContext(this.context, this.state); + this.enterRule(localContext, 482, PostgreSqlParser.RULE_createdb_opt_item); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 7828; - this.match(PostgreSqlParser.KW_NOTIFY); - this.state = 7829; - this.colid(); - this.state = 7831; + this.state = 5539; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 6) { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_CONNECTION: { - this.state = 7830; - this.notify_payload(); - } - } + this.state = 5531; + this.match(PostgreSqlParser.KW_CONNECTION); + this.state = 5532; + this.match(PostgreSqlParser.KW_LIMIT); + } + break; + case PostgreSqlParser.KW_ENCODING: + { + this.state = 5533; + this.match(PostgreSqlParser.KW_ENCODING); + } + break; + case PostgreSqlParser.KW_LOCATION: + { + this.state = 5534; + this.match(PostgreSqlParser.KW_LOCATION); + } + break; + case PostgreSqlParser.KW_OWNER: + { + this.state = 5535; + this.match(PostgreSqlParser.KW_OWNER); + } + break; + case PostgreSqlParser.KW_TABLESPACE: + { + this.state = 5536; + this.match(PostgreSqlParser.KW_TABLESPACE); + } + break; + case PostgreSqlParser.KW_TEMPLATE: + { + this.state = 5537; + this.match(PostgreSqlParser.KW_TEMPLATE); + } + break; + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 5538; + this.identifier(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 5542; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 10) { + { + this.state = 5541; + this.match(PostgreSqlParser.EQUAL); + } + } + + this.state = 5547; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 691, this.context) ) { + case 1: + { + this.state = 5544; + this.signediconst(); + } + break; + case 2: + { + this.state = 5545; + this.opt_boolean_or_string(); + } + break; + case 3: + { + this.state = 5546; + this.match(PostgreSqlParser.KW_DEFAULT); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public alterdatabasestmt(): AlterdatabasestmtContext { + let localContext = new AlterdatabasestmtContext(this.context, this.state); + this.enterRule(localContext, 484, PostgreSqlParser.RULE_alterdatabasestmt); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 5549; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5550; + this.match(PostgreSqlParser.KW_DATABASE); + this.state = 5551; + this.database_name(); + this.state = 5567; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 696, this.context) ) { + case 1: + { + this.state = 5555; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 692, this.context) ) { + case 1: + { + this.state = 5552; + this.match(PostgreSqlParser.KW_SET); + this.state = 5553; + this.match(PostgreSqlParser.KW_TABLESPACE); + this.state = 5554; + this.tablespace_name_create(); + } + break; + } + } + break; + case 2: + { + this.state = 5565; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 695, this.context) ) { + case 1: + { + this.state = 5558; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 105) { + { + this.state = 5557; + this.match(PostgreSqlParser.KW_WITH); + } + } + this.state = 5561; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 5560; + this.createdb_opt_item(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 5563; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 694, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + } + break; + } + } + break; + } } } catch (re) { @@ -35292,16 +30759,28 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public notify_payload(): Notify_payloadContext { - let localContext = new Notify_payloadContext(this.context, this.state); - this.enterRule(localContext, 820, PostgreSqlParser.RULE_notify_payload); + public alterdatabasesetstmt(): AlterdatabasesetstmtContext { + let localContext = new AlterdatabasesetstmtContext(this.context, this.state); + this.enterRule(localContext, 486, PostgreSqlParser.RULE_alterdatabasesetstmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 7833; - this.match(PostgreSqlParser.COMMA); - this.state = 7834; - this.sconst(); + this.state = 5569; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5570; + this.match(PostgreSqlParser.KW_DATABASE); + this.state = 5571; + this.database_name(); + this.state = 5573; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 697, this.context) ) { + case 1: + { + this.state = 5572; + this.setresetclause(); + } + break; + } } } catch (re) { @@ -35318,16 +30797,22 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public listenstmt(): ListenstmtContext { - let localContext = new ListenstmtContext(this.context, this.state); - this.enterRule(localContext, 822, PostgreSqlParser.RULE_listenstmt); + public altercollationstmt(): AltercollationstmtContext { + let localContext = new AltercollationstmtContext(this.context, this.state); + this.enterRule(localContext, 488, PostgreSqlParser.RULE_altercollationstmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 7836; - this.match(PostgreSqlParser.KW_LISTEN); - this.state = 7837; - this.colid(); + this.state = 5575; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5576; + this.match(PostgreSqlParser.KW_COLLATION); + this.state = 5577; + this.any_name(); + this.state = 5578; + this.match(PostgreSqlParser.KW_REFRESH); + this.state = 5579; + this.match(PostgreSqlParser.KW_VERSION); } } catch (re) { @@ -35344,31 +30829,86 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public unlistenstmt(): UnlistenstmtContext { - let localContext = new UnlistenstmtContext(this.context, this.state); - this.enterRule(localContext, 824, PostgreSqlParser.RULE_unlistenstmt); + public altersystemstmt(): AltersystemstmtContext { + let localContext = new AltersystemstmtContext(this.context, this.state); + this.enterRule(localContext, 490, PostgreSqlParser.RULE_altersystemstmt); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 5581; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5582; + this.match(PostgreSqlParser.KW_SYSTEM); + this.state = 5583; + _la = this.tokenStream.LA(1); + if(!(_la === 313 || _la === 333)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5584; + this.generic_set(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public createdomainstmt(): CreatedomainstmtContext { + let localContext = new CreatedomainstmtContext(this.context, this.state); + this.enterRule(localContext, 492, PostgreSqlParser.RULE_createdomainstmt); + let _la: number; try { - this.state = 7843; + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 5586; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 5587; + this.match(PostgreSqlParser.KW_DOMAIN); + this.state = 5588; + this.any_name(); + this.state = 5590; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 703, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); + _la = this.tokenStream.LA(1); + if (_la === 36) { { - this.state = 7839; - this.match(PostgreSqlParser.KW_UNLISTEN); - this.state = 7840; - this.colid(); + this.state = 5589; + this.match(PostgreSqlParser.KW_AS); } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 7841; - this.match(PostgreSqlParser.KW_UNLISTEN); - this.state = 7842; - this.match(PostgreSqlParser.STAR); + } + + this.state = 5592; + this.typename(); + this.state = 5596; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 699, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 5593; + this.colconstraint(); + } + } } - break; + this.state = 5598; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 699, this.context); + } } } catch (re) { @@ -35385,260 +30925,106 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public transactionstmt(): TransactionstmtContext { - let localContext = new TransactionstmtContext(this.context, this.state); - this.enterRule(localContext, 826, PostgreSqlParser.RULE_transactionstmt); + public alterdomainstmt(): AlterdomainstmtContext { + let localContext = new AlterdomainstmtContext(this.context, this.state); + this.enterRule(localContext, 494, PostgreSqlParser.RULE_alterdomainstmt); let _la: number; try { - this.state = 7910; + this.enterOuterAlt(localContext, 1); + { + this.state = 5599; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5600; + this.match(PostgreSqlParser.KW_DOMAIN); + this.state = 5601; + this.any_name(); + this.state = 5624; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 718, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 703, this.context) ) { case 1: - this.enterOuterAlt(localContext, 1); { - this.state = 7845; - this.match(PostgreSqlParser.KW_ABORT); - this.state = 7847; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 704, this.context) ) { - case 1: - { - this.state = 7846; - this.opt_transaction(); - } - break; - } - this.state = 7850; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 705, this.context) ) { - case 1: - { - this.state = 7849; - this.opt_transaction_chain(); - } - break; - } + this.state = 5602; + this.alter_column_default(); } break; case 2: - this.enterOuterAlt(localContext, 2); { - this.state = 7852; - this.match(PostgreSqlParser.KW_BEGIN); - this.state = 7854; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 706, this.context) ) { - case 1: - { - this.state = 7853; - this.opt_transaction(); - } - break; + this.state = 5603; + _la = this.tokenStream.LA(1); + if(!(_la === 191 || _la === 333)) { + this.errorHandler.recoverInline(this); } - this.state = 7857; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 707, this.context) ) { - case 1: - { - this.state = 7856; - this.transaction_mode_list_or_empty(); - } - break; + else { + this.errorHandler.reportMatch(this); + this.consume(); } + this.state = 5604; + this.match(PostgreSqlParser.KW_NOT); + this.state = 5605; + this.match(PostgreSqlParser.KW_NULL); } break; case 3: - this.enterOuterAlt(localContext, 3); { - this.state = 7859; - this.match(PostgreSqlParser.KW_START); - this.state = 7860; - this.match(PostgreSqlParser.KW_TRANSACTION); - this.state = 7862; + this.state = 5606; + this.match(PostgreSqlParser.KW_ADD); + this.state = 5609; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 708, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 45) { { - this.state = 7861; - this.transaction_mode_list_or_empty(); + this.state = 5607; + this.match(PostgreSqlParser.KW_CONSTRAINT); + this.state = 5608; + this.colid(); } - break; } + + this.state = 5611; + this.constraintelem(); } break; case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 7864; - this.match(PostgreSqlParser.KW_END); - this.state = 7866; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 709, this.context) ) { - case 1: - { - this.state = 7865; - this.opt_transaction(); - } - break; - } - this.state = 7869; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 710, this.context) ) { - case 1: - { - this.state = 7868; - this.opt_transaction_chain(); - } - break; - } - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 7871; - this.match(PostgreSqlParser.KW_SAVEPOINT); - this.state = 7872; - this.colid(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); { - this.state = 7873; - this.match(PostgreSqlParser.KW_RELEASE); - this.state = 7875; + this.state = 5612; + this.match(PostgreSqlParser.KW_DROP); + this.state = 5613; + this.match(PostgreSqlParser.KW_CONSTRAINT); + this.state = 5615; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 711, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 701, this.context) ) { case 1: { - this.state = 7874; - this.match(PostgreSqlParser.KW_SAVEPOINT); + this.state = 5614; + this.opt_if_exists(); } break; } - this.state = 7877; + this.state = 5617; this.colid(); - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 7878; - this.match(PostgreSqlParser.KW_PREPARE); - this.state = 7879; - this.match(PostgreSqlParser.KW_TRANSACTION); - this.state = 7880; - this.sconst(); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 7881; - this.match(PostgreSqlParser.KW_COMMIT); - this.state = 7882; - this.match(PostgreSqlParser.KW_PREPARED); - this.state = 7883; - this.sconst(); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 7884; - this.match(PostgreSqlParser.KW_COMMIT); - this.state = 7886; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 712, this.context) ) { - case 1: - { - this.state = 7885; - this.opt_transaction(); - } - break; - } - this.state = 7889; + this.state = 5619; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 713, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 702, this.context) ) { case 1: { - this.state = 7888; - this.opt_transaction_chain(); + this.state = 5618; + this.opt_drop_behavior(); } break; } } break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 7891; - this.match(PostgreSqlParser.KW_ROLLBACK); - this.state = 7892; - this.match(PostgreSqlParser.KW_PREPARED); - this.state = 7893; - this.sconst(); - } - break; - case 11: - this.enterOuterAlt(localContext, 11); + case 5: { - this.state = 7894; - this.match(PostgreSqlParser.KW_ROLLBACK); - this.state = 7896; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 356 || _la === 380) { - { - this.state = 7895; - this.opt_transaction(); - } - } - - this.state = 7898; - this.match(PostgreSqlParser.KW_TO); - this.state = 7900; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 715, this.context) ) { - case 1: - { - this.state = 7899; - this.match(PostgreSqlParser.KW_SAVEPOINT); - } - break; - } - this.state = 7902; + this.state = 5621; + this.match(PostgreSqlParser.KW_VALIDATE); + this.state = 5622; + this.match(PostgreSqlParser.KW_CONSTRAINT); + this.state = 5623; this.colid(); } break; - case 12: - this.enterOuterAlt(localContext, 12); - { - this.state = 7903; - this.match(PostgreSqlParser.KW_ROLLBACK); - this.state = 7905; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 716, this.context) ) { - case 1: - { - this.state = 7904; - this.opt_transaction(); - } - break; - } - this.state = 7908; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 717, this.context) ) { - case 1: - { - this.state = 7907; - this.opt_transaction_chain(); - } - break; - } - } - break; + } } } catch (re) { @@ -35655,22 +31041,24 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_transaction(): Opt_transactionContext { - let localContext = new Opt_transactionContext(this.context, this.state); - this.enterRule(localContext, 828, PostgreSqlParser.RULE_opt_transaction); - let _la: number; + public altertsdictionarystmt(): AltertsdictionarystmtContext { + let localContext = new AltertsdictionarystmtContext(this.context, this.state); + this.enterRule(localContext, 496, PostgreSqlParser.RULE_altertsdictionarystmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 7912; - _la = this.tokenStream.LA(1); - if(!(_la === 356 || _la === 380)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } + this.state = 5626; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5627; + this.match(PostgreSqlParser.KW_TEXT); + this.state = 5628; + this.match(PostgreSqlParser.KW_SEARCH); + this.state = 5629; + this.match(PostgreSqlParser.KW_DICTIONARY); + this.state = 5630; + this.any_name(); + this.state = 5631; + this.definition(); } } catch (re) { @@ -35687,56 +31075,118 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public transaction_mode_item(): Transaction_mode_itemContext { - let localContext = new Transaction_mode_itemContext(this.context, this.state); - this.enterRule(localContext, 830, PostgreSqlParser.RULE_transaction_mode_item); + public altertsconfigurationstmt(): AltertsconfigurationstmtContext { + let localContext = new AltertsconfigurationstmtContext(this.context, this.state); + this.enterRule(localContext, 498, PostgreSqlParser.RULE_altertsconfigurationstmt); + let _la: number; try { - this.state = 7924; + this.state = 5674; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 719, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 706, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 7914; - this.match(PostgreSqlParser.KW_ISOLATION); - this.state = 7915; - this.match(PostgreSqlParser.KW_LEVEL); - this.state = 7916; - this.iso_level(); + this.state = 5633; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5634; + this.match(PostgreSqlParser.KW_TEXT); + this.state = 5635; + this.match(PostgreSqlParser.KW_SEARCH); + this.state = 5636; + this.match(PostgreSqlParser.KW_CONFIGURATION); + this.state = 5637; + this.any_name(); + this.state = 5638; + _la = this.tokenStream.LA(1); + if(!(_la === 133 || _la === 138)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5639; + this.match(PostgreSqlParser.KW_MAPPING); + this.state = 5640; + this.match(PostgreSqlParser.KW_FOR); + this.state = 5641; + this.name_list(); + this.state = 5642; + this.match(PostgreSqlParser.KW_WITH); + this.state = 5643; + this.any_name_list(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 7917; - this.match(PostgreSqlParser.KW_READ); - this.state = 7918; - this.match(PostgreSqlParser.KW_ONLY); + this.state = 5645; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5646; + this.match(PostgreSqlParser.KW_TEXT); + this.state = 5647; + this.match(PostgreSqlParser.KW_SEARCH); + this.state = 5648; + this.match(PostgreSqlParser.KW_CONFIGURATION); + this.state = 5649; + this.any_name(); + this.state = 5650; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5651; + this.match(PostgreSqlParser.KW_MAPPING); + this.state = 5654; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 62) { + { + this.state = 5652; + this.match(PostgreSqlParser.KW_FOR); + this.state = 5653; + this.name_list(); + } + } + + this.state = 5656; + this.match(PostgreSqlParser.KW_REPLACE); + this.state = 5657; + this.any_name(); + this.state = 5658; + this.match(PostgreSqlParser.KW_WITH); + this.state = 5659; + this.any_name(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 7919; - this.match(PostgreSqlParser.KW_READ); - this.state = 7920; - this.match(PostgreSqlParser.KW_WRITE); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 7921; - this.match(PostgreSqlParser.KW_DEFERRABLE); + this.state = 5661; + this.match(PostgreSqlParser.KW_ALTER); + this.state = 5662; + this.match(PostgreSqlParser.KW_TEXT); + this.state = 5663; + this.match(PostgreSqlParser.KW_SEARCH); + this.state = 5664; + this.match(PostgreSqlParser.KW_CONFIGURATION); + this.state = 5665; + this.any_name(); + this.state = 5666; + this.match(PostgreSqlParser.KW_DROP); + this.state = 5667; + this.match(PostgreSqlParser.KW_MAPPING); + this.state = 5669; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 220) { + { + this.state = 5668; + this.opt_if_exists(); + } } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 7922; - this.match(PostgreSqlParser.KW_NOT); - this.state = 7923; - this.match(PostgreSqlParser.KW_DEFERRABLE); + + this.state = 5671; + this.match(PostgreSqlParser.KW_FOR); + this.state = 5672; + this.name_list(); } break; } @@ -35755,66 +31205,41 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public transaction_mode_list(): Transaction_mode_listContext { - let localContext = new Transaction_mode_listContext(this.context, this.state); - this.enterRule(localContext, 832, PostgreSqlParser.RULE_transaction_mode_list); + public createconversionstmt(): CreateconversionstmtContext { + let localContext = new CreateconversionstmtContext(this.context, this.state); + this.enterRule(localContext, 500, PostgreSqlParser.RULE_createconversionstmt); let _la: number; try { - let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 7926; - this.transaction_mode_item(); - this.state = 7933; + this.state = 5676; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 5678; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 721, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 7928; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 6) { - { - this.state = 7927; - this.match(PostgreSqlParser.COMMA); - } - } - - this.state = 7930; - this.transaction_mode_item(); - } - } + _la = this.tokenStream.LA(1); + if (_la === 53) { + { + this.state = 5677; + this.match(PostgreSqlParser.KW_DEFAULT); } - this.state = 7935; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 721, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; } - } - finally { - this.exitRule(); - } - return localContext; - } - public transaction_mode_list_or_empty(): Transaction_mode_list_or_emptyContext { - let localContext = new Transaction_mode_list_or_emptyContext(this.context, this.state); - this.enterRule(localContext, 834, PostgreSqlParser.RULE_transaction_mode_list_or_empty); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 7936; - this.transaction_mode_list(); + + this.state = 5680; + this.match(PostgreSqlParser.KW_CONVERSION); + this.state = 5681; + this.any_name(); + this.state = 5682; + this.match(PostgreSqlParser.KW_FOR); + this.state = 5683; + this.sconst(); + this.state = 5684; + this.match(PostgreSqlParser.KW_TO); + this.state = 5685; + this.sconst(); + this.state = 5686; + this.match(PostgreSqlParser.KW_FROM); + this.state = 5687; + this.any_name(); } } catch (re) { @@ -35831,27 +31256,92 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_transaction_chain(): Opt_transaction_chainContext { - let localContext = new Opt_transaction_chainContext(this.context, this.state); - this.enterRule(localContext, 836, PostgreSqlParser.RULE_opt_transaction_chain); + public clusterstmt(): ClusterstmtContext { + let localContext = new ClusterstmtContext(this.context, this.state); + this.enterRule(localContext, 502, PostgreSqlParser.RULE_clusterstmt); let _la: number; try { - this.enterOuterAlt(localContext, 1); - { - this.state = 7938; - this.match(PostgreSqlParser.KW_AND); - this.state = 7940; + this.state = 5714; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 269) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 713, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); { - this.state = 7939; - this.match(PostgreSqlParser.KW_NO); + this.state = 5689; + this.match(PostgreSqlParser.KW_CLUSTER); + this.state = 5691; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 128) { + { + this.state = 5690; + this.opt_verbose(); + } } - } - this.state = 7942; - this.match(PostgreSqlParser.KW_CHAIN); + this.state = 5697; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 710, this.context) ) { + case 1: + { + this.state = 5693; + this.table_name(); + this.state = 5695; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 100) { + { + this.state = 5694; + this.table_access_method_clause(); + } + } + + } + break; + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 5699; + this.match(PostgreSqlParser.KW_CLUSTER); + this.state = 5700; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 5701; + this.opt_verbose(); + this.state = 5706; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 5702; + this.match(PostgreSqlParser.COMMA); + this.state = 5703; + this.opt_verbose(); + } + } + this.state = 5708; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 5709; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 5710; + this.table_name(); + this.state = 5712; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 100) { + { + this.state = 5711; + this.table_access_method_clause(); + } + } + + } + break; } } catch (re) { @@ -35868,109 +31358,86 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public viewstmt(): ViewstmtContext { - let localContext = new ViewstmtContext(this.context, this.state); - this.enterRule(localContext, 838, PostgreSqlParser.RULE_viewstmt); + public vacuumstmt(): VacuumstmtContext { + let localContext = new VacuumstmtContext(this.context, this.state); + this.enterRule(localContext, 504, PostgreSqlParser.RULE_vacuumstmt); let _la: number; try { - localContext = new CreateViewContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 7944; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 7947; + this.state = 5716; + this.match(PostgreSqlParser.KW_VACUUM); + this.state = 5732; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 82) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 719, this.context) ) { + case 1: { - this.state = 7945; - this.match(PostgreSqlParser.KW_OR); - this.state = 7946; - this.match(PostgreSqlParser.KW_REPLACE); - } - } - - this.state = 7950; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 213 || _la === 254 || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & 32773) !== 0)) { { - this.state = 7949; - this.opttemp(); + this.state = 5718; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 113) { + { + this.state = 5717; + this.match(PostgreSqlParser.KW_FULL); + } } - } - this.state = 7969; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_VIEW: - { - this.state = 7952; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 7953; - this.view_name_create(); - this.state = 7955; + this.state = 5721; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 2) { + if (_la === 112) { { - this.state = 7954; - this.opt_column_list_create(); + this.state = 5720; + this.match(PostgreSqlParser.KW_FREEZE); } } - this.state = 7958; + this.state = 5724; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 105) { + if (_la === 128) { { - this.state = 7957; - this.opt_reloptions(); + this.state = 5723; + this.opt_verbose(); } } + this.state = 5727; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 717, this.context) ) { + case 1: + { + this.state = 5726; + this.analyze_keyword(); + } + break; + } + } } break; - case PostgreSqlParser.KW_RECURSIVE: + case 2: { - this.state = 7960; - this.match(PostgreSqlParser.KW_RECURSIVE); - this.state = 7961; - this.match(PostgreSqlParser.KW_VIEW); - this.state = 7962; - this.view_name_create(); - this.state = 7963; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 7964; - this.column_list(); - this.state = 7965; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 7967; + this.state = 5730; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 105) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 718, this.context) ) { + case 1: { - this.state = 7966; - this.opt_reloptions(); + this.state = 5729; + this.explain_option_list(); } + break; } - } break; - default: - throw new antlr.NoViableAltException(this); } - this.state = 7971; - this.match(PostgreSqlParser.KW_AS); - this.state = 7972; - this.selectstmt(); - this.state = 7974; + this.state = 5735; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 729, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 720, this.context) ) { case 1: { - this.state = 7973; - this.opt_check_option(); + this.state = 5734; + this.vacuum_relation_list(); } break; } @@ -35990,108 +31457,66 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_check_option(): Opt_check_optionContext { - let localContext = new Opt_check_optionContext(this.context, this.state); - this.enterRule(localContext, 840, PostgreSqlParser.RULE_opt_check_option); + public analyzestmt(): AnalyzestmtContext { + let localContext = new AnalyzestmtContext(this.context, this.state); + this.enterRule(localContext, 506, PostgreSqlParser.RULE_analyzestmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 7976; - this.match(PostgreSqlParser.KW_WITH); - this.state = 7978; + this.state = 5737; + this.analyze_keyword(); + this.state = 5752; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 151 || _la === 254) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 723, this.context) ) { + case 1: { - this.state = 7977; + this.state = 5739; + this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if(!(_la === 151 || _la === 254)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } + if (_la === 128) { + { + this.state = 5738; + this.opt_verbose(); + } } - } - this.state = 7980; - this.match(PostgreSqlParser.KW_CHECK); - this.state = 7981; - this.match(PostgreSqlParser.KW_OPTION); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public loadstmt(): LoadstmtContext { - let localContext = new LoadstmtContext(this.context, this.state); - this.enterRule(localContext, 842, PostgreSqlParser.RULE_loadstmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 7983; - this.match(PostgreSqlParser.KW_LOAD); - this.state = 7984; - this.file_name(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createdbstmt(): CreatedbstmtContext { - let localContext = new CreatedbstmtContext(this.context, this.state); - this.enterRule(localContext, 844, PostgreSqlParser.RULE_createdbstmt); - try { - localContext = new CreateDatabaseContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 7986; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 7987; - this.match(PostgreSqlParser.KW_DATABASE); - this.state = 7988; - this.database_name_create(); - this.state = 7990; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 731, this.context) ) { - case 1: + } + break; + case 2: { - this.state = 7989; - this.opt_with(); + this.state = 5741; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 5742; + this.analyze_option_elem(); + this.state = 5747; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 5743; + this.match(PostgreSqlParser.COMMA); + this.state = 5744; + this.analyze_option_elem(); + } + } + this.state = 5749; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 5750; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; } - this.state = 7993; + this.state = 5755; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 732, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 724, this.context) ) { case 1: { - this.state = 7992; - this.createdb_opt_list(); + this.state = 5754; + this.vacuum_relation_list(); } break; } @@ -36111,113 +31536,21 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public createdb_opt_list(): Createdb_opt_listContext { - let localContext = new Createdb_opt_listContext(this.context, this.state); - this.enterRule(localContext, 846, PostgreSqlParser.RULE_createdb_opt_list); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 7995; - this.createdb_opt_items(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createdb_opt_items(): Createdb_opt_itemsContext { - let localContext = new Createdb_opt_itemsContext(this.context, this.state); - this.enterRule(localContext, 848, PostgreSqlParser.RULE_createdb_opt_items); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 7998; - this.errorHandler.sync(this); - alternative = 1; - do { - switch (alternative) { - case 1: - { - { - this.state = 7997; - this.createdb_opt_item(); - } - } - break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 8000; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 733, this.context); - } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createdb_opt_item(): Createdb_opt_itemContext { - let localContext = new Createdb_opt_itemContext(this.context, this.state); - this.enterRule(localContext, 850, PostgreSqlParser.RULE_createdb_opt_item); + public analyze_keyword(): Analyze_keywordContext { + let localContext = new Analyze_keywordContext(this.context, this.state); + this.enterRule(localContext, 508, PostgreSqlParser.RULE_analyze_keyword); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8002; - this.createdb_opt_name(); - this.state = 8004; - this.errorHandler.sync(this); + this.state = 5757; _la = this.tokenStream.LA(1); - if (_la === 10) { - { - this.state = 8003; - this.opt_equal(); - } + if(!(_la === 31 || _la === 32)) { + this.errorHandler.recoverInline(this); } - - this.state = 8009; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 735, this.context) ) { - case 1: - { - this.state = 8006; - this.signediconst(); - } - break; - case 2: - { - this.state = 8007; - this.opt_boolean_or_string(); - } - break; - case 3: - { - this.state = 8008; - this.match(PostgreSqlParser.KW_DEFAULT); - } - break; + else { + this.errorHandler.reportMatch(this); + this.consume(); } } } @@ -36235,57 +31568,15 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public createdb_opt_name(): Createdb_opt_nameContext { - let localContext = new Createdb_opt_nameContext(this.context, this.state); - this.enterRule(localContext, 852, PostgreSqlParser.RULE_createdb_opt_name); + public vac_analyze_option_elem(): Vac_analyze_option_elemContext { + let localContext = new Vac_analyze_option_elemContext(this.context, this.state); + this.enterRule(localContext, 510, PostgreSqlParser.RULE_vac_analyze_option_elem); try { - this.state = 8019; + this.enterOuterAlt(localContext, 1); + { + this.state = 5761; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_CONNECTION: - this.enterOuterAlt(localContext, 1); - { - this.state = 8011; - this.match(PostgreSqlParser.KW_CONNECTION); - this.state = 8012; - this.match(PostgreSqlParser.KW_LIMIT); - } - break; - case PostgreSqlParser.KW_ENCODING: - this.enterOuterAlt(localContext, 2); - { - this.state = 8013; - this.match(PostgreSqlParser.KW_ENCODING); - } - break; - case PostgreSqlParser.KW_LOCATION: - this.enterOuterAlt(localContext, 3); - { - this.state = 8014; - this.match(PostgreSqlParser.KW_LOCATION); - } - break; - case PostgreSqlParser.KW_OWNER: - this.enterOuterAlt(localContext, 4); - { - this.state = 8015; - this.match(PostgreSqlParser.KW_OWNER); - } - break; - case PostgreSqlParser.KW_TABLESPACE: - this.enterOuterAlt(localContext, 5); - { - this.state = 8016; - this.match(PostgreSqlParser.KW_TABLESPACE); - } - break; - case PostgreSqlParser.KW_TEMPLATE: - this.enterOuterAlt(localContext, 6); - { - this.state = 8017; - this.match(PostgreSqlParser.KW_TEMPLATE); - } - break; case PostgreSqlParser.KW_AND: case PostgreSqlParser.KW_ARRAY: case PostgreSqlParser.KW_COLLATE: @@ -36293,34 +31584,380 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_DEFAULT: case PostgreSqlParser.KW_DO: case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_AUTHORIZATION: + case PostgreSqlParser.KW_BINARY: + case PostgreSqlParser.KW_COLLATION: + case PostgreSqlParser.KW_CONCURRENTLY: + case PostgreSqlParser.KW_CROSS: + case PostgreSqlParser.KW_CURRENT_SCHEMA: + case PostgreSqlParser.KW_FREEZE: + case PostgreSqlParser.KW_FULL: + case PostgreSqlParser.KW_ILIKE: + case PostgreSqlParser.KW_INNER: case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_ISNULL: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_LIKE: + case PostgreSqlParser.KW_NATURAL: + case PostgreSqlParser.KW_NOTNULL: case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_OVERLAPS: + case PostgreSqlParser.KW_RIGHT: + case PostgreSqlParser.KW_SIMILAR: + case PostgreSqlParser.KW_VERBOSE: + case PostgreSqlParser.KW_ABORT: case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: case PostgreSqlParser.KW_NEXT: case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: case PostgreSqlParser.KW_SCHEMA: case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: case PostgreSqlParser.KW_CALL: case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_TABLESAMPLE: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: case PostgreSqlParser.KW_DUMP: case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: case PostgreSqlParser.KW_VARIABLE_CONFLICT: @@ -36349,6 +31986,8 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_EXCEPTION: case PostgreSqlParser.KW_ASSERT: case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: case PostgreSqlParser.Identifier: case PostgreSqlParser.QuotedIdentifier: case PostgreSqlParser.UnicodeQuotedIdentifier: @@ -36358,191 +31997,466 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLVARIABLENAME: case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 7); - { - this.state = 8018; - this.identifier(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_equal(): Opt_equalContext { - let localContext = new Opt_equalContext(this.context, this.state); - this.enterRule(localContext, 854, PostgreSqlParser.RULE_opt_equal); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8021; - this.match(PostgreSqlParser.EQUAL); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alterdatabasestmt(): AlterdatabasestmtContext { - let localContext = new AlterdatabasestmtContext(this.context, this.state); - this.enterRule(localContext, 856, PostgreSqlParser.RULE_alterdatabasestmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8023; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8024; - this.match(PostgreSqlParser.KW_DATABASE); - this.state = 8025; - this.database_name(); - this.state = 8037; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 740, this.context) ) { - case 1: { - this.state = 8029; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 737, this.context) ) { - case 1: - { - this.state = 8026; - this.match(PostgreSqlParser.KW_SET); - this.state = 8027; - this.match(PostgreSqlParser.KW_TABLESPACE); - this.state = 8028; - this.tablespace_name_create(); - } - break; - } + this.state = 5759; + this.nonreservedword(); } break; - case 2: + case PostgreSqlParser.KW_ANALYSE: + case PostgreSqlParser.KW_ANALYZE: { - this.state = 8035; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 739, this.context) ) { - case 1: - { - this.state = 8032; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 105) { - { - this.state = 8031; - this.match(PostgreSqlParser.KW_WITH); - } - } - - this.state = 8034; - this.createdb_opt_list(); - } - break; - } + this.state = 5760; + this.analyze_keyword(); } break; + default: + throw new antlr.NoViableAltException(this); } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public alterdatabasesetstmt(): AlterdatabasesetstmtContext { - let localContext = new AlterdatabasesetstmtContext(this.context, this.state); - this.enterRule(localContext, 858, PostgreSqlParser.RULE_alterdatabasesetstmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8039; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8040; - this.match(PostgreSqlParser.KW_DATABASE); - this.state = 8041; - this.database_name(); - this.state = 8043; + this.state = 5765; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 741, this.context) ) { - case 1: - { - this.state = 8042; - this.setresetclause(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public drop_option_list(): Drop_option_listContext { - let localContext = new Drop_option_listContext(this.context, this.state); - this.enterRule(localContext, 860, PostgreSqlParser.RULE_drop_option_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8045; - this.drop_option(); - this.state = 8050; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FALSE: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_ON: + case PostgreSqlParser.KW_TRUE: + case PostgreSqlParser.KW_AUTHORIZATION: + case PostgreSqlParser.KW_BINARY: + case PostgreSqlParser.KW_COLLATION: + case PostgreSqlParser.KW_CONCURRENTLY: + case PostgreSqlParser.KW_CROSS: + case PostgreSqlParser.KW_CURRENT_SCHEMA: + case PostgreSqlParser.KW_FREEZE: + case PostgreSqlParser.KW_FULL: + case PostgreSqlParser.KW_ILIKE: + case PostgreSqlParser.KW_INNER: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_ISNULL: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_LIKE: + case PostgreSqlParser.KW_NATURAL: + case PostgreSqlParser.KW_NOTNULL: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_OVERLAPS: + case PostgreSqlParser.KW_RIGHT: + case PostgreSqlParser.KW_SIMILAR: + case PostgreSqlParser.KW_VERBOSE: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_TABLESAMPLE: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: { - this.state = 8046; - this.match(PostgreSqlParser.COMMA); - this.state = 8047; - this.drop_option(); + this.state = 5763; + this.opt_boolean_or_string(); } + break; + case PostgreSqlParser.PLUS: + case PostgreSqlParser.MINUS: + case PostgreSqlParser.Integral: + case PostgreSqlParser.Numeric: + { + this.state = 5764; + this.numericonly(); } - this.state = 8052; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); + break; + case PostgreSqlParser.CLOSE_PAREN: + case PostgreSqlParser.COMMA: + break; + default: + break; } } } @@ -36560,14 +32474,79 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public drop_option(): Drop_optionContext { - let localContext = new Drop_optionContext(this.context, this.state); - this.enterRule(localContext, 862, PostgreSqlParser.RULE_drop_option); + public analyze_option_elem(): Analyze_option_elemContext { + let localContext = new Analyze_option_elemContext(this.context, this.state); + this.enterRule(localContext, 512, PostgreSqlParser.RULE_analyze_option_elem); + let _la: number; try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8053; - this.match(PostgreSqlParser.KW_FORCE); + this.state = 5776; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_VERBOSE: + case PostgreSqlParser.KW_SKIP_LOCKED: + this.enterOuterAlt(localContext, 1); + { + this.state = 5767; + _la = this.tokenStream.LA(1); + if(!(_la === 128 || _la === 547)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5769; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 60 || _la === 96) { + { + this.state = 5768; + _la = this.tokenStream.LA(1); + if(!(_la === 60 || _la === 96)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + } + break; + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + this.enterOuterAlt(localContext, 2); + { + this.state = 5771; + this.match(PostgreSqlParser.KW_BUFFER_USAGE_LIMIT); + this.state = 5774; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.PLUS: + case PostgreSqlParser.MINUS: + case PostgreSqlParser.Integral: + case PostgreSqlParser.Numeric: + { + this.state = 5772; + this.numericonly(); + } + break; + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 5773; + this.sconst(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -36584,22 +32563,32 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public altercollationstmt(): AltercollationstmtContext { - let localContext = new AltercollationstmtContext(this.context, this.state); - this.enterRule(localContext, 864, PostgreSqlParser.RULE_altercollationstmt); + public opt_verbose(): Opt_verboseContext { + let localContext = new Opt_verboseContext(this.context, this.state); + this.enterRule(localContext, 514, PostgreSqlParser.RULE_opt_verbose); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8055; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8056; - this.match(PostgreSqlParser.KW_COLLATION); - this.state = 8057; - this.any_name(); - this.state = 8058; - this.match(PostgreSqlParser.KW_REFRESH); - this.state = 8059; - this.match(PostgreSqlParser.KW_VERSION); + this.state = 5778; + this.match(PostgreSqlParser.KW_VERBOSE); + this.state = 5780; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 60 || _la === 96) { + { + this.state = 5779; + _la = this.tokenStream.LA(1); + if(!(_la === 60 || _la === 96)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + } } catch (re) { @@ -36616,28 +32605,24 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public altersystemstmt(): AltersystemstmtContext { - let localContext = new AltersystemstmtContext(this.context, this.state); - this.enterRule(localContext, 866, PostgreSqlParser.RULE_altersystemstmt); - let _la: number; + public vacuum_relation(): Vacuum_relationContext { + let localContext = new Vacuum_relationContext(this.context, this.state); + this.enterRule(localContext, 516, PostgreSqlParser.RULE_vacuum_relation); try { this.enterOuterAlt(localContext, 1); { - this.state = 8061; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8062; - this.match(PostgreSqlParser.KW_SYSTEM); - this.state = 8063; - _la = this.tokenStream.LA(1); - if(!(_la === 313 || _la === 333)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); + this.state = 5782; + this.table_name(); + this.state = 5784; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 731, this.context) ) { + case 1: + { + this.state = 5783; + this.opt_column_list(); + } + break; } - this.state = 8064; - this.generic_set(); } } catch (re) { @@ -36654,33 +32639,31 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public createdomainstmt(): CreatedomainstmtContext { - let localContext = new CreatedomainstmtContext(this.context, this.state); - this.enterRule(localContext, 868, PostgreSqlParser.RULE_createdomainstmt); + public vacuum_relation_list(): Vacuum_relation_listContext { + let localContext = new Vacuum_relation_listContext(this.context, this.state); + this.enterRule(localContext, 518, PostgreSqlParser.RULE_vacuum_relation_list); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8066; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 8067; - this.match(PostgreSqlParser.KW_DOMAIN); - this.state = 8068; - this.any_name(); - this.state = 8070; + this.state = 5786; + this.vacuum_relation(); + this.state = 5791; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 36) { + while (_la === 6) { { - this.state = 8069; - this.opt_as(); + { + this.state = 5787; + this.match(PostgreSqlParser.COMMA); + this.state = 5788; + this.vacuum_relation(); } + } + this.state = 5793; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - - this.state = 8072; - this.typename(); - this.state = 8073; - this.colquallist(); } } catch (re) { @@ -36697,154 +32680,65 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public alterdomainstmt(): AlterdomainstmtContext { - let localContext = new AlterdomainstmtContext(this.context, this.state); - this.enterRule(localContext, 870, PostgreSqlParser.RULE_alterdomainstmt); + public explainstmt(): ExplainstmtContext { + let localContext = new ExplainstmtContext(this.context, this.state); + this.enterRule(localContext, 520, PostgreSqlParser.RULE_explainstmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8075; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8076; - this.match(PostgreSqlParser.KW_DOMAIN); - this.state = 8077; - this.any_name(); - this.state = 8099; + this.state = 5794; + this.match(PostgreSqlParser.KW_EXPLAIN); + this.state = 5805; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 746, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 736, this.context) ) { case 1: { - this.state = 8078; - this.alter_column_default(); + this.state = 5795; + this.explain_option_list(); } break; case 2: { - this.state = 8079; - this.match(PostgreSqlParser.KW_DROP); - this.state = 8080; - this.match(PostgreSqlParser.KW_NOT); - this.state = 8081; - this.match(PostgreSqlParser.KW_NULL); - } - break; - case 3: - { - this.state = 8082; - this.match(PostgreSqlParser.KW_SET); - this.state = 8083; - this.match(PostgreSqlParser.KW_NOT); - this.state = 8084; - this.match(PostgreSqlParser.KW_NULL); + this.state = 5797; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 128) { + { + this.state = 5796; + this.match(PostgreSqlParser.KW_VERBOSE); + } } - break; - case 4: - { - this.state = 8085; - this.match(PostgreSqlParser.KW_ADD); - this.state = 8086; - this.tableconstraint(); + } break; - case 5: + case 3: { - this.state = 8087; - this.match(PostgreSqlParser.KW_DROP); - this.state = 8088; - this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 8090; + this.state = 5803; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 744, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 31 || _la === 32) { { - this.state = 8089; - this.opt_if_exists(); + this.state = 5799; + this.analyze_keyword(); + this.state = 5801; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 128) { + { + this.state = 5800; + this.opt_verbose(); + } } - break; - } - this.state = 8092; - this.name(); - this.state = 8094; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 745, this.context) ) { - case 1: - { - this.state = 8093; - this.opt_drop_behavior(); + } - break; } + } break; - case 6: - { - this.state = 8096; - this.match(PostgreSqlParser.KW_VALIDATE); - this.state = 8097; - this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 8098; - this.name(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_as(): Opt_asContext { - let localContext = new Opt_asContext(this.context, this.state); - this.enterRule(localContext, 872, PostgreSqlParser.RULE_opt_as); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8101; - this.match(PostgreSqlParser.KW_AS); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; } - } - finally { - this.exitRule(); - } - return localContext; - } - public altertsdictionarystmt(): AltertsdictionarystmtContext { - let localContext = new AltertsdictionarystmtContext(this.context, this.state); - this.enterRule(localContext, 874, PostgreSqlParser.RULE_altertsdictionarystmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8103; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8104; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 8105; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 8106; - this.match(PostgreSqlParser.KW_DICTIONARY); - this.state = 8107; - this.any_name(); - this.state = 8108; - this.definition(); + this.state = 5807; + this.explainablestmt(); } } catch (re) { @@ -36861,157 +32755,74 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public altertsconfigurationstmt(): AltertsconfigurationstmtContext { - let localContext = new AltertsconfigurationstmtContext(this.context, this.state); - this.enterRule(localContext, 876, PostgreSqlParser.RULE_altertsconfigurationstmt); - let _la: number; + public explainablestmt(): ExplainablestmtContext { + let localContext = new ExplainablestmtContext(this.context, this.state); + this.enterRule(localContext, 522, PostgreSqlParser.RULE_explainablestmt); try { - this.state = 8173; + this.state = 5818; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 748, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 737, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 8110; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8111; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 8112; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 8113; - this.match(PostgreSqlParser.KW_CONFIGURATION); - this.state = 8114; - this.any_name(); - this.state = 8115; - this.match(PostgreSqlParser.KW_ADD); - this.state = 8116; - this.match(PostgreSqlParser.KW_MAPPING); - this.state = 8117; - this.match(PostgreSqlParser.KW_FOR); - this.state = 8118; - this.name_list(); - this.state = 8119; - this.any_with(); - this.state = 8120; - this.any_name_list(); + this.state = 5809; + this.selectstmt(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 8122; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8123; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 8124; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 8125; - this.match(PostgreSqlParser.KW_CONFIGURATION); - this.state = 8126; - this.any_name(); - this.state = 8127; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8128; - this.match(PostgreSqlParser.KW_MAPPING); - this.state = 8129; - this.match(PostgreSqlParser.KW_FOR); - this.state = 8130; - this.name_list(); - this.state = 8131; - this.any_with(); - this.state = 8132; - this.any_name_list(); + this.state = 5810; + this.insertstmt(); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 8134; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8135; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 8136; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 8137; - this.match(PostgreSqlParser.KW_CONFIGURATION); - this.state = 8138; - this.any_name(); - this.state = 8139; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8140; - this.match(PostgreSqlParser.KW_MAPPING); - this.state = 8141; - this.match(PostgreSqlParser.KW_REPLACE); - this.state = 8142; - this.any_name(); - this.state = 8143; - this.any_with(); - this.state = 8144; - this.any_name(); + this.state = 5811; + this.updatestmt(); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 8146; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8147; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 8148; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 8149; - this.match(PostgreSqlParser.KW_CONFIGURATION); - this.state = 8150; - this.any_name(); - this.state = 8151; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8152; - this.match(PostgreSqlParser.KW_MAPPING); - this.state = 8153; - this.match(PostgreSqlParser.KW_FOR); - this.state = 8154; - this.name_list(); - this.state = 8155; - this.match(PostgreSqlParser.KW_REPLACE); - this.state = 8156; - this.any_name(); - this.state = 8157; - this.any_with(); - this.state = 8158; - this.any_name(); + this.state = 5812; + this.deletestmt(); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 8160; - this.match(PostgreSqlParser.KW_ALTER); - this.state = 8161; - this.match(PostgreSqlParser.KW_TEXT); - this.state = 8162; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 8163; - this.match(PostgreSqlParser.KW_CONFIGURATION); - this.state = 8164; - this.any_name(); - this.state = 8165; - this.match(PostgreSqlParser.KW_DROP); - this.state = 8166; - this.match(PostgreSqlParser.KW_MAPPING); - this.state = 8168; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 220) { - { - this.state = 8167; - this.opt_if_exists(); - } + this.state = 5813; + this.declarecursorstmt(); } - - this.state = 8170; - this.match(PostgreSqlParser.KW_FOR); - this.state = 8171; - this.name_list(); + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 5814; + this.createasstmt(); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 5815; + this.creatematviewstmt(); + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 5816; + this.refreshmatviewstmt(); + } + break; + case 9: + this.enterOuterAlt(localContext, 9); + { + this.state = 5817; + this.executestmt(); } break; } @@ -37030,65 +32841,35 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public any_with(): Any_withContext { - let localContext = new Any_withContext(this.context, this.state); - this.enterRule(localContext, 878, PostgreSqlParser.RULE_any_with); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8175; - this.match(PostgreSqlParser.KW_WITH); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public createconversionstmt(): CreateconversionstmtContext { - let localContext = new CreateconversionstmtContext(this.context, this.state); - this.enterRule(localContext, 880, PostgreSqlParser.RULE_createconversionstmt); + public explain_option_list(): Explain_option_listContext { + let localContext = new Explain_option_listContext(this.context, this.state); + this.enterRule(localContext, 524, PostgreSqlParser.RULE_explain_option_list); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8177; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 8179; + this.state = 5820; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 5821; + this.vac_analyze_option_elem(); + this.state = 5826; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 53) { + while (_la === 6) { + { { - this.state = 8178; - this.opt_default(); + this.state = 5822; + this.match(PostgreSqlParser.COMMA); + this.state = 5823; + this.vac_analyze_option_elem(); + } } + this.state = 5828; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - - this.state = 8181; - this.match(PostgreSqlParser.KW_CONVERSION); - this.state = 8182; - this.any_name(); - this.state = 8183; - this.match(PostgreSqlParser.KW_FOR); - this.state = 8184; - this.sconst(); - this.state = 8185; - this.match(PostgreSqlParser.KW_TO); - this.state = 8186; - this.sconst(); - this.state = 8187; - this.match(PostgreSqlParser.KW_FROM); - this.state = 8188; - this.any_name(); + this.state = 5829; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -37105,81 +32886,31 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public clusterstmt(): ClusterstmtContext { - let localContext = new ClusterstmtContext(this.context, this.state); - this.enterRule(localContext, 882, PostgreSqlParser.RULE_clusterstmt); + public preparestmt(): PreparestmtContext { + let localContext = new PreparestmtContext(this.context, this.state); + this.enterRule(localContext, 526, PostgreSqlParser.RULE_preparestmt); let _la: number; try { - this.state = 8208; + this.enterOuterAlt(localContext, 1); + { + this.state = 5831; + this.match(PostgreSqlParser.KW_PREPARE); + this.state = 5832; + this.colid(); + this.state = 5834; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 754, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 8190; - this.match(PostgreSqlParser.KW_CLUSTER); - this.state = 8192; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 128) { - { - this.state = 8191; - this.opt_verbose(); - } - } - - this.state = 8194; - this.table_name(); - this.state = 8196; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 100) { - { - this.state = 8195; - this.cluster_index_specification(); - } - } - - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 8198; - this.match(PostgreSqlParser.KW_CLUSTER); - this.state = 8200; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 128) { - { - this.state = 8199; - this.opt_verbose(); - } - } - - } - break; - case 3: - this.enterOuterAlt(localContext, 3); + _la = this.tokenStream.LA(1); + if (_la === 2) { { - this.state = 8202; - this.match(PostgreSqlParser.KW_CLUSTER); - this.state = 8203; - this.opt_verbose_list(); - this.state = 8204; - this.table_name(); - this.state = 8206; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 100) { - { - this.state = 8205; - this.cluster_index_specification(); - } + this.state = 5833; + this.prep_type_clause(); } + } - } - break; + this.state = 5836; + this.match(PostgreSqlParser.KW_AS); + this.state = 5837; + this.preparablestmt(); } } catch (re) { @@ -37196,34 +32927,34 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_verbose_list(): Opt_verbose_listContext { - let localContext = new Opt_verbose_listContext(this.context, this.state); - this.enterRule(localContext, 884, PostgreSqlParser.RULE_opt_verbose_list); + public prep_type_clause(): Prep_type_clauseContext { + let localContext = new Prep_type_clauseContext(this.context, this.state); + this.enterRule(localContext, 528, PostgreSqlParser.RULE_prep_type_clause); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8210; + this.state = 5839; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8211; - this.opt_verbose(); - this.state = 8216; + this.state = 5840; + this.typename(); + this.state = 5845; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 8212; + this.state = 5841; this.match(PostgreSqlParser.COMMA); - this.state = 8213; - this.opt_verbose(); + this.state = 5842; + this.typename(); } } - this.state = 8218; + this.state = 5847; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } - this.state = 8219; + this.state = 5848; this.match(PostgreSqlParser.CLOSE_PAREN); } } @@ -37241,16 +32972,41 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public cluster_index_specification(): Cluster_index_specificationContext { - let localContext = new Cluster_index_specificationContext(this.context, this.state); - this.enterRule(localContext, 886, PostgreSqlParser.RULE_cluster_index_specification); + public preparablestmt(): PreparablestmtContext { + let localContext = new PreparablestmtContext(this.context, this.state); + this.enterRule(localContext, 530, PostgreSqlParser.RULE_preparablestmt); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8221; - this.match(PostgreSqlParser.KW_USING); - this.state = 8222; - this.name(); + this.state = 5854; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 741, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 5850; + this.selectstmt(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 5851; + this.insertstmt(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 5852; + this.updatestmt(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 5853; + this.deletestmt(); + } + break; } } catch (re) { @@ -37267,217 +33023,92 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public vacuumstmt(): VacuumstmtContext { - let localContext = new VacuumstmtContext(this.context, this.state); - this.enterRule(localContext, 888, PostgreSqlParser.RULE_vacuumstmt); + public executestmt(): ExecutestmtContext { + let localContext = new ExecutestmtContext(this.context, this.state); + this.enterRule(localContext, 532, PostgreSqlParser.RULE_executestmt); let _la: number; try { - this.state = 8250; + this.state = 5879; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 763, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_EXECUTE: this.enterOuterAlt(localContext, 1); { - this.state = 8224; - this.match(PostgreSqlParser.KW_VACUUM); - this.state = 8226; + this.state = 5856; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 5857; + this.colid(); + this.state = 5859; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 113) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 742, this.context) ) { + case 1: { - this.state = 8225; - this.opt_full(); + this.state = 5858; + this.execute_param_clause(); } + break; } - - this.state = 8229; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 112) { - { - this.state = 8228; - this.opt_freeze(); - } } - - this.state = 8232; + break; + case PostgreSqlParser.KW_CREATE: + this.enterOuterAlt(localContext, 2); + { + this.state = 5861; + this.match(PostgreSqlParser.KW_CREATE); + this.state = 5863; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 128) { + if (_la === 213 || _la === 254 || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & 32773) !== 0)) { { - this.state = 8231; - this.opt_verbose(); + this.state = 5862; + this.opttemp(); } } - this.state = 8235; + this.state = 5865; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 5867; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 759, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 744, this.context) ) { case 1: { - this.state = 8234; - this.opt_analyze(); + this.state = 5866; + this.opt_if_not_exists(); } break; } - this.state = 8238; + this.state = 5869; + this.create_as_target(); + this.state = 5870; + this.match(PostgreSqlParser.KW_AS); + this.state = 5871; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 5872; + this.colid(); + this.state = 5874; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 760, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 745, this.context) ) { case 1: { - this.state = 8237; - this.opt_vacuum_relation_list(); + this.state = 5873; + this.execute_param_clause(); } break; } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 8240; - this.match(PostgreSqlParser.KW_VACUUM); - this.state = 8245; + this.state = 5877; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 761, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 746, this.context) ) { case 1: { - this.state = 8241; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8242; - this.vac_analyze_option_list(); - this.state = 8243; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - this.state = 8248; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 762, this.context) ) { - case 1: - { - this.state = 8247; - this.opt_vacuum_relation_list(); - } - break; - } - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public analyzestmt(): AnalyzestmtContext { - let localContext = new AnalyzestmtContext(this.context, this.state); - this.enterRule(localContext, 890, PostgreSqlParser.RULE_analyzestmt); - let _la: number; - try { - this.state = 8266; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 767, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 8252; - this.analyze_keyword(); - this.state = 8254; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 128) { - { - this.state = 8253; - this.opt_verbose(); - } - } - - this.state = 8257; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 765, this.context) ) { - case 1: - { - this.state = 8256; - this.opt_vacuum_relation_list(); + this.state = 5876; + this.opt_with_data(); } break; } } break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 8259; - this.analyze_keyword(); - this.state = 8260; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8261; - this.analyze_options_list(); - this.state = 8262; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 8264; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 766, this.context) ) { - case 1: - { - this.state = 8263; - this.opt_vacuum_relation_list(); - } - break; - } - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public vac_analyze_option_list(): Vac_analyze_option_listContext { - let localContext = new Vac_analyze_option_listContext(this.context, this.state); - this.enterRule(localContext, 892, PostgreSqlParser.RULE_vac_analyze_option_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8268; - this.vac_analyze_option_elem(); - this.state = 8273; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 8269; - this.match(PostgreSqlParser.COMMA); - this.state = 8270; - this.vac_analyze_option_elem(); - } - } - this.state = 8275; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -37494,22 +33125,18 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public analyze_keyword(): Analyze_keywordContext { - let localContext = new Analyze_keywordContext(this.context, this.state); - this.enterRule(localContext, 894, PostgreSqlParser.RULE_analyze_keyword); - let _la: number; + public execute_param_clause(): Execute_param_clauseContext { + let localContext = new Execute_param_clauseContext(this.context, this.state); + this.enterRule(localContext, 534, PostgreSqlParser.RULE_execute_param_clause); try { this.enterOuterAlt(localContext, 1); { - this.state = 8276; - _la = this.tokenStream.LA(1); - if(!(_la === 31 || _la === 32)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } + this.state = 5881; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 5882; + this.expr_list(); + this.state = 5883; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -37526,46 +33153,25 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public vac_analyze_option_elem(): Vac_analyze_option_elemContext { - let localContext = new Vac_analyze_option_elemContext(this.context, this.state); - this.enterRule(localContext, 896, PostgreSqlParser.RULE_vac_analyze_option_elem); - let _la: number; + public deallocatestmt(): DeallocatestmtContext { + let localContext = new DeallocatestmtContext(this.context, this.state); + this.enterRule(localContext, 536, PostgreSqlParser.RULE_deallocatestmt); try { this.enterOuterAlt(localContext, 1); { - this.state = 8278; - this.vac_analyze_option_name(); - this.state = 8280; + this.state = 5885; + this.match(PostgreSqlParser.KW_DEALLOCATE); + this.state = 5887; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 12 || _la === 13 || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 420484101) !== 0) || ((((_la - 80)) & ~0x1F) === 0 && ((1 << (_la - 80)) & 4227923969) !== 0) || ((((_la - 112)) & ~0x1F) === 0 && ((1 << (_la - 112)) & 4294967295) !== 0) || ((((_la - 144)) & ~0x1F) === 0 && ((1 << (_la - 144)) & 4294967295) !== 0) || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & 4294967295) !== 0) || ((((_la - 208)) & ~0x1F) === 0 && ((1 << (_la - 208)) & 3223322623) !== 0) || ((((_la - 240)) & ~0x1F) === 0 && ((1 << (_la - 240)) & 4294967295) !== 0) || ((((_la - 272)) & ~0x1F) === 0 && ((1 << (_la - 272)) & 4294967295) !== 0) || ((((_la - 304)) & ~0x1F) === 0 && ((1 << (_la - 304)) & 4294967295) !== 0) || ((((_la - 336)) & ~0x1F) === 0 && ((1 << (_la - 336)) & 4294967295) !== 0) || ((((_la - 368)) & ~0x1F) === 0 && ((1 << (_la - 368)) & 4294967295) !== 0) || ((((_la - 400)) & ~0x1F) === 0 && ((1 << (_la - 400)) & 4294967295) !== 0) || ((((_la - 432)) & ~0x1F) === 0 && ((1 << (_la - 432)) & 4290772991) !== 0) || ((((_la - 464)) & ~0x1F) === 0 && ((1 << (_la - 464)) & 4294967295) !== 0) || ((((_la - 496)) & ~0x1F) === 0 && ((1 << (_la - 496)) & 25165183) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 486582415) !== 0) || _la === 584) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 748, this.context) ) { + case 1: { - this.state = 8279; - this.vac_analyze_option_arg(); + this.state = 5886; + this.match(PostgreSqlParser.KW_PREPARE); } + break; } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public vac_analyze_option_name(): Vac_analyze_option_nameContext { - let localContext = new Vac_analyze_option_nameContext(this.context, this.state); - this.enterRule(localContext, 898, PostgreSqlParser.RULE_vac_analyze_option_name); - try { - this.state = 8284; + this.state = 5891; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_AND: @@ -37575,29 +33181,9 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_DEFAULT: case PostgreSqlParser.KW_DO: case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_AUTHORIZATION: - case PostgreSqlParser.KW_BINARY: - case PostgreSqlParser.KW_COLLATION: - case PostgreSqlParser.KW_CONCURRENTLY: - case PostgreSqlParser.KW_CROSS: - case PostgreSqlParser.KW_CURRENT_SCHEMA: - case PostgreSqlParser.KW_FREEZE: - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_ILIKE: - case PostgreSqlParser.KW_INNER: case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_ISNULL: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_LIKE: - case PostgreSqlParser.KW_NATURAL: - case PostgreSqlParser.KW_NOTNULL: case PostgreSqlParser.KW_OUTER: case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_OVERLAPS: - case PostgreSqlParser.KW_RIGHT: - case PostgreSqlParser.KW_SIMILAR: - case PostgreSqlParser.KW_VERBOSE: case PostgreSqlParser.KW_ABORT: case PostgreSqlParser.KW_ABSOLUTE: case PostgreSqlParser.KW_ACCESS: @@ -37931,7 +33517,6 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_CUBE: case PostgreSqlParser.KW_GROUPING: case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_TABLESAMPLE: case PostgreSqlParser.KW_ORDINALITY: case PostgreSqlParser.KW_XMLTABLE: case PostgreSqlParser.KW_COLUMNS: @@ -37988,23 +33573,21 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.PLSQLVARIABLENAME: case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); { - this.state = 8282; - this.nonreservedword(); + this.state = 5889; + this.colid(); } break; - case PostgreSqlParser.KW_ANALYSE: - case PostgreSqlParser.KW_ANALYZE: - this.enterOuterAlt(localContext, 2); + case PostgreSqlParser.KW_ALL: { - this.state = 8283; - this.analyze_keyword(); + this.state = 5890; + this.match(PostgreSqlParser.KW_ALL); } break; default: throw new antlr.NoViableAltException(this); } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -38020,454 +33603,134 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public vac_analyze_option_arg(): Vac_analyze_option_argContext { - let localContext = new Vac_analyze_option_argContext(this.context, this.state); - this.enterRule(localContext, 900, PostgreSqlParser.RULE_vac_analyze_option_arg); + public insertstmt(): InsertstmtContext { + let localContext = new InsertstmtContext(this.context, this.state); + this.enterRule(localContext, 538, PostgreSqlParser.RULE_insertstmt); + let _la: number; try { - this.state = 8288; + localContext = new InsertStatementContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 5894; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FALSE: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_ON: - case PostgreSqlParser.KW_TRUE: - case PostgreSqlParser.KW_AUTHORIZATION: - case PostgreSqlParser.KW_BINARY: - case PostgreSqlParser.KW_COLLATION: - case PostgreSqlParser.KW_CONCURRENTLY: - case PostgreSqlParser.KW_CROSS: - case PostgreSqlParser.KW_CURRENT_SCHEMA: - case PostgreSqlParser.KW_FREEZE: - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_ILIKE: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_ISNULL: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_LIKE: - case PostgreSqlParser.KW_NATURAL: - case PostgreSqlParser.KW_NOTNULL: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_OVERLAPS: - case PostgreSqlParser.KW_RIGHT: - case PostgreSqlParser.KW_SIMILAR: - case PostgreSqlParser.KW_VERBOSE: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_TABLESAMPLE: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); + _la = this.tokenStream.LA(1); + if (_la === 105) { { - this.state = 8286; - this.opt_boolean_or_string(); + this.state = 5893; + this.with_clause(); } - break; - case PostgreSqlParser.PLUS: - case PostgreSqlParser.MINUS: - case PostgreSqlParser.Integral: - case PostgreSqlParser.Numeric: - this.enterOuterAlt(localContext, 2); + } + + this.state = 5896; + this.match(PostgreSqlParser.KW_INSERT); + this.state = 5897; + this.match(PostgreSqlParser.KW_INTO); + this.state = 5898; + this.table_name(); + this.state = 5901; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 36) { { - this.state = 8287; - this.numericonly(); + this.state = 5899; + this.match(PostgreSqlParser.KW_AS); + this.state = 5900; + this.colid(); } - break; - default: - throw new antlr.NoViableAltException(this); + } + + this.state = 5903; + this.insert_rest(); + this.state = 5925; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 80) { + { + this.state = 5904; + this.match(PostgreSqlParser.KW_ON); + this.state = 5905; + this.match(PostgreSqlParser.KW_CONFLICT); + this.state = 5913; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.OPEN_PAREN: + { + this.state = 5906; + this.index_params(); + this.state = 5908; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 103) { + { + this.state = 5907; + this.where_clause(); + } + } + + } + break; + case PostgreSqlParser.KW_ON: + { + this.state = 5910; + this.match(PostgreSqlParser.KW_ON); + this.state = 5911; + this.match(PostgreSqlParser.KW_CONSTRAINT); + this.state = 5912; + this.colid(); + } + break; + case PostgreSqlParser.KW_DO: + break; + default: + break; + } + this.state = 5915; + this.match(PostgreSqlParser.KW_DO); + this.state = 5923; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_UPDATE: + { + this.state = 5916; + this.match(PostgreSqlParser.KW_UPDATE); + this.state = 5917; + this.match(PostgreSqlParser.KW_SET); + this.state = 5918; + this.set_clause_list(); + this.state = 5920; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 103) { + { + this.state = 5919; + this.where_clause(); + } + } + + } + break; + case PostgreSqlParser.KW_NOTHING: + { + this.state = 5922; + this.match(PostgreSqlParser.KW_NOTHING); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + } + + this.state = 5928; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 87) { + { + this.state = 5927; + this.returning_clause(); + } + } + } } catch (re) { @@ -38484,14 +33747,64 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_analyze(): Opt_analyzeContext { - let localContext = new Opt_analyzeContext(this.context, this.state); - this.enterRule(localContext, 902, PostgreSqlParser.RULE_opt_analyze); + public insert_rest(): Insert_restContext { + let localContext = new Insert_restContext(this.context, this.state); + this.enterRule(localContext, 540, PostgreSqlParser.RULE_insert_rest); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8290; - this.analyze_keyword(); + this.state = 5934; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 758, this.context) ) { + case 1: + { + this.state = 5930; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 5931; + this.insert_column_list(); + this.state = 5932; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + } + this.state = 5939; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 463) { + { + this.state = 5936; + this.match(PostgreSqlParser.KW_OVERRIDING); + this.state = 5937; + _la = this.tokenStream.LA(1); + if(!(_la === 99 || _la === 349)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5938; + this.match(PostgreSqlParser.KW_VALUE); + } + } + + this.state = 5943; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 760, this.context) ) { + case 1: + { + this.state = 5941; + this.default_values_or_values(); + } + break; + case 2: + { + this.state = 5942; + this.selectstmt(); + } + break; + } } } catch (re) { @@ -38508,28 +33821,28 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public analyze_options_list(): Analyze_options_listContext { - let localContext = new Analyze_options_listContext(this.context, this.state); - this.enterRule(localContext, 904, PostgreSqlParser.RULE_analyze_options_list); + public insert_column_list(): Insert_column_listContext { + let localContext = new Insert_column_listContext(this.context, this.state); + this.enterRule(localContext, 542, PostgreSqlParser.RULE_insert_column_list); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8292; - this.analyze_option_elem(); - this.state = 8297; + this.state = 5945; + this.insert_column_item(); + this.state = 5950; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); while (_la === 6) { { { - this.state = 8293; + this.state = 5946; this.match(PostgreSqlParser.COMMA); - this.state = 8294; - this.analyze_option_elem(); + this.state = 5947; + this.insert_column_item(); } } - this.state = 8299; + this.state = 5952; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } @@ -38549,36 +33862,16 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public analyze_option_elem(): Analyze_option_elemContext { - let localContext = new Analyze_option_elemContext(this.context, this.state); - this.enterRule(localContext, 906, PostgreSqlParser.RULE_analyze_option_elem); + public insert_column_item(): Insert_column_itemContext { + let localContext = new Insert_column_itemContext(this.context, this.state); + this.enterRule(localContext, 544, PostgreSqlParser.RULE_insert_column_item); try { - this.state = 8303; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_VERBOSE: - this.enterOuterAlt(localContext, 1); - { - this.state = 8300; - this.opt_verbose(); - } - break; - case PostgreSqlParser.KW_SKIP_LOCKED: - this.enterOuterAlt(localContext, 2); - { - this.state = 8301; - this.opt_skiplock(); - } - break; - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - this.enterOuterAlt(localContext, 3); - { - this.state = 8302; - this.opt_buffer_usage_limit(); - } - break; - default: - throw new antlr.NoViableAltException(this); + this.enterOuterAlt(localContext, 1); + { + this.state = 5953; + this.column_name(); + this.state = 5954; + this.opt_indirection(); } } catch (re) { @@ -38595,32 +33888,16 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_verbose(): Opt_verboseContext { - let localContext = new Opt_verboseContext(this.context, this.state); - this.enterRule(localContext, 908, PostgreSqlParser.RULE_opt_verbose); - let _la: number; + public returning_clause(): Returning_clauseContext { + let localContext = new Returning_clauseContext(this.context, this.state); + this.enterRule(localContext, 546, PostgreSqlParser.RULE_returning_clause); try { this.enterOuterAlt(localContext, 1); { - this.state = 8305; - this.match(PostgreSqlParser.KW_VERBOSE); - this.state = 8307; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 60 || _la === 96) { - { - this.state = 8306; - _la = this.tokenStream.LA(1); - if(!(_la === 60 || _la === 96)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - + this.state = 5956; + this.match(PostgreSqlParser.KW_RETURNING); + this.state = 5957; + this.target_list(); } } catch (re) { @@ -38637,29 +33914,58 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_skiplock(): Opt_skiplockContext { - let localContext = new Opt_skiplockContext(this.context, this.state); - this.enterRule(localContext, 910, PostgreSqlParser.RULE_opt_skiplock); + public deletestmt(): DeletestmtContext { + let localContext = new DeletestmtContext(this.context, this.state); + this.enterRule(localContext, 548, PostgreSqlParser.RULE_deletestmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8309; - this.match(PostgreSqlParser.KW_SKIP_LOCKED); - this.state = 8311; + this.state = 5960; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 60 || _la === 96) { + if (_la === 105) { { - this.state = 8310; - _la = this.tokenStream.LA(1); - if(!(_la === 60 || _la === 96)) { - this.errorHandler.recoverInline(this); + this.state = 5959; + this.with_clause(); } - else { - this.errorHandler.reportMatch(this); - this.consume(); + } + + this.state = 5962; + this.match(PostgreSqlParser.KW_DELETE); + this.state = 5963; + this.match(PostgreSqlParser.KW_FROM); + this.state = 5964; + this.relation_expr_opt_alias(); + this.state = 5967; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 100) { + { + this.state = 5965; + this.match(PostgreSqlParser.KW_USING); + this.state = 5966; + this.from_list(); + } + } + + this.state = 5970; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 103) { + { + this.state = 5969; + this.where_or_current_clause(); } + } + + this.state = 5973; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 87) { + { + this.state = 5972; + this.returning_clause(); } } @@ -38679,37 +33985,113 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_buffer_usage_limit(): Opt_buffer_usage_limitContext { - let localContext = new Opt_buffer_usage_limitContext(this.context, this.state); - this.enterRule(localContext, 912, PostgreSqlParser.RULE_opt_buffer_usage_limit); + public lockstmt(): LockstmtContext { + let localContext = new LockstmtContext(this.context, this.state); + this.enterRule(localContext, 550, PostgreSqlParser.RULE_lockstmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8313; - this.match(PostgreSqlParser.KW_BUFFER_USAGE_LIMIT); - this.state = 8316; + this.state = 5975; + this.match(PostgreSqlParser.KW_LOCK); + this.state = 5977; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.PLUS: - case PostgreSqlParser.MINUS: - case PostgreSqlParser.Integral: - case PostgreSqlParser.Numeric: + _la = this.tokenStream.LA(1); + if (_la === 92) { { - this.state = 8314; - this.numericonly(); + this.state = 5976; + this.match(PostgreSqlParser.KW_TABLE); } - break; - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.EscapeStringConstant: + } + + this.state = 5979; + this.relation_expr_list(); + this.state = 5994; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 68) { { - this.state = 8315; - this.sconst(); + this.state = 5980; + this.match(PostgreSqlParser.KW_IN); + this.state = 5991; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ROW: + { + this.state = 5981; + _la = this.tokenStream.LA(1); + if(!(_la === 131 || _la === 414)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 5982; + _la = this.tokenStream.LA(1); + if(!(_la === 201 || _la === 334)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case PostgreSqlParser.KW_SHARE: + { + this.state = 5983; + this.match(PostgreSqlParser.KW_SHARE); + this.state = 5988; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_UPDATE: + { + this.state = 5984; + this.match(PostgreSqlParser.KW_UPDATE); + this.state = 5985; + this.match(PostgreSqlParser.KW_EXCLUSIVE); + } + break; + case PostgreSqlParser.KW_ROW: + { + this.state = 5986; + this.match(PostgreSqlParser.KW_ROW); + this.state = 5987; + this.match(PostgreSqlParser.KW_EXCLUSIVE); + } + break; + case PostgreSqlParser.KW_MODE: + break; + default: + break; + } + } + break; + case PostgreSqlParser.KW_EXCLUSIVE: + { + this.state = 5990; + this.match(PostgreSqlParser.KW_EXCLUSIVE); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 5993; + this.match(PostgreSqlParser.KW_MODE); + } + } + + this.state = 5997; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 770, this.context) ) { + case 1: + { + this.state = 5996; + this.match(PostgreSqlParser.KW_NOWAIT); } break; - default: - throw new antlr.NoViableAltException(this); } } } @@ -38727,38 +34109,61 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_full(): Opt_fullContext { - let localContext = new Opt_fullContext(this.context, this.state); - this.enterRule(localContext, 914, PostgreSqlParser.RULE_opt_full); + public updatestmt(): UpdatestmtContext { + let localContext = new UpdatestmtContext(this.context, this.state); + this.enterRule(localContext, 552, PostgreSqlParser.RULE_updatestmt); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8318; - this.match(PostgreSqlParser.KW_FULL); + this.state = 6000; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 105) { + { + this.state = 5999; + this.with_clause(); + } } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + + this.state = 6002; + this.match(PostgreSqlParser.KW_UPDATE); + this.state = 6003; + this.relation_expr_opt_alias(); + this.state = 6004; + this.match(PostgreSqlParser.KW_SET); + this.state = 6005; + this.set_clause_list(); + this.state = 6007; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 64) { + { + this.state = 6006; + this.from_clause(); + } } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_freeze(): Opt_freezeContext { - let localContext = new Opt_freezeContext(this.context, this.state); - this.enterRule(localContext, 916, PostgreSqlParser.RULE_opt_freeze); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8320; - this.match(PostgreSqlParser.KW_FREEZE); + + this.state = 6010; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 103) { + { + this.state = 6009; + this.where_or_current_clause(); + } + } + + this.state = 6013; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 87) { + { + this.state = 6012; + this.returning_clause(); + } + } + } } catch (re) { @@ -38775,18 +34180,31 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_name_list(): Opt_name_listContext { - let localContext = new Opt_name_listContext(this.context, this.state); - this.enterRule(localContext, 918, PostgreSqlParser.RULE_opt_name_list); + public set_clause_list(): Set_clause_listContext { + let localContext = new Set_clause_listContext(this.context, this.state); + this.enterRule(localContext, 554, PostgreSqlParser.RULE_set_clause_list); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8322; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8323; - this.column_list(); - this.state = 8324; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6015; + this.set_clause(); + this.state = 6020; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 6016; + this.match(PostgreSqlParser.COMMA); + this.state = 6017; + this.set_clause(); + } + } + this.state = 6022; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } } } catch (re) { @@ -38803,24 +34221,67 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public vacuum_relation(): Vacuum_relationContext { - let localContext = new Vacuum_relationContext(this.context, this.state); - this.enterRule(localContext, 920, PostgreSqlParser.RULE_vacuum_relation); + public set_clause(): Set_clauseContext { + let localContext = new Set_clauseContext(this.context, this.state); + this.enterRule(localContext, 556, PostgreSqlParser.RULE_set_clause); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8326; - this.table_name(); - this.state = 8328; + this.state = 6041; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 777, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 778, this.context) ) { case 1: + this.enterOuterAlt(localContext, 1); { - this.state = 8327; - this.opt_name_list(); + this.state = 6023; + this.insert_column_item(); + this.state = 6024; + this.match(PostgreSqlParser.EQUAL); + this.state = 6025; + this.expression(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 6027; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6028; + this.insert_column_list(); + this.state = 6029; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6030; + this.match(PostgreSqlParser.EQUAL); + this.state = 6039; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 777, this.context) ) { + case 1: + { + this.state = 6032; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 776, this.context) ) { + case 1: + { + this.state = 6031; + this.match(PostgreSqlParser.KW_ROW); + } + break; + } + this.state = 6034; + this.expression(); + } + break; + case 2: + { + this.state = 6035; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6036; + this.select_clause(); + this.state = 6037; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + } } break; - } } } catch (re) { @@ -38837,32 +34298,131 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public vacuum_relation_list(): Vacuum_relation_listContext { - let localContext = new Vacuum_relation_listContext(this.context, this.state); - this.enterRule(localContext, 922, PostgreSqlParser.RULE_vacuum_relation_list); + public declarecursorstmt(): DeclarecursorstmtContext { + let localContext = new DeclarecursorstmtContext(this.context, this.state); + this.enterRule(localContext, 558, PostgreSqlParser.RULE_declarecursorstmt); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8330; - this.vacuum_relation(); - this.state = 8335; + this.state = 6043; + this.match(PostgreSqlParser.KW_DECLARE); + this.state = 6044; + this.colid(); + { + this.state = 6053; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - while (_la === 6) { - { + while (_la === 107 || _la === 240 || _la === 269 || _la === 324) { { - this.state = 8331; - this.match(PostgreSqlParser.COMMA); - this.state = 8332; - this.vacuum_relation(); + this.state = 6051; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_SCROLL: + { + { + this.state = 6046; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269) { + { + this.state = 6045; + this.match(PostgreSqlParser.KW_NO); + } + } + + this.state = 6048; + this.match(PostgreSqlParser.KW_SCROLL); + } + } + break; + case PostgreSqlParser.KW_BINARY: + { + this.state = 6049; + this.match(PostgreSqlParser.KW_BINARY); + } + break; + case PostgreSqlParser.KW_INSENSITIVE: + { + this.state = 6050; + this.match(PostgreSqlParser.KW_INSENSITIVE); + } + break; + default: + throw new antlr.NoViableAltException(this); } } - this.state = 8337; + this.state = 6055; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); } } + this.state = 6056; + this.match(PostgreSqlParser.KW_CURSOR); + this.state = 6059; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 105 || _la === 379) { + { + this.state = 6057; + _la = this.tokenStream.LA(1); + if(!(_la === 105 || _la === 379)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6058; + this.match(PostgreSqlParser.KW_HOLD); + } + } + + this.state = 6061; + this.match(PostgreSqlParser.KW_FOR); + this.state = 6062; + this.selectstmt(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public selectstmt(): SelectstmtContext { + let localContext = new SelectstmtContext(this.context, this.state); + this.enterRule(localContext, 560, PostgreSqlParser.RULE_selectstmt); + try { + this.state = 6066; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 783, this.context) ) { + case 1: + localContext = new SelectStatementContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 6064; + this.select_no_parens(); + } + break; + case 2: + localContext = new SelectStatementContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 6065; + this.select_with_parens(); + } + break; + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -38878,14 +34438,32 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_vacuum_relation_list(): Opt_vacuum_relation_listContext { - let localContext = new Opt_vacuum_relation_listContext(this.context, this.state); - this.enterRule(localContext, 924, PostgreSqlParser.RULE_opt_vacuum_relation_list); + public select_with_parens(): Select_with_parensContext { + let localContext = new Select_with_parensContext(this.context, this.state); + this.enterRule(localContext, 562, PostgreSqlParser.RULE_select_with_parens); try { this.enterOuterAlt(localContext, 1); { - this.state = 8338; - this.vacuum_relation_list(); + this.state = 6068; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6071; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 784, this.context) ) { + case 1: + { + this.state = 6069; + this.select_no_parens(); + } + break; + case 2: + { + this.state = 6070; + this.select_with_parens(); + } + break; + } + this.state = 6073; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -38902,71 +34480,72 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public explainstmt(): ExplainstmtContext { - let localContext = new ExplainstmtContext(this.context, this.state); - this.enterRule(localContext, 926, PostgreSqlParser.RULE_explainstmt); + public select_no_parens(): Select_no_parensContext { + let localContext = new Select_no_parensContext(this.context, this.state); + this.enterRule(localContext, 564, PostgreSqlParser.RULE_select_no_parens); let _la: number; try { - this.state = 8358; + this.enterOuterAlt(localContext, 1); + { + this.state = 6076; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 105) { + { + this.state = 6075; + this.with_clause(); + } + } + + this.state = 6078; + this.select_clause(); + this.state = 6080; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 83) { + { + this.state = 6079; + this.sort_clause(); + } + } + + this.state = 6090; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 780, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 789, this.context) ) { case 1: - this.enterOuterAlt(localContext, 1); { - this.state = 8340; - this.match(PostgreSqlParser.KW_EXPLAIN); - this.state = 8341; - this.explainablestmt(); + this.state = 6082; + this.for_locking_clause(); + this.state = 6084; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 787, this.context) ) { + case 1: + { + this.state = 6083; + this.select_limit(); + } + break; + } } break; case 2: - this.enterOuterAlt(localContext, 2); { - this.state = 8342; - this.match(PostgreSqlParser.KW_EXPLAIN); - this.state = 8343; - this.analyze_keyword(); - this.state = 8345; + this.state = 6086; + this.select_limit(); + this.state = 6088; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 128) { + if (_la === 62) { { - this.state = 8344; - this.opt_verbose(); + this.state = 6087; + this.for_locking_clause(); } } - this.state = 8347; - this.explainablestmt(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 8349; - this.match(PostgreSqlParser.KW_EXPLAIN); - this.state = 8350; - this.match(PostgreSqlParser.KW_VERBOSE); - this.state = 8351; - this.explainablestmt(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 8352; - this.match(PostgreSqlParser.KW_EXPLAIN); - this.state = 8353; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8354; - this.explain_option_list(); - this.state = 8355; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 8356; - this.explainablestmt(); } break; } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -38982,76 +34561,176 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public explainablestmt(): ExplainablestmtContext { - let localContext = new ExplainablestmtContext(this.context, this.state); - this.enterRule(localContext, 928, PostgreSqlParser.RULE_explainablestmt); + public select_clause(): Select_clauseContext { + let localContext = new Select_clauseContext(this.context, this.state); + this.enterRule(localContext, 566, PostgreSqlParser.RULE_select_clause); try { - this.state = 8369; + this.state = 6094; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 781, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 790, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 8360; - this.selectstmt(); + this.state = 6092; + this.simple_select(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 8361; - this.insertstmt(); + this.state = 6093; + this.select_with_parens(); } break; - case 3: - this.enterOuterAlt(localContext, 3); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public simple_select(): Simple_selectContext { + let localContext = new Simple_selectContext(this.context, this.state); + this.enterRule(localContext, 568, PostgreSqlParser.RULE_simple_select); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 6118; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_SELECT: { - this.state = 8362; - this.updatestmt(); + this.state = 6096; + this.match(PostgreSqlParser.KW_SELECT); + this.state = 6106; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 794, this.context) ) { + case 1: + { + this.state = 6098; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 791, this.context) ) { + case 1: + { + this.state = 6097; + this.match(PostgreSqlParser.KW_ALL); + } + break; + } + this.state = 6101; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 792, this.context) ) { + case 1: + { + this.state = 6100; + this.into_clause(); + } + break; + } + } + break; + case 2: + { + this.state = 6104; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 793, this.context) ) { + case 1: + { + this.state = 6103; + this.distinct_clause(); + } + break; + } + } + break; } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 8363; - this.deletestmt(); + this.state = 6108; + this.sql_expression(); } break; - case 5: - this.enterOuterAlt(localContext, 5); + case PostgreSqlParser.KW_VALUES: { - this.state = 8364; - this.declarecursorstmt(); + this.state = 6109; + this.values_clause(); } break; - case 6: - this.enterOuterAlt(localContext, 6); + case PostgreSqlParser.KW_TABLE: { - this.state = 8365; - this.createasstmt(); + this.state = 6110; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 6111; + this.relation_expr(); } break; - case 7: - this.enterOuterAlt(localContext, 7); + case PostgreSqlParser.OPEN_PAREN: { - this.state = 8366; - this.creatematviewstmt(); + this.state = 6112; + this.select_with_parens(); + this.state = 6113; + this.set_operator_with_all_or_distinct(); + this.state = 6116; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 795, this.context) ) { + case 1: + { + this.state = 6114; + this.simple_select(); + } + break; + case 2: + { + this.state = 6115; + this.select_with_parens(); + } + break; } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 8367; - this.refreshmatviewstmt(); } break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 8368; - this.executestmt(); + default: + throw new antlr.NoViableAltException(this); + } + this.state = 6127; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 798, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 6120; + this.set_operator_with_all_or_distinct(); + this.state = 6123; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 797, this.context) ) { + case 1: + { + this.state = 6121; + this.simple_select(); + } + break; + case 2: + { + this.state = 6122; + this.select_with_parens(); + } + break; + } + } + } } - break; + this.state = 6129; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 798, this.context); + } } } catch (re) { @@ -39068,30 +34747,95 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public explain_option_list(): Explain_option_listContext { - let localContext = new Explain_option_listContext(this.context, this.state); - this.enterRule(localContext, 930, PostgreSqlParser.RULE_explain_option_list); + public set_operator_with_all_or_distinct(): Set_operator_with_all_or_distinctContext { + let localContext = new Set_operator_with_all_or_distinctContext(this.context, this.state); + this.enterRule(localContext, 570, PostgreSqlParser.RULE_set_operator_with_all_or_distinct); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8371; - this.explain_option_elem(); - this.state = 8376; + this.state = 6130; + _la = this.tokenStream.LA(1); + if(!(_la === 59 || _la === 70 || _la === 97)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6132; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - while (_la === 6) { + if (_la === 30 || _la === 56) { { + this.state = 6131; + _la = this.tokenStream.LA(1); + if(!(_la === 30 || _la === 56)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public with_clause(): With_clauseContext { + let localContext = new With_clauseContext(this.context, this.state); + this.enterRule(localContext, 572, PostgreSqlParser.RULE_with_clause); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 6134; + this.match(PostgreSqlParser.KW_WITH); + this.state = 6136; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 800, this.context) ) { + case 1: { - this.state = 8372; - this.match(PostgreSqlParser.COMMA); - this.state = 8373; - this.explain_option_elem(); + this.state = 6135; + this.match(PostgreSqlParser.KW_RECURSIVE); } + break; + } + { + this.state = 6138; + this.common_table_expr(); + this.state = 6143; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 801, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 6139; + this.match(PostgreSqlParser.COMMA); + this.state = 6140; + this.common_table_expr(); + } + } } - this.state = 8378; + this.state = 6145; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 801, this.context); + } } } } @@ -39109,25 +34853,73 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public explain_option_elem(): Explain_option_elemContext { - let localContext = new Explain_option_elemContext(this.context, this.state); - this.enterRule(localContext, 932, PostgreSqlParser.RULE_explain_option_elem); + public common_table_expr(): Common_table_exprContext { + let localContext = new Common_table_exprContext(this.context, this.state); + this.enterRule(localContext, 574, PostgreSqlParser.RULE_common_table_expr); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8379; - this.explain_option_name(); - this.state = 8381; + this.state = 6146; + this.colid(); + this.state = 6148; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 6147; + this.opt_column_list(); + } + } + + this.state = 6150; + this.match(PostgreSqlParser.KW_AS); + this.state = 6155; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 12 || _la === 13 || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 420484101) !== 0) || ((((_la - 80)) & ~0x1F) === 0 && ((1 << (_la - 80)) & 4227923969) !== 0) || ((((_la - 112)) & ~0x1F) === 0 && ((1 << (_la - 112)) & 4294967295) !== 0) || ((((_la - 144)) & ~0x1F) === 0 && ((1 << (_la - 144)) & 4294967295) !== 0) || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & 4294967295) !== 0) || ((((_la - 208)) & ~0x1F) === 0 && ((1 << (_la - 208)) & 3223322623) !== 0) || ((((_la - 240)) & ~0x1F) === 0 && ((1 << (_la - 240)) & 4294967295) !== 0) || ((((_la - 272)) & ~0x1F) === 0 && ((1 << (_la - 272)) & 4294967295) !== 0) || ((((_la - 304)) & ~0x1F) === 0 && ((1 << (_la - 304)) & 4294967295) !== 0) || ((((_la - 336)) & ~0x1F) === 0 && ((1 << (_la - 336)) & 4294967295) !== 0) || ((((_la - 368)) & ~0x1F) === 0 && ((1 << (_la - 368)) & 4294967295) !== 0) || ((((_la - 400)) & ~0x1F) === 0 && ((1 << (_la - 400)) & 4294967295) !== 0) || ((((_la - 432)) & ~0x1F) === 0 && ((1 << (_la - 432)) & 4290772991) !== 0) || ((((_la - 464)) & ~0x1F) === 0 && ((1 << (_la - 464)) & 4294967295) !== 0) || ((((_la - 496)) & ~0x1F) === 0 && ((1 << (_la - 496)) & 25165183) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 486582415) !== 0) || _la === 584) { + if (_la === 77 || _la === 259) { { - this.state = 8380; - this.explain_option_arg(); + this.state = 6152; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { + { + this.state = 6151; + this.match(PostgreSqlParser.KW_NOT); + } + } + + this.state = 6154; + this.match(PostgreSqlParser.KW_MATERIALIZED); } } + this.state = 6157; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6158; + this.preparablestmt(); + this.state = 6159; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6161; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 805, this.context) ) { + case 1: + { + this.state = 6160; + this.search_cluase(); + } + break; + } + this.state = 6164; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 806, this.context) ) { + case 1: + { + this.state = 6163; + this.cycle_cluase(); + } + break; + } } } catch (re) { @@ -39144,52 +34936,545 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public explain_option_name(): Explain_option_nameContext { - let localContext = new Explain_option_nameContext(this.context, this.state); - this.enterRule(localContext, 934, PostgreSqlParser.RULE_explain_option_name); + public search_cluase(): Search_cluaseContext { + let localContext = new Search_cluaseContext(this.context, this.state); + this.enterRule(localContext, 576, PostgreSqlParser.RULE_search_cluase); + let _la: number; try { - this.state = 8385; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_AUTHORIZATION: - case PostgreSqlParser.KW_BINARY: - case PostgreSqlParser.KW_COLLATION: - case PostgreSqlParser.KW_CONCURRENTLY: - case PostgreSqlParser.KW_CROSS: - case PostgreSqlParser.KW_CURRENT_SCHEMA: - case PostgreSqlParser.KW_FREEZE: - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_ILIKE: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_ISNULL: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_LIKE: - case PostgreSqlParser.KW_NATURAL: - case PostgreSqlParser.KW_NOTNULL: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_OVERLAPS: - case PostgreSqlParser.KW_RIGHT: - case PostgreSqlParser.KW_SIMILAR: - case PostgreSqlParser.KW_VERBOSE: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: + this.enterOuterAlt(localContext, 1); + { + this.state = 6166; + this.match(PostgreSqlParser.KW_SEARCH); + this.state = 6167; + _la = this.tokenStream.LA(1); + if(!(_la === 527 || _la === 528)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6168; + this.match(PostgreSqlParser.KW_FIRST); + this.state = 6169; + this.match(PostgreSqlParser.KW_BY); + this.state = 6170; + this.column_list(); + this.state = 6171; + this.match(PostgreSqlParser.KW_SET); + this.state = 6172; + this.column_name(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public cycle_cluase(): Cycle_cluaseContext { + let localContext = new Cycle_cluaseContext(this.context, this.state); + this.enterRule(localContext, 578, PostgreSqlParser.RULE_cycle_cluase); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 6174; + this.match(PostgreSqlParser.KW_CYCLE); + this.state = 6175; + this.column_list(); + this.state = 6176; + this.match(PostgreSqlParser.KW_SET); + this.state = 6177; + this.column_name(); + this.state = 6183; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 94) { + { + this.state = 6178; + this.match(PostgreSqlParser.KW_TO); + this.state = 6179; + this.colid(); + this.state = 6180; + this.match(PostgreSqlParser.KW_DEFAULT); + this.state = 6181; + this.colid(); + } + } + + this.state = 6185; + this.match(PostgreSqlParser.KW_USING); + this.state = 6186; + this.column_name(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public into_clause(): Into_clauseContext { + let localContext = new Into_clauseContext(this.context, this.state); + this.enterRule(localContext, 580, PostgreSqlParser.RULE_into_clause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 6188; + this.match(PostgreSqlParser.KW_INTO); + this.state = 6194; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 809, this.context) ) { + case 1: + { + this.state = 6190; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 808, this.context) ) { + case 1: + { + this.state = 6189; + this.match(PostgreSqlParser.KW_STRICT); + } + break; + } + this.state = 6192; + this.opttempTableName(); + } + break; + case 2: + { + this.state = 6193; + this.expr_list(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public opttempTableName(): OpttempTableNameContext { + let localContext = new OpttempTableNameContext(this.context, this.state); + this.enterRule(localContext, 582, PostgreSqlParser.RULE_opttempTableName); + let _la: number; + try { + this.state = 6211; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 814, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 6197; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 213 || _la === 254) { + { + this.state = 6196; + _la = this.tokenStream.LA(1); + if(!(_la === 213 || _la === 254)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 6199; + _la = this.tokenStream.LA(1); + if(!(_la === 352 || _la === 354)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6201; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 92) { + { + this.state = 6200; + this.match(PostgreSqlParser.KW_TABLE); + } + } + + this.state = 6203; + this.table_name_create(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 6205; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 812, this.context) ) { + case 1: + { + this.state = 6204; + this.match(PostgreSqlParser.KW_UNLOGGED); + } + break; + } + this.state = 6208; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 92) { + { + this.state = 6207; + this.match(PostgreSqlParser.KW_TABLE); + } + } + + this.state = 6210; + this.table_name_create(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public distinct_clause(): Distinct_clauseContext { + let localContext = new Distinct_clauseContext(this.context, this.state); + this.enterRule(localContext, 584, PostgreSqlParser.RULE_distinct_clause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 6213; + this.match(PostgreSqlParser.KW_DISTINCT); + this.state = 6216; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 815, this.context) ) { + case 1: + { + this.state = 6214; + this.match(PostgreSqlParser.KW_ON); + this.state = 6215; + this.execute_param_clause(); + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public sort_clause(): Sort_clauseContext { + let localContext = new Sort_clauseContext(this.context, this.state); + this.enterRule(localContext, 586, PostgreSqlParser.RULE_sort_clause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 6218; + this.match(PostgreSqlParser.KW_ORDER); + this.state = 6219; + this.match(PostgreSqlParser.KW_BY); + this.state = 6220; + this.sortby(); + this.state = 6225; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 6221; + this.match(PostgreSqlParser.COMMA); + this.state = 6222; + this.sortby(); + } + } + this.state = 6227; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public sortby(): SortbyContext { + let localContext = new SortbyContext(this.context, this.state); + this.enterRule(localContext, 588, PostgreSqlParser.RULE_sortby); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 6228; + this.column_expr_noparen(); + this.state = 6232; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 817, this.context) ) { + case 1: + { + this.state = 6229; + this.match(PostgreSqlParser.KW_USING); + this.state = 6230; + this.qual_all_op(); + } + break; + case 2: + { + this.state = 6231; + _la = this.tokenStream.LA(1); + if(!(_la === 37 || _la === 55)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + this.state = 6236; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 818, this.context) ) { + case 1: + { + this.state = 6234; + this.match(PostgreSqlParser.KW_NULLS); + this.state = 6235; + _la = this.tokenStream.LA(1); + if(!(_la === 207 || _la === 249)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public select_limit(): Select_limitContext { + let localContext = new Select_limitContext(this.context, this.state); + this.enterRule(localContext, 590, PostgreSqlParser.RULE_select_limit); + let _la: number; + try { + this.state = 6249; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_OFFSET: + this.enterOuterAlt(localContext, 1); + { + this.state = 6238; + this.offset_clause(); + this.state = 6240; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 819, this.context) ) { + case 1: + { + this.state = 6239; + this.fetch_clause(); + } + break; + } + } + break; + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_LIMIT: + this.enterOuterAlt(localContext, 2); + { + this.state = 6244; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_LIMIT: + { + this.state = 6242; + this.limit_clause(); + } + break; + case PostgreSqlParser.KW_FETCH: + { + this.state = 6243; + this.fetch_clause(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 6247; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 79) { + { + this.state = 6246; + this.offset_clause(); + } + } + + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public limit_clause(): Limit_clauseContext { + let localContext = new Limit_clauseContext(this.context, this.state); + this.enterRule(localContext, 592, PostgreSqlParser.RULE_limit_clause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 6251; + this.match(PostgreSqlParser.KW_LIMIT); + this.state = 6254; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.OPEN_PAREN: + case PostgreSqlParser.PLUS: + case PostgreSqlParser.MINUS: + case PostgreSqlParser.PARAM: + case PostgreSqlParser.Operator: + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_CASE: + case PostgreSqlParser.KW_CAST: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_CURRENT_CATALOG: + case PostgreSqlParser.KW_CURRENT_DATE: + case PostgreSqlParser.KW_CURRENT_ROLE: + case PostgreSqlParser.KW_CURRENT_TIME: + case PostgreSqlParser.KW_CURRENT_TIMESTAMP: + case PostgreSqlParser.KW_CURRENT_USER: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FALSE: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_LOCALTIME: + case PostgreSqlParser.KW_LOCALTIMESTAMP: + case PostgreSqlParser.KW_NOT: + case PostgreSqlParser.KW_NULL: + case PostgreSqlParser.KW_SESSION_USER: + case PostgreSqlParser.KW_TRUE: + case PostgreSqlParser.KW_UNIQUE: + case PostgreSqlParser.KW_USER: + case PostgreSqlParser.KW_AUTHORIZATION: + case PostgreSqlParser.KW_BINARY: + case PostgreSqlParser.KW_COLLATION: + case PostgreSqlParser.KW_CONCURRENTLY: + case PostgreSqlParser.KW_CROSS: + case PostgreSqlParser.KW_CURRENT_SCHEMA: + case PostgreSqlParser.KW_FREEZE: + case PostgreSqlParser.KW_FULL: + case PostgreSqlParser.KW_ILIKE: + case PostgreSqlParser.KW_INNER: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_ISNULL: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_LIKE: + case PostgreSqlParser.KW_NATURAL: + case PostgreSqlParser.KW_NOTNULL: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_OVERLAPS: + case PostgreSqlParser.KW_RIGHT: + case PostgreSqlParser.KW_SIMILAR: + case PostgreSqlParser.KW_VERBOSE: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: case PostgreSqlParser.KW_ALTER: case PostgreSqlParser.KW_ALWAYS: case PostgreSqlParser.KW_ASSERTION: @@ -39568,26 +35853,40 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.StringConstant: case PostgreSqlParser.UnicodeEscapeStringConstant: case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.BinaryStringConstant: + case PostgreSqlParser.HexadecimalStringConstant: + case PostgreSqlParser.Integral: + case PostgreSqlParser.Numeric: case PostgreSqlParser.PLSQLVARIABLENAME: case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); { - this.state = 8383; - this.nonreservedword(); + this.state = 6252; + this.expression(); } break; - case PostgreSqlParser.KW_ANALYSE: - case PostgreSqlParser.KW_ANALYZE: - this.enterOuterAlt(localContext, 2); + case PostgreSqlParser.KW_ALL: { - this.state = 8384; - this.analyze_keyword(); + this.state = 6253; + this.match(PostgreSqlParser.KW_ALL); } break; default: throw new antlr.NoViableAltException(this); } + this.state = 6258; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 6) { + { + this.state = 6256; + this.match(PostgreSqlParser.COMMA); + this.state = 6257; + this.expression(); + } + } + + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -39603,455 +35902,66 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public explain_option_arg(): Explain_option_argContext { - let localContext = new Explain_option_argContext(this.context, this.state); - this.enterRule(localContext, 936, PostgreSqlParser.RULE_explain_option_arg); + public fetch_clause(): Fetch_clauseContext { + let localContext = new Fetch_clauseContext(this.context, this.state); + this.enterRule(localContext, 594, PostgreSqlParser.RULE_fetch_clause); + let _la: number; try { - this.state = 8389; + this.enterOuterAlt(localContext, 1); + { + this.state = 6260; + this.match(PostgreSqlParser.KW_FETCH); + this.state = 6261; + _la = this.tokenStream.LA(1); + if(!(_la === 207 || _la === 268)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + { + this.state = 6263; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FALSE: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_ON: - case PostgreSqlParser.KW_TRUE: - case PostgreSqlParser.KW_AUTHORIZATION: - case PostgreSqlParser.KW_BINARY: - case PostgreSqlParser.KW_COLLATION: - case PostgreSqlParser.KW_CONCURRENTLY: - case PostgreSqlParser.KW_CROSS: - case PostgreSqlParser.KW_CURRENT_SCHEMA: - case PostgreSqlParser.KW_FREEZE: - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_ILIKE: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_ISNULL: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_LIKE: - case PostgreSqlParser.KW_NATURAL: - case PostgreSqlParser.KW_NOTNULL: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_OVERLAPS: - case PostgreSqlParser.KW_RIGHT: - case PostgreSqlParser.KW_SIMILAR: - case PostgreSqlParser.KW_VERBOSE: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_TABLESAMPLE: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); + switch (this.interpreter.adaptivePredict(this.tokenStream, 825, this.context) ) { + case 1: { - this.state = 8387; - this.opt_boolean_or_string(); + this.state = 6262; + this.select_fetch_first_value(); } break; - case PostgreSqlParser.PLUS: - case PostgreSqlParser.MINUS: - case PostgreSqlParser.Integral: - case PostgreSqlParser.Numeric: - this.enterOuterAlt(localContext, 2); + } + this.state = 6265; + _la = this.tokenStream.LA(1); + if(!(_la === 320 || _la === 414)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6269; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_ONLY: { - this.state = 8388; - this.numericonly(); + this.state = 6266; + this.match(PostgreSqlParser.KW_ONLY); + } + break; + case PostgreSqlParser.KW_WITH: + { + this.state = 6267; + this.match(PostgreSqlParser.KW_WITH); + this.state = 6268; + this.match(PostgreSqlParser.KW_TIES); } break; default: throw new antlr.NoViableAltException(this); } + } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -40067,31 +35977,40 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public preparestmt(): PreparestmtContext { - let localContext = new PreparestmtContext(this.context, this.state); - this.enterRule(localContext, 938, PostgreSqlParser.RULE_preparestmt); + public offset_clause(): Offset_clauseContext { + let localContext = new Offset_clauseContext(this.context, this.state); + this.enterRule(localContext, 596, PostgreSqlParser.RULE_offset_clause); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8391; - this.match(PostgreSqlParser.KW_PREPARE); - this.state = 8392; - this.name(); - this.state = 8394; + this.state = 6271; + this.match(PostgreSqlParser.KW_OFFSET); + this.state = 6276; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 827, this.context) ) { + case 1: { - this.state = 8393; - this.prep_type_clause(); + this.state = 6272; + this.select_fetch_first_value(); + this.state = 6273; + _la = this.tokenStream.LA(1); + if(!(_la === 320 || _la === 414)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case 2: + { + this.state = 6275; + this.expression(); } + break; } - - this.state = 8396; - this.match(PostgreSqlParser.KW_AS); - this.state = 8397; - this.preparablestmt(); } } catch (re) { @@ -40108,18 +36027,44 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public prep_type_clause(): Prep_type_clauseContext { - let localContext = new Prep_type_clauseContext(this.context, this.state); - this.enterRule(localContext, 940, PostgreSqlParser.RULE_prep_type_clause); + public select_fetch_first_value(): Select_fetch_first_valueContext { + let localContext = new Select_fetch_first_valueContext(this.context, this.state); + this.enterRule(localContext, 598, PostgreSqlParser.RULE_select_fetch_first_value); + let _la: number; try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8399; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8400; - this.type_list(); - this.state = 8401; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6281; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 828, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 6278; + _la = this.tokenStream.LA(1); + if(!(_la === 12 || _la === 13)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6279; + _la = this.tokenStream.LA(1); + if(!(_la === 571 || _la === 573)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 6280; + this.primaryExpression(0); + } + break; } } catch (re) { @@ -40136,39 +36081,178 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public preparablestmt(): PreparablestmtContext { - let localContext = new PreparablestmtContext(this.context, this.state); - this.enterRule(localContext, 942, PostgreSqlParser.RULE_preparablestmt); + public group_clause(): Group_clauseContext { + let localContext = new Group_clauseContext(this.context, this.state); + this.enterRule(localContext, 600, PostgreSqlParser.RULE_group_clause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 6283; + this.match(PostgreSqlParser.KW_GROUP); + this.state = 6284; + this.match(PostgreSqlParser.KW_BY); + this.state = 6286; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 829, this.context) ) { + case 1: + { + this.state = 6285; + _la = this.tokenStream.LA(1); + if(!(_la === 30 || _la === 56)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + this.state = 6288; + this.group_by_list(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public group_by_list(): Group_by_listContext { + let localContext = new Group_by_listContext(this.context, this.state); + this.enterRule(localContext, 602, PostgreSqlParser.RULE_group_by_list); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 6290; + this.group_by_item(); + this.state = 6295; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 830, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 6291; + this.match(PostgreSqlParser.COMMA); + this.state = 6292; + this.group_by_item(); + } + } + } + this.state = 6297; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 830, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public group_by_item(): Group_by_itemContext { + let localContext = new Group_by_itemContext(this.context, this.state); + this.enterRule(localContext, 604, PostgreSqlParser.RULE_group_by_item); + let _la: number; try { - this.state = 8407; + this.state = 6321; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 787, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 833, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 8403; - this.selectstmt(); + this.state = 6298; + this.column_expr_noparen(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 8404; - this.insertstmt(); + this.state = 6299; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6300; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 8405; - this.updatestmt(); + this.state = 6302; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 468 || _la === 469) { + { + this.state = 6301; + _la = this.tokenStream.LA(1); + if(!(_la === 468 || _la === 469)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + this.state = 6304; + this.match(PostgreSqlParser.OPEN_PAREN); + { + this.state = 6305; + this.column_expr_noparen(); + this.state = 6310; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 6306; + this.match(PostgreSqlParser.COMMA); + this.state = 6307; + this.column_expr_noparen(); + } + } + this.state = 6312; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + this.state = 6313; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 8406; - this.deletestmt(); + this.state = 6315; + this.match(PostgreSqlParser.KW_GROUPING); + this.state = 6316; + this.match(PostgreSqlParser.KW_SETS); + this.state = 6317; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6318; + this.group_by_list(); + this.state = 6319; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; } @@ -40187,92 +36271,159 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public executestmt(): ExecutestmtContext { - let localContext = new ExecutestmtContext(this.context, this.state); - this.enterRule(localContext, 944, PostgreSqlParser.RULE_executestmt); + public for_locking_clause(): For_locking_clauseContext { + let localContext = new For_locking_clauseContext(this.context, this.state); + this.enterRule(localContext, 606, PostgreSqlParser.RULE_for_locking_clause); let _la: number; try { - this.state = 8432; + this.state = 6351; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_EXECUTE: + switch (this.interpreter.adaptivePredict(this.tokenStream, 840, this.context) ) { + case 1: this.enterOuterAlt(localContext, 1); { - this.state = 8409; - this.match(PostgreSqlParser.KW_EXECUTE); - this.state = 8410; - this.name(); - this.state = 8412; + this.state = 6344; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 788, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + do { { - this.state = 8411; - this.execute_param_clause(); + { + this.state = 6323; + this.match(PostgreSqlParser.KW_FOR); + this.state = 6333; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_UPDATE: + { + this.state = 6326; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269) { + { + this.state = 6324; + this.match(PostgreSqlParser.KW_NO); + this.state = 6325; + this.match(PostgreSqlParser.KW_KEY); + } + } + + this.state = 6328; + this.match(PostgreSqlParser.KW_UPDATE); + } + break; + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_SHARE: + { + this.state = 6330; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 245) { + { + this.state = 6329; + this.match(PostgreSqlParser.KW_KEY); + } + } + + this.state = 6332; + this.match(PostgreSqlParser.KW_SHARE); + } + break; + default: + throw new antlr.NoViableAltException(this); } - break; - } + this.state = 6337; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 837, this.context) ) { + case 1: + { + this.state = 6335; + this.match(PostgreSqlParser.KW_OF); + this.state = 6336; + this.qualified_name_list(); + } + break; + } + this.state = 6342; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 838, this.context) ) { + case 1: + { + this.state = 6339; + this.match(PostgreSqlParser.KW_NOWAIT); + } + break; + case 2: + { + this.state = 6340; + this.match(PostgreSqlParser.KW_SKIP); + this.state = 6341; + this.match(PostgreSqlParser.KW_LOCKED); + } + break; + } + } + } + this.state = 6346; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 62); } break; - case PostgreSqlParser.KW_CREATE: + case 2: this.enterOuterAlt(localContext, 2); { - this.state = 8414; - this.match(PostgreSqlParser.KW_CREATE); - this.state = 8416; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 213 || _la === 254 || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & 32773) !== 0)) { - { - this.state = 8415; - this.opttemp(); - } + this.state = 6348; + this.match(PostgreSqlParser.KW_FOR); + this.state = 6349; + this.match(PostgreSqlParser.KW_READ); + this.state = 6350; + this.match(PostgreSqlParser.KW_ONLY); } - - this.state = 8418; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 8420; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 790, this.context) ) { - case 1: - { - this.state = 8419; - this.opt_if_not_exists(); - } - break; + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public values_clause(): Values_clauseContext { + let localContext = new Values_clauseContext(this.context, this.state); + this.enterRule(localContext, 608, PostgreSqlParser.RULE_values_clause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 6353; + this.match(PostgreSqlParser.KW_VALUES); + this.state = 6354; + this.execute_param_clause(); + this.state = 6359; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 6355; + this.match(PostgreSqlParser.COMMA); + this.state = 6356; + this.execute_param_clause(); } - this.state = 8422; - this.create_as_target(); - this.state = 8423; - this.match(PostgreSqlParser.KW_AS); - this.state = 8424; - this.match(PostgreSqlParser.KW_EXECUTE); - this.state = 8425; - this.name(); - this.state = 8427; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 791, this.context) ) { - case 1: - { - this.state = 8426; - this.execute_param_clause(); - } - break; } - this.state = 8430; + this.state = 6361; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 792, this.context) ) { - case 1: - { - this.state = 8429; - this.opt_with_data(); - } - break; - } - } - break; - default: - throw new antlr.NoViableAltException(this); + _la = this.tokenStream.LA(1); + } } } catch (re) { @@ -40289,18 +36440,16 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public execute_param_clause(): Execute_param_clauseContext { - let localContext = new Execute_param_clauseContext(this.context, this.state); - this.enterRule(localContext, 946, PostgreSqlParser.RULE_execute_param_clause); + public from_clause(): From_clauseContext { + let localContext = new From_clauseContext(this.context, this.state); + this.enterRule(localContext, 610, PostgreSqlParser.RULE_from_clause); try { this.enterOuterAlt(localContext, 1); { - this.state = 8434; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8435; - this.expr_list(); - this.state = 8436; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6362; + this.match(PostgreSqlParser.KW_FROM); + this.state = 6363; + this.from_list(); } } catch (re) { @@ -40317,439 +36466,362 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public deallocatestmt(): DeallocatestmtContext { - let localContext = new DeallocatestmtContext(this.context, this.state); - this.enterRule(localContext, 948, PostgreSqlParser.RULE_deallocatestmt); + public from_list(): From_listContext { + let localContext = new From_listContext(this.context, this.state); + this.enterRule(localContext, 612, PostgreSqlParser.RULE_from_list); try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 8438; - this.match(PostgreSqlParser.KW_DEALLOCATE); - this.state = 8440; + this.state = 6365; + this.table_ref(); + this.state = 6370; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 842, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 6366; + this.match(PostgreSqlParser.COMMA); + this.state = 6367; + this.table_ref(); + } + } + } + this.state = 6372; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 842, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public table_ref(): Table_refContext { + let localContext = new Table_refContext(this.context, this.state); + this.enterRule(localContext, 614, PostgreSqlParser.RULE_table_ref); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 6436; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 794, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 859, this.context) ) { case 1: { - this.state = 8439; - this.match(PostgreSqlParser.KW_PREPARE); + this.state = 6387; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 847, this.context) ) { + case 1: + { + this.state = 6373; + this.relation_expr(); + } + break; + case 2: + { + { + this.state = 6375; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 81) { + { + this.state = 6374; + this.match(PostgreSqlParser.KW_ONLY); + } + } + + this.state = 6377; + this.view_name(); + this.state = 6379; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 844, this.context) ) { + case 1: + { + this.state = 6378; + this.match(PostgreSqlParser.STAR); + } + break; + } + this.state = 6382; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 845, this.context) ) { + case 1: + { + this.state = 6381; + this.column_list(); + } + break; + } + this.state = 6385; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 846, this.context) ) { + case 1: + { + this.state = 6384; + this.where_clause(); + } + break; + } + } + } + break; + } + this.state = 6390; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 848, this.context) ) { + case 1: + { + this.state = 6389; + this.alias_clause(); + } + break; + } + this.state = 6393; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 472) { + { + this.state = 6392; + this.tablesample_clause(); + } + } + + } + break; + case 2: + { + this.state = 6396; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 72) { + { + this.state = 6395; + this.match(PostgreSqlParser.KW_LATERAL); + } + } + + this.state = 6410; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 854, this.context) ) { + case 1: + { + this.state = 6398; + this.xmltable(); + this.state = 6400; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 851, this.context) ) { + case 1: + { + this.state = 6399; + this.alias_clause(); + } + break; + } + } + break; + case 2: + { + this.state = 6402; + this.func_table(); + this.state = 6404; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 852, this.context) ) { + case 1: + { + this.state = 6403; + this.func_alias_clause(); + } + break; + } + } + break; + case 3: + { + this.state = 6406; + this.select_with_parens(); + this.state = 6408; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 853, this.context) ) { + case 1: + { + this.state = 6407; + this.alias_clause(); + } + break; + } + } + break; + } + } + break; + case 3: + { + this.state = 6412; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6413; + this.table_ref(); + this.state = 6430; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_CROSS: + { + this.state = 6414; + this.match(PostgreSqlParser.KW_CROSS); + this.state = 6415; + this.match(PostgreSqlParser.KW_JOIN); + this.state = 6416; + this.table_ref(); + } + break; + case PostgreSqlParser.KW_NATURAL: + { + this.state = 6417; + this.match(PostgreSqlParser.KW_NATURAL); + this.state = 6419; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & 8261) !== 0)) { + { + this.state = 6418; + this.join_type(); + } + } + + this.state = 6421; + this.match(PostgreSqlParser.KW_JOIN); + this.state = 6422; + this.table_ref(); + } + break; + case PostgreSqlParser.KW_FULL: + case PostgreSqlParser.KW_INNER: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_RIGHT: + { + this.state = 6424; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & 8261) !== 0)) { + { + this.state = 6423; + this.join_type(); + } + } + + this.state = 6426; + this.match(PostgreSqlParser.KW_JOIN); + this.state = 6427; + this.table_ref(); + this.state = 6428; + this.join_qual(); + } + break; + case PostgreSqlParser.CLOSE_PAREN: + break; + default: + break; + } + this.state = 6432; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6434; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 858, this.context) ) { + case 1: + { + this.state = 6433; + this.alias_clause(); + } + break; + } } break; } - this.state = 8444; + this.state = 6456; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - { - this.state = 8442; - this.name(); - } - break; - case PostgreSqlParser.KW_ALL: - { - this.state = 8443; - this.match(PostgreSqlParser.KW_ALL); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 863, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + this.state = 6454; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_CROSS: + { + this.state = 6438; + this.match(PostgreSqlParser.KW_CROSS); + this.state = 6439; + this.match(PostgreSqlParser.KW_JOIN); + this.state = 6440; + this.table_ref(); + } + break; + case PostgreSqlParser.KW_NATURAL: + { + this.state = 6441; + this.match(PostgreSqlParser.KW_NATURAL); + this.state = 6443; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & 8261) !== 0)) { + { + this.state = 6442; + this.join_type(); + } + } + + this.state = 6445; + this.match(PostgreSqlParser.KW_JOIN); + this.state = 6446; + this.table_ref(); + } + break; + case PostgreSqlParser.KW_FULL: + case PostgreSqlParser.KW_INNER: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_RIGHT: + { + this.state = 6448; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & 8261) !== 0)) { + { + this.state = 6447; + this.join_type(); + } + } + + this.state = 6450; + this.match(PostgreSqlParser.KW_JOIN); + this.state = 6451; + this.table_ref(); + this.state = 6452; + this.join_qual(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } } - break; - default: - throw new antlr.NoViableAltException(this); + this.state = 6458; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 863, this.context); } } } @@ -40767,52 +36839,39 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public insertstmt(): InsertstmtContext { - let localContext = new InsertstmtContext(this.context, this.state); - this.enterRule(localContext, 950, PostgreSqlParser.RULE_insertstmt); + public alias_clause(): Alias_clauseContext { + let localContext = new Alias_clauseContext(this.context, this.state); + this.enterRule(localContext, 616, PostgreSqlParser.RULE_alias_clause); let _la: number; try { - localContext = new InsertStatementContext(localContext); this.enterOuterAlt(localContext, 1); { - this.state = 8447; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 105) { - { - this.state = 8446; - this.opt_with_clause(); - } - } - - this.state = 8449; - this.match(PostgreSqlParser.KW_INSERT); - this.state = 8450; - this.match(PostgreSqlParser.KW_INTO); - this.state = 8451; - this.insert_target(); - this.state = 8452; - this.insert_rest(); - this.state = 8454; + this.state = 6460; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 80) { + if (_la === 36) { { - this.state = 8453; - this.opt_on_conflict(); + this.state = 6459; + this.match(PostgreSqlParser.KW_AS); } } - this.state = 8457; + this.state = 6462; + this.colid(); + this.state = 6467; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 87) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 865, this.context) ) { + case 1: { - this.state = 8456; - this.returning_clause(); + this.state = 6463; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6464; + this.name_list(); + this.state = 6465; + this.match(PostgreSqlParser.CLOSE_PAREN); } + break; } - } } catch (re) { @@ -40829,95 +36888,459 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public insert_target(): Insert_targetContext { - let localContext = new Insert_targetContext(this.context, this.state); - this.enterRule(localContext, 952, PostgreSqlParser.RULE_insert_target); + public func_alias_clause(): Func_alias_clauseContext { + let localContext = new Func_alias_clauseContext(this.context, this.state); + this.enterRule(localContext, 618, PostgreSqlParser.RULE_func_alias_clause); let _la: number; try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8459; - this.table_name(); - this.state = 8462; + this.state = 6481; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 36) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 868, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); { - this.state = 8460; - this.match(PostgreSqlParser.KW_AS); - this.state = 8461; - this.colid(); + this.state = 6469; + this.alias_clause(); } - } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 6475; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AS: + { + this.state = 6470; + this.match(PostgreSqlParser.KW_AS); + this.state = 6472; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { + { + this.state = 6471; + this.colid(); + } + } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public insert_rest(): Insert_restContext { - let localContext = new Insert_restContext(this.context, this.state); - this.enterRule(localContext, 954, PostgreSqlParser.RULE_insert_rest); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8468; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 800, this.context) ) { - case 1: - { - this.state = 8464; + } + break; + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 6474; + this.colid(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 6477; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8465; - this.insert_column_list(); - this.state = 8466; + this.state = 6478; + this.tablefuncelementlist(); + this.state = 6479; this.match(PostgreSqlParser.CLOSE_PAREN); } break; } - this.state = 8474; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 463) { - { - this.state = 8470; - this.match(PostgreSqlParser.KW_OVERRIDING); - this.state = 8471; - this.override_kind(); - this.state = 8472; - this.match(PostgreSqlParser.KW_VALUE); - } - } - - this.state = 8478; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 802, this.context) ) { - case 1: - { - this.state = 8476; - this.default_values_or_values(); - } - break; - case 2: - { - this.state = 8477; - this.selectstmt(); - } - break; - } - } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -40933,22 +37356,32 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public override_kind(): Override_kindContext { - let localContext = new Override_kindContext(this.context, this.state); - this.enterRule(localContext, 956, PostgreSqlParser.RULE_override_kind); + public join_type(): Join_typeContext { + let localContext = new Join_typeContext(this.context, this.state); + this.enterRule(localContext, 620, PostgreSqlParser.RULE_join_type); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8480; + this.state = 6483; _la = this.tokenStream.LA(1); - if(!(_la === 99 || _la === 349)) { + if(!(((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & 8261) !== 0))) { this.errorHandler.recoverInline(this); } else { this.errorHandler.reportMatch(this); this.consume(); } + this.state = 6485; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 123) { + { + this.state = 6484; + this.match(PostgreSqlParser.KW_OUTER); + } + } + } } catch (re) { @@ -40965,31 +37398,33 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public insert_column_list(): Insert_column_listContext { - let localContext = new Insert_column_listContext(this.context, this.state); - this.enterRule(localContext, 958, PostgreSqlParser.RULE_insert_column_list); - let _la: number; + public join_qual(): Join_qualContext { + let localContext = new Join_qualContext(this.context, this.state); + this.enterRule(localContext, 622, PostgreSqlParser.RULE_join_qual); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8482; - this.insert_column_item(); - this.state = 8487; + this.state = 6491; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_USING: + this.enterOuterAlt(localContext, 1); { - this.state = 8483; - this.match(PostgreSqlParser.COMMA); - this.state = 8484; - this.insert_column_item(); + this.state = 6487; + this.match(PostgreSqlParser.KW_USING); + this.state = 6488; + this.opt_column_list(); } + break; + case PostgreSqlParser.KW_ON: + this.enterOuterAlt(localContext, 2); + { + this.state = 6489; + this.match(PostgreSqlParser.KW_ON); + this.state = 6490; + this.expression(); } - this.state = 8489; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } + break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -41006,171 +37441,872 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public insert_column_item(): Insert_column_itemContext { - let localContext = new Insert_column_itemContext(this.context, this.state); - this.enterRule(localContext, 960, PostgreSqlParser.RULE_insert_column_item); + public relation_expr(): Relation_exprContext { + let localContext = new Relation_exprContext(this.context, this.state); + this.enterRule(localContext, 624, PostgreSqlParser.RULE_relation_expr); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8490; - this.column_name(); - this.state = 8491; - this.opt_indirection(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_on_conflict(): Opt_on_conflictContext { - let localContext = new Opt_on_conflictContext(this.context, this.state); - this.enterRule(localContext, 962, PostgreSqlParser.RULE_opt_on_conflict); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8493; - this.match(PostgreSqlParser.KW_ON); - this.state = 8494; - this.match(PostgreSqlParser.KW_CONFLICT); - this.state = 8496; + this.state = 6508; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2 || _la === 80) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 873, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); { - this.state = 8495; - this.opt_conf_expr(); + this.state = 6493; + this.truncate_table(); } - } - - this.state = 8498; - this.match(PostgreSqlParser.KW_DO); - this.state = 8506; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_UPDATE: + break; + case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 8499; - this.match(PostgreSqlParser.KW_UPDATE); - this.state = 8500; - this.match(PostgreSqlParser.KW_SET); - this.state = 8501; - this.set_clause_list(); - this.state = 8503; + this.state = 6494; + this.match(PostgreSqlParser.KW_ONLY); + this.state = 6500; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 103) { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: { - this.state = 8502; - this.where_clause(); + this.state = 6495; + this.table_name(); } - } - - } - break; - case PostgreSqlParser.KW_NOTHING: - { - this.state = 8505; - this.match(PostgreSqlParser.KW_NOTHING); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_conf_expr(): Opt_conf_exprContext { - let localContext = new Opt_conf_exprContext(this.context, this.state); - this.enterRule(localContext, 964, PostgreSqlParser.RULE_opt_conf_expr); - let _la: number; - try { - this.state = 8517; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.OPEN_PAREN: - this.enterOuterAlt(localContext, 1); - { - this.state = 8508; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8509; - this.index_params(); - this.state = 8510; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 8512; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 103) { + break; + case PostgreSqlParser.OPEN_PAREN: { - this.state = 8511; - this.where_clause(); + this.state = 6496; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6497; + this.table_name(); + this.state = 6498; + this.match(PostgreSqlParser.CLOSE_PAREN); } + break; + default: + throw new antlr.NoViableAltException(this); } - } break; - case PostgreSqlParser.KW_ON: - this.enterOuterAlt(localContext, 2); + case 3: + this.enterOuterAlt(localContext, 3); { - this.state = 8514; - this.match(PostgreSqlParser.KW_ON); - this.state = 8515; - this.match(PostgreSqlParser.KW_CONSTRAINT); - this.state = 8516; - this.name(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public returning_clause(): Returning_clauseContext { - let localContext = new Returning_clauseContext(this.context, this.state); - this.enterRule(localContext, 966, PostgreSqlParser.RULE_returning_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8519; - this.match(PostgreSqlParser.KW_RETURNING); - this.state = 8520; - this.target_list(); + this.state = 6502; + this.match(PostgreSqlParser.KW_IN); + this.state = 6503; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 6506; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 6504; + this.schema_name(); + } + break; + case PostgreSqlParser.KW_CURRENT_SCHEMA: + { + this.state = 6505; + this.match(PostgreSqlParser.KW_CURRENT_SCHEMA); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; } } catch (re) { @@ -41187,982 +38323,899 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public deletestmt(): DeletestmtContext { - let localContext = new DeletestmtContext(this.context, this.state); - this.enterRule(localContext, 968, PostgreSqlParser.RULE_deletestmt); + public publication_relation_expr(): Publication_relation_exprContext { + let localContext = new Publication_relation_exprContext(this.context, this.state); + this.enterRule(localContext, 626, PostgreSqlParser.RULE_publication_relation_expr); let _la: number; try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8523; + this.state = 6534; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 105) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 878, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); { - this.state = 8522; - this.opt_with_clause(); + this.state = 6510; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 6511; + this.truncate_table(); + this.state = 6513; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 874, this.context) ) { + case 1: + { + this.state = 6512; + this.opt_column_list(); + } + break; } - } - - this.state = 8525; - this.match(PostgreSqlParser.KW_DELETE); - this.state = 8526; - this.match(PostgreSqlParser.KW_FROM); - this.state = 8527; - this.relation_expr_opt_alias(); - this.state = 8529; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 100) { - { - this.state = 8528; - this.using_clause(); + this.state = 6516; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 103) { + { + this.state = 6515; + this.where_clause(); + } } - } - this.state = 8532; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 103) { - { - this.state = 8531; - this.where_or_current_clause(); } - } - - this.state = 8535; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 87) { + break; + case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 8534; - this.returning_clause(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public using_clause(): Using_clauseContext { - let localContext = new Using_clauseContext(this.context, this.state); - this.enterRule(localContext, 970, PostgreSqlParser.RULE_using_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8537; - this.match(PostgreSqlParser.KW_USING); - this.state = 8538; - this.from_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public lockstmt(): LockstmtContext { - let localContext = new LockstmtContext(this.context, this.state); - this.enterRule(localContext, 972, PostgreSqlParser.RULE_lockstmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8540; - this.match(PostgreSqlParser.KW_LOCK); - this.state = 8542; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 92) { - { - this.state = 8541; - this.opt_table(); - } - } - - this.state = 8544; - this.relation_expr_list(); - this.state = 8546; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 68) { - { - this.state = 8545; - this.opt_lock(); - } - } - - this.state = 8549; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 815, this.context) ) { - case 1: - { - this.state = 8548; - this.opt_nowait(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_lock(): Opt_lockContext { - let localContext = new Opt_lockContext(this.context, this.state); - this.enterRule(localContext, 974, PostgreSqlParser.RULE_opt_lock); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8551; - this.match(PostgreSqlParser.KW_IN); - this.state = 8552; - this.lock_type(); - this.state = 8553; - this.match(PostgreSqlParser.KW_MODE); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public lock_type(): Lock_typeContext { - let localContext = new Lock_typeContext(this.context, this.state); - this.enterRule(localContext, 976, PostgreSqlParser.RULE_lock_type); - let _la: number; - try { - this.state = 8567; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_ACCESS: - this.enterOuterAlt(localContext, 1); - { - this.state = 8555; - this.match(PostgreSqlParser.KW_ACCESS); - this.state = 8556; - _la = this.tokenStream.LA(1); - if(!(_la === 201 || _la === 334)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - break; - case PostgreSqlParser.KW_ROW: - this.enterOuterAlt(localContext, 2); - { - this.state = 8557; - this.match(PostgreSqlParser.KW_ROW); - this.state = 8558; - _la = this.tokenStream.LA(1); - if(!(_la === 201 || _la === 334)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - break; - case PostgreSqlParser.KW_SHARE: - this.enterOuterAlt(localContext, 3); - { - this.state = 8559; - this.match(PostgreSqlParser.KW_SHARE); - this.state = 8564; + this.state = 6518; + this.match(PostgreSqlParser.KW_TABLE); + this.state = 6519; + this.match(PostgreSqlParser.KW_ONLY); + this.state = 6525; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: case PostgreSqlParser.KW_UPDATE: - { - this.state = 8560; - this.match(PostgreSqlParser.KW_UPDATE); - this.state = 8561; - this.match(PostgreSqlParser.KW_EXCLUSIVE); - } - break; + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: { - this.state = 8562; - this.match(PostgreSqlParser.KW_ROW); - this.state = 8563; - this.match(PostgreSqlParser.KW_EXCLUSIVE); - } - break; - case PostgreSqlParser.KW_MODE: - break; - default: - break; - } - } - break; - case PostgreSqlParser.KW_EXCLUSIVE: - this.enterOuterAlt(localContext, 4); - { - this.state = 8566; - this.match(PostgreSqlParser.KW_EXCLUSIVE); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_nowait(): Opt_nowaitContext { - let localContext = new Opt_nowaitContext(this.context, this.state); - this.enterRule(localContext, 978, PostgreSqlParser.RULE_opt_nowait); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8569; - this.match(PostgreSqlParser.KW_NOWAIT); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_nowait_or_skip(): Opt_nowait_or_skipContext { - let localContext = new Opt_nowait_or_skipContext(this.context, this.state); - this.enterRule(localContext, 980, PostgreSqlParser.RULE_opt_nowait_or_skip); - try { - this.state = 8574; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_NOWAIT: - this.enterOuterAlt(localContext, 1); - { - this.state = 8571; - this.match(PostgreSqlParser.KW_NOWAIT); - } - break; - case PostgreSqlParser.KW_SKIP: - this.enterOuterAlt(localContext, 2); - { - this.state = 8572; - this.match(PostgreSqlParser.KW_SKIP); - this.state = 8573; - this.match(PostgreSqlParser.KW_LOCKED); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public updatestmt(): UpdatestmtContext { - let localContext = new UpdatestmtContext(this.context, this.state); - this.enterRule(localContext, 982, PostgreSqlParser.RULE_updatestmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8577; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 105) { - { - this.state = 8576; - this.opt_with_clause(); - } - } - - this.state = 8579; - this.match(PostgreSqlParser.KW_UPDATE); - this.state = 8580; - this.relation_expr_opt_alias(); - this.state = 8581; - this.match(PostgreSqlParser.KW_SET); - this.state = 8582; - this.set_clause_list(); - this.state = 8584; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 64) { - { - this.state = 8583; - this.from_clause(); - } - } - - this.state = 8587; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 103) { - { - this.state = 8586; - this.where_or_current_clause(); - } - } - - this.state = 8590; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 87) { - { - this.state = 8589; - this.returning_clause(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public set_clause_list(): Set_clause_listContext { - let localContext = new Set_clause_listContext(this.context, this.state); - this.enterRule(localContext, 984, PostgreSqlParser.RULE_set_clause_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8592; - this.set_clause(); - this.state = 8597; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 8593; - this.match(PostgreSqlParser.COMMA); - this.state = 8594; - this.set_clause(); - } - } - this.state = 8599; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public set_clause(): Set_clauseContext { - let localContext = new Set_clauseContext(this.context, this.state); - this.enterRule(localContext, 986, PostgreSqlParser.RULE_set_clause); - try { - this.state = 8618; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 826, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 8600; - this.set_target(); - this.state = 8601; - this.match(PostgreSqlParser.EQUAL); - this.state = 8602; - this.a_expr(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 8604; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8605; - this.set_target_list(); - this.state = 8606; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 8607; - this.match(PostgreSqlParser.EQUAL); - this.state = 8616; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 825, this.context) ) { - case 1: - { - this.state = 8609; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 824, this.context) ) { - case 1: - { - this.state = 8608; - this.match(PostgreSqlParser.KW_ROW); - } - break; - } - this.state = 8611; - this.a_expr(); + this.state = 6520; + this.table_name(); } break; - case 2: + case PostgreSqlParser.OPEN_PAREN: { - this.state = 8612; + this.state = 6521; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8613; - this.select_clause(); - this.state = 8614; + this.state = 6522; + this.table_name(); + this.state = 6523; this.match(PostgreSqlParser.CLOSE_PAREN); } break; - } - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public set_target(): Set_targetContext { - let localContext = new Set_targetContext(this.context, this.state); - this.enterRule(localContext, 988, PostgreSqlParser.RULE_set_target); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8620; - this.column_name(); - this.state = 8621; - this.opt_indirection(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public set_target_list(): Set_target_listContext { - let localContext = new Set_target_listContext(this.context, this.state); - this.enterRule(localContext, 990, PostgreSqlParser.RULE_set_target_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8623; - this.set_target(); - this.state = 8628; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 8624; - this.match(PostgreSqlParser.COMMA); - this.state = 8625; - this.set_target(); - } - } - this.state = 8630; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public declarecursorstmt(): DeclarecursorstmtContext { - let localContext = new DeclarecursorstmtContext(this.context, this.state); - this.enterRule(localContext, 992, PostgreSqlParser.RULE_declarecursorstmt); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8631; - this.match(PostgreSqlParser.KW_DECLARE); - this.state = 8632; - this.cursor_name(); - this.state = 8633; - this.cursor_options(); - this.state = 8634; - this.match(PostgreSqlParser.KW_CURSOR); - this.state = 8635; - this.opt_hold(); - this.state = 8636; - this.match(PostgreSqlParser.KW_FOR); - this.state = 8637; - this.selectstmt(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public cursor_name(): Cursor_nameContext { - let localContext = new Cursor_nameContext(this.context, this.state); - this.enterRule(localContext, 994, PostgreSqlParser.RULE_cursor_name); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8639; - this.name(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public cursor_options(): Cursor_optionsContext { - let localContext = new Cursor_optionsContext(this.context, this.state); - this.enterRule(localContext, 996, PostgreSqlParser.RULE_cursor_options); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8648; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 107 || _la === 240 || _la === 269 || _la === 324) { - { - this.state = 8646; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_NO: - { - this.state = 8641; - this.match(PostgreSqlParser.KW_NO); - this.state = 8642; - this.match(PostgreSqlParser.KW_SCROLL); - } - break; - case PostgreSqlParser.KW_SCROLL: - { - this.state = 8643; - this.match(PostgreSqlParser.KW_SCROLL); - } - break; - case PostgreSqlParser.KW_BINARY: - { - this.state = 8644; - this.match(PostgreSqlParser.KW_BINARY); - } - break; - case PostgreSqlParser.KW_INSENSITIVE: - { - this.state = 8645; - this.match(PostgreSqlParser.KW_INSENSITIVE); - } - break; default: throw new antlr.NoViableAltException(this); } } - this.state = 8650; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_hold(): Opt_holdContext { - let localContext = new Opt_holdContext(this.context, this.state); - this.enterRule(localContext, 998, PostgreSqlParser.RULE_opt_hold); - try { - this.state = 8656; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_FOR: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_WITH: - this.enterOuterAlt(localContext, 2); - { - this.state = 8652; - this.match(PostgreSqlParser.KW_WITH); - this.state = 8653; - this.match(PostgreSqlParser.KW_HOLD); - } break; - case PostgreSqlParser.KW_WITHOUT: + case 3: this.enterOuterAlt(localContext, 3); { - this.state = 8654; - this.match(PostgreSqlParser.KW_WITHOUT); - this.state = 8655; - this.match(PostgreSqlParser.KW_HOLD); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public selectstmt(): SelectstmtContext { - let localContext = new SelectstmtContext(this.context, this.state); - this.enterRule(localContext, 1000, PostgreSqlParser.RULE_selectstmt); - try { - this.state = 8660; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 831, this.context) ) { - case 1: - localContext = new SelectStatementContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 8658; - this.select_no_parens(); - } - break; - case 2: - localContext = new SelectStatementContext(localContext); - this.enterOuterAlt(localContext, 2); - { - this.state = 8659; - this.select_with_parens(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public select_with_parens(): Select_with_parensContext { - let localContext = new Select_with_parensContext(this.context, this.state); - this.enterRule(localContext, 1002, PostgreSqlParser.RULE_select_with_parens); - try { - this.state = 8670; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 832, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 8662; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8663; - this.select_no_parens(); - this.state = 8664; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 8666; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8667; - this.select_with_parens(); - this.state = 8668; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public select_no_parens(): Select_no_parensContext { - let localContext = new Select_no_parensContext(this.context, this.state); - this.enterRule(localContext, 1004, PostgreSqlParser.RULE_select_no_parens); - let _la: number; - try { - this.state = 8701; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.OPEN_PAREN: - case PostgreSqlParser.KW_SELECT: - case PostgreSqlParser.KW_TABLE: - case PostgreSqlParser.KW_VALUES: - this.enterOuterAlt(localContext, 1); - { - this.state = 8672; - this.select_clause(); - this.state = 8674; + this.state = 6527; + this.match(PostgreSqlParser.KW_TABLES); + this.state = 6528; + this.match(PostgreSqlParser.KW_IN); + this.state = 6529; + this.match(PostgreSqlParser.KW_SCHEMA); + this.state = 6532; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 83) { - { - this.state = 8673; - this.opt_sort_clause(); - } - } - - this.state = 8684; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 836, this.context) ) { - case 1: - { - this.state = 8676; - this.for_locking_clause(); - this.state = 8678; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 834, this.context) ) { - case 1: - { - this.state = 8677; - this.opt_select_limit(); - } - break; - } - } - break; - case 2: - { - this.state = 8680; - this.select_limit(); - this.state = 8682; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 8681; - this.opt_for_locking_clause(); - } - } - - } - break; - } - } - break; - case PostgreSqlParser.KW_WITH: - this.enterOuterAlt(localContext, 2); - { - this.state = 8686; - this.with_clause(); - this.state = 8687; - this.select_clause(); - this.state = 8689; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 83) { - { - this.state = 8688; - this.opt_sort_clause(); - } - } - - this.state = 8699; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 840, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: { - this.state = 8691; - this.for_locking_clause(); - this.state = 8693; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 838, this.context) ) { - case 1: - { - this.state = 8692; - this.opt_select_limit(); - } - break; - } + this.state = 6530; + this.schema_name(); } break; - case 2: + case PostgreSqlParser.KW_CURRENT_SCHEMA: { - this.state = 8695; - this.select_limit(); - this.state = 8697; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 8696; - this.opt_for_locking_clause(); - } - } - + this.state = 6531; + this.match(PostgreSqlParser.KW_CURRENT_SCHEMA); } break; + default: + throw new antlr.NoViableAltException(this); } } break; - default: - throw new antlr.NoViableAltException(this); } } catch (re) { @@ -42179,27 +39232,31 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public select_clause(): Select_clauseContext { - let localContext = new Select_clauseContext(this.context, this.state); - this.enterRule(localContext, 1006, PostgreSqlParser.RULE_select_clause); + public relation_expr_list(): Relation_expr_listContext { + let localContext = new Relation_expr_listContext(this.context, this.state); + this.enterRule(localContext, 628, PostgreSqlParser.RULE_relation_expr_list); + let _la: number; try { - this.state = 8705; + this.enterOuterAlt(localContext, 1); + { + this.state = 6536; + this.relation_expr(); + this.state = 6541; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 842, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); + _la = this.tokenStream.LA(1); + while (_la === 6) { { - this.state = 8703; - this.simple_select(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); { - this.state = 8704; - this.select_with_parens(); + this.state = 6537; + this.match(PostgreSqlParser.COMMA); + this.state = 6538; + this.relation_expr(); } - break; + } + this.state = 6543; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } } } catch (re) { @@ -42216,267 +39273,35 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public simple_select(): Simple_selectContext { - let localContext = new Simple_selectContext(this.context, this.state); - this.enterRule(localContext, 1008, PostgreSqlParser.RULE_simple_select); + public relation_expr_opt_alias(): Relation_expr_opt_aliasContext { + let localContext = new Relation_expr_opt_aliasContext(this.context, this.state); + this.enterRule(localContext, 630, PostgreSqlParser.RULE_relation_expr_opt_alias); let _la: number; try { - let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 8752; + this.state = 6544; + this.relation_expr(); + this.state = 6549; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_SELECT: + switch (this.interpreter.adaptivePredict(this.tokenStream, 881, this.context) ) { + case 1: { - this.state = 8707; - this.match(PostgreSqlParser.KW_SELECT); - this.state = 8723; + this.state = 6546; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 848, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 36) { { - this.state = 8709; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 843, this.context) ) { - case 1: - { - this.state = 8708; - this.opt_all_clause(); - } - break; - } - this.state = 8712; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 844, this.context) ) { - case 1: - { - this.state = 8711; - this.into_clause(); - } - break; - } - this.state = 8715; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 845, this.context) ) { - case 1: - { - this.state = 8714; - this.opt_target_list(); - } - break; - } - } - break; - case 2: - { - this.state = 8718; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 846, this.context) ) { - case 1: - { - this.state = 8717; - this.distinct_clause(); - } - break; - } - this.state = 8721; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 847, this.context) ) { - case 1: - { - this.state = 8720; - this.target_list(); - } - break; - } - } - break; - } - this.state = 8726; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 849, this.context) ) { - case 1: - { - this.state = 8725; - this.into_clause(); - } - break; - } - this.state = 8729; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 64) { - { - this.state = 8728; - this.from_clause(); - } - } - - this.state = 8732; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 103) { - { - this.state = 8731; - this.where_clause(); - } - } - - this.state = 8735; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 66) { - { - this.state = 8734; - this.group_clause(); - } - } - - this.state = 8738; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 67) { - { - this.state = 8737; - this.having_clause(); + this.state = 6545; + this.match(PostgreSqlParser.KW_AS); } } - this.state = 8741; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 854, this.context) ) { - case 1: - { - this.state = 8740; - this.window_clause(); - } - break; - } - } - break; - case PostgreSqlParser.KW_VALUES: - { - this.state = 8743; - this.values_clause(); - } - break; - case PostgreSqlParser.KW_TABLE: - { - this.state = 8744; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 8745; - this.relation_expr(); - } - break; - case PostgreSqlParser.OPEN_PAREN: - { - this.state = 8746; - this.select_with_parens(); - this.state = 8747; - this.set_operator_with_all_or_distinct(); - this.state = 8750; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 855, this.context) ) { - case 1: - { - this.state = 8748; - this.simple_select(); - } - break; - case 2: - { - this.state = 8749; - this.select_with_parens(); - } - break; - } + this.state = 6548; + this.colid(); } break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 8761; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 858, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 8754; - this.set_operator_with_all_or_distinct(); - this.state = 8757; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 857, this.context) ) { - case 1: - { - this.state = 8755; - this.simple_select(); - } - break; - case 2: - { - this.state = 8756; - this.select_with_parens(); - } - break; - } - } - } - } - this.state = 8763; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 858, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; } - } - finally { - this.exitRule(); - } - return localContext; - } - public set_operator(): Set_operatorContext { - let localContext = new Set_operatorContext(this.context, this.state); - this.enterRule(localContext, 1010, PostgreSqlParser.RULE_set_operator); - try { - this.state = 8767; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_UNION: - localContext = new UnionContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 8764; - this.match(PostgreSqlParser.KW_UNION); - } - break; - case PostgreSqlParser.KW_INTERSECT: - localContext = new IntersectContext(localContext); - this.enterOuterAlt(localContext, 2); - { - this.state = 8765; - this.match(PostgreSqlParser.KW_INTERSECT); - } - break; - case PostgreSqlParser.KW_EXCEPT: - localContext = new ExceptContext(localContext); - this.enterOuterAlt(localContext, 3); - { - this.state = 8766; - this.match(PostgreSqlParser.KW_EXCEPT); - } - break; - default: - throw new antlr.NoViableAltException(this); } } catch (re) { @@ -42493,25 +39318,34 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public set_operator_with_all_or_distinct(): Set_operator_with_all_or_distinctContext { - let localContext = new Set_operator_with_all_or_distinctContext(this.context, this.state); - this.enterRule(localContext, 1012, PostgreSqlParser.RULE_set_operator_with_all_or_distinct); - let _la: number; + public tablesample_clause(): Tablesample_clauseContext { + let localContext = new Tablesample_clauseContext(this.context, this.state); + this.enterRule(localContext, 632, PostgreSqlParser.RULE_tablesample_clause); try { this.enterOuterAlt(localContext, 1); { - this.state = 8769; - this.set_operator(); - this.state = 8771; + this.state = 6551; + this.match(PostgreSqlParser.KW_TABLESAMPLE); + this.state = 6552; + this.function_name(); + this.state = 6553; + this.execute_param_clause(); + this.state = 6559; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 30 || _la === 56) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 882, this.context) ) { + case 1: { - this.state = 8770; - this.all_or_distinct(); + this.state = 6554; + this.match(PostgreSqlParser.KW_REPEATABLE); + this.state = 6555; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6556; + this.expression(); + this.state = 6557; + this.match(PostgreSqlParser.CLOSE_PAREN); } + break; } - } } catch (re) { @@ -42528,139 +39362,64 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public with_clause(): With_clauseContext { - let localContext = new With_clauseContext(this.context, this.state); - this.enterRule(localContext, 1014, PostgreSqlParser.RULE_with_clause); + public func_table(): Func_tableContext { + let localContext = new Func_tableContext(this.context, this.state); + this.enterRule(localContext, 634, PostgreSqlParser.RULE_func_table); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8773; - this.match(PostgreSqlParser.KW_WITH); - this.state = 8775; + this.state = 6575; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 861, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 884, this.context) ) { case 1: { - this.state = 8774; - this.match(PostgreSqlParser.KW_RECURSIVE); + this.state = 6561; + this.func_expr_windowless(); } break; - } - this.state = 8777; - this.cte_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public cte_list(): Cte_listContext { - let localContext = new Cte_listContext(this.context, this.state); - this.enterRule(localContext, 1016, PostgreSqlParser.RULE_cte_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 8779; - this.common_table_expr(); - this.state = 8784; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 862, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { + case 2: + { + { + this.state = 6562; + this.match(PostgreSqlParser.KW_ROWS); + this.state = 6563; + this.match(PostgreSqlParser.KW_FROM); + this.state = 6564; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6565; + this.rowsfrom_item(); + this.state = 6570; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { { { - this.state = 8780; + this.state = 6566; this.match(PostgreSqlParser.COMMA); - this.state = 8781; - this.common_table_expr(); + this.state = 6567; + this.rowsfrom_item(); } } + this.state = 6572; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - this.state = 8786; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 862, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public common_table_expr(): Common_table_exprContext { - let localContext = new Common_table_exprContext(this.context, this.state); - this.enterRule(localContext, 1018, PostgreSqlParser.RULE_common_table_expr); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8787; - this.name(); - this.state = 8789; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2) { - { - this.state = 8788; - this.opt_name_list(); - } - } - - this.state = 8791; - this.match(PostgreSqlParser.KW_AS); - this.state = 8793; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 77 || _la === 259) { - { - this.state = 8792; - this.opt_materialized(); + this.state = 6573; + this.match(PostgreSqlParser.CLOSE_PAREN); } - } - - this.state = 8795; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8796; - this.preparablestmt(); - this.state = 8797; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 8799; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 865, this.context) ) { - case 1: - { - this.state = 8798; - this.search_cluase(); } break; } - this.state = 8802; + this.state = 6579; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 866, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 885, this.context) ) { case 1: { - this.state = 8801; - this.cycle_cluase(); + this.state = 6577; + this.match(PostgreSqlParser.KW_WITH); + this.state = 6578; + this.match(PostgreSqlParser.KW_ORDINALITY); } break; } @@ -42680,34 +39439,31 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public search_cluase(): Search_cluaseContext { - let localContext = new Search_cluaseContext(this.context, this.state); - this.enterRule(localContext, 1020, PostgreSqlParser.RULE_search_cluase); + public rowsfrom_item(): Rowsfrom_itemContext { + let localContext = new Rowsfrom_itemContext(this.context, this.state); + this.enterRule(localContext, 636, PostgreSqlParser.RULE_rowsfrom_item); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8804; - this.match(PostgreSqlParser.KW_SEARCH); - this.state = 8805; + this.state = 6581; + this.func_expr_windowless(); + this.state = 6587; + this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if(!(_la === 527 || _la === 528)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); + if (_la === 36) { + { + this.state = 6582; + this.match(PostgreSqlParser.KW_AS); + this.state = 6583; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6584; + this.tablefuncelementlist(); + this.state = 6585; + this.match(PostgreSqlParser.CLOSE_PAREN); + } } - this.state = 8806; - this.match(PostgreSqlParser.KW_FIRST); - this.state = 8807; - this.match(PostgreSqlParser.KW_BY); - this.state = 8808; - this.column_list(); - this.state = 8809; - this.match(PostgreSqlParser.KW_SET); - this.state = 8810; - this.column_name(); + } } catch (re) { @@ -42724,41 +39480,16 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public cycle_cluase(): Cycle_cluaseContext { - let localContext = new Cycle_cluaseContext(this.context, this.state); - this.enterRule(localContext, 1022, PostgreSqlParser.RULE_cycle_cluase); - let _la: number; + public where_clause(): Where_clauseContext { + let localContext = new Where_clauseContext(this.context, this.state); + this.enterRule(localContext, 638, PostgreSqlParser.RULE_where_clause); try { this.enterOuterAlt(localContext, 1); { - this.state = 8812; - this.match(PostgreSqlParser.KW_CYCLE); - this.state = 8813; - this.column_list(); - this.state = 8814; - this.match(PostgreSqlParser.KW_SET); - this.state = 8815; - this.column_name(); - this.state = 8821; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 94) { - { - this.state = 8816; - this.match(PostgreSqlParser.KW_TO); - this.state = 8817; - this.name(); - this.state = 8818; - this.match(PostgreSqlParser.KW_DEFAULT); - this.state = 8819; - this.name(); - } - } - - this.state = 8823; - this.match(PostgreSqlParser.KW_USING); - this.state = 8824; - this.column_name(); + this.state = 6589; + this.match(PostgreSqlParser.KW_WHERE); + this.state = 6590; + this.column_expr_noparen(); } } catch (re) { @@ -42775,55 +39506,34 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_materialized(): Opt_materializedContext { - let localContext = new Opt_materializedContext(this.context, this.state); - this.enterRule(localContext, 1024, PostgreSqlParser.RULE_opt_materialized); + public where_or_current_clause(): Where_or_current_clauseContext { + let localContext = new Where_or_current_clauseContext(this.context, this.state); + this.enterRule(localContext, 640, PostgreSqlParser.RULE_where_or_current_clause); try { - this.state = 8829; + this.enterOuterAlt(localContext, 1); + { + this.state = 6592; + this.match(PostgreSqlParser.KW_WHERE); + this.state = 6597; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_MATERIALIZED: - this.enterOuterAlt(localContext, 1); + switch (this.interpreter.adaptivePredict(this.tokenStream, 887, this.context) ) { + case 1: { - this.state = 8826; - this.match(PostgreSqlParser.KW_MATERIALIZED); + this.state = 6593; + this.match(PostgreSqlParser.KW_CURRENT); + this.state = 6594; + this.match(PostgreSqlParser.KW_OF); + this.state = 6595; + this.colid(); } break; - case PostgreSqlParser.KW_NOT: - this.enterOuterAlt(localContext, 2); + case 2: { - this.state = 8827; - this.match(PostgreSqlParser.KW_NOT); - this.state = 8828; - this.match(PostgreSqlParser.KW_MATERIALIZED); + this.state = 6596; + this.expression(); } break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_with_clause(): Opt_with_clauseContext { - let localContext = new Opt_with_clauseContext(this.context, this.state); - this.enterRule(localContext, 1026, PostgreSqlParser.RULE_opt_with_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8831; - this.with_clause(); } } catch (re) { @@ -42840,31 +39550,30 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public into_clause(): Into_clauseContext { - let localContext = new Into_clauseContext(this.context, this.state); - this.enterRule(localContext, 1028, PostgreSqlParser.RULE_into_clause); + public tablefuncelementlist(): TablefuncelementlistContext { + let localContext = new TablefuncelementlistContext(this.context, this.state); + this.enterRule(localContext, 642, PostgreSqlParser.RULE_tablefuncelementlist); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8833; - this.match(PostgreSqlParser.KW_INTO); - this.state = 8838; + this.state = 6599; + this.tablefuncelement(); + this.state = 6604; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 869, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + while (_la === 6) { { - this.state = 8834; - this.opt_strict(); - this.state = 8835; - this.opttempTableName(); - } - break; - case 2: { - this.state = 8837; - this.into_target(); + this.state = 6600; + this.match(PostgreSqlParser.COMMA); + this.state = 6601; + this.tablefuncelement(); } - break; + } + this.state = 6606; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } } } @@ -42882,27 +39591,27 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_strict(): Opt_strictContext { - let localContext = new Opt_strictContext(this.context, this.state); - this.enterRule(localContext, 1030, PostgreSqlParser.RULE_opt_strict); + public tablefuncelement(): TablefuncelementContext { + let localContext = new TablefuncelementContext(this.context, this.state); + this.enterRule(localContext, 644, PostgreSqlParser.RULE_tablefuncelement); try { - this.state = 8842; + this.enterOuterAlt(localContext, 1); + { + this.state = 6607; + this.colid(); + this.state = 6608; + this.typename(); + this.state = 6610; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 870, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 889, this.context) ) { case 1: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case 2: - this.enterOuterAlt(localContext, 2); { - this.state = 8841; - this.match(PostgreSqlParser.KW_STRICT); + this.state = 6609; + this.opt_collate_clause(); } break; } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -42918,92 +39627,79 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opttempTableName(): OpttempTableNameContext { - let localContext = new OpttempTableNameContext(this.context, this.state); - this.enterRule(localContext, 1032, PostgreSqlParser.RULE_opttempTableName); + public xmltable(): XmltableContext { + let localContext = new XmltableContext(this.context, this.state); + this.enterRule(localContext, 646, PostgreSqlParser.RULE_xmltable); let _la: number; try { - this.state = 8860; + this.enterOuterAlt(localContext, 1); + { + this.state = 6612; + this.match(PostgreSqlParser.KW_XMLTABLE); + this.state = 6613; + this.match(PostgreSqlParser.OPEN_PAREN); + { + this.state = 6627; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 874, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 891, this.context) ) { case 1: - this.enterOuterAlt(localContext, 1); { - this.state = 8845; + this.state = 6614; + this.match(PostgreSqlParser.KW_XMLNAMESPACES); + this.state = 6615; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6616; + this.xml_namespace_el(); + this.state = 6621; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 213 || _la === 254) { + while (_la === 6) { { - this.state = 8844; - _la = this.tokenStream.LA(1); - if(!(_la === 213 || _la === 254)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - - this.state = 8847; - _la = this.tokenStream.LA(1); - if(!(_la === 352 || _la === 354)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 8849; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 92) { { - this.state = 8848; - this.opt_table(); + this.state = 6617; + this.match(PostgreSqlParser.COMMA); + this.state = 6618; + this.xml_namespace_el(); } - } - - this.state = 8851; - this.table_name_create(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 8852; - this.match(PostgreSqlParser.KW_UNLOGGED); - this.state = 8854; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 92) { - { - this.state = 8853; - this.opt_table(); } + this.state = 6623; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - - this.state = 8856; - this.table_name_create(); + this.state = 6624; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6625; + this.match(PostgreSqlParser.COMMA); } break; - case 3: - this.enterOuterAlt(localContext, 3); + } + this.state = 6629; + this.primaryExpression(0); + this.state = 6630; + this.xmlexists_argument(); + this.state = 6631; + this.match(PostgreSqlParser.KW_COLUMNS); + this.state = 6632; + this.xmltable_column_el(); + this.state = 6637; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { { - this.state = 8857; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 8858; - this.table_name_create(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); { - this.state = 8859; - this.table_name_create(); + this.state = 6633; + this.match(PostgreSqlParser.COMMA); + this.state = 6634; + this.xmltable_column_el(); } - break; + } + this.state = 6639; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + this.state = 6640; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -43020,573 +39716,25 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_table(): Opt_tableContext { - let localContext = new Opt_tableContext(this.context, this.state); - this.enterRule(localContext, 1034, PostgreSqlParser.RULE_opt_table); + public xmltable_column_el(): Xmltable_column_elContext { + let localContext = new Xmltable_column_elContext(this.context, this.state); + this.enterRule(localContext, 648, PostgreSqlParser.RULE_xmltable_column_el); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8862; - this.match(PostgreSqlParser.KW_TABLE); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public all_or_distinct(): All_or_distinctContext { - let localContext = new All_or_distinctContext(this.context, this.state); - this.enterRule(localContext, 1036, PostgreSqlParser.RULE_all_or_distinct); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8864; - _la = this.tokenStream.LA(1); - if(!(_la === 30 || _la === 56)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public distinct_clause(): Distinct_clauseContext { - let localContext = new Distinct_clauseContext(this.context, this.state); - this.enterRule(localContext, 1038, PostgreSqlParser.RULE_distinct_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8866; - this.match(PostgreSqlParser.KW_DISTINCT); - this.state = 8872; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 875, this.context) ) { - case 1: - { - this.state = 8867; - this.match(PostgreSqlParser.KW_ON); - this.state = 8868; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8869; - this.expr_list(); - this.state = 8870; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_all_clause(): Opt_all_clauseContext { - let localContext = new Opt_all_clauseContext(this.context, this.state); - this.enterRule(localContext, 1040, PostgreSqlParser.RULE_opt_all_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8874; - this.match(PostgreSqlParser.KW_ALL); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_sort_clause(): Opt_sort_clauseContext { - let localContext = new Opt_sort_clauseContext(this.context, this.state); - this.enterRule(localContext, 1042, PostgreSqlParser.RULE_opt_sort_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8876; - this.sort_clause(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public sort_clause(): Sort_clauseContext { - let localContext = new Sort_clauseContext(this.context, this.state); - this.enterRule(localContext, 1044, PostgreSqlParser.RULE_sort_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8878; - this.match(PostgreSqlParser.KW_ORDER); - this.state = 8879; - this.match(PostgreSqlParser.KW_BY); - this.state = 8880; - this.sortby_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public sortby_list(): Sortby_listContext { - let localContext = new Sortby_listContext(this.context, this.state); - this.enterRule(localContext, 1046, PostgreSqlParser.RULE_sortby_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8882; - this.sortby(); - this.state = 8887; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 8883; - this.match(PostgreSqlParser.COMMA); - this.state = 8884; - this.sortby(); - } - } - this.state = 8889; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public sortby(): SortbyContext { - let localContext = new SortbyContext(this.context, this.state); - this.enterRule(localContext, 1048, PostgreSqlParser.RULE_sortby); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8890; - this.column_expr_noparen(); - this.state = 8894; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 877, this.context) ) { - case 1: - { - this.state = 8891; - this.match(PostgreSqlParser.KW_USING); - this.state = 8892; - this.qual_all_op(); - } - break; - case 2: - { - this.state = 8893; - this.opt_asc_desc(); - } - break; - } - this.state = 8897; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 878, this.context) ) { - case 1: - { - this.state = 8896; - this.opt_nulls_order(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public select_limit(): Select_limitContext { - let localContext = new Select_limitContext(this.context, this.state); - this.enterRule(localContext, 1050, PostgreSqlParser.RULE_select_limit); - let _la: number; - try { - this.state = 8911; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_LIMIT: - this.enterOuterAlt(localContext, 1); - { - this.state = 8899; - this.limit_clause(); - this.state = 8901; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 79) { - { - this.state = 8900; - this.offset_clause(); - } - } - - } - break; - case PostgreSqlParser.KW_OFFSET: - this.enterOuterAlt(localContext, 2); - { - this.state = 8903; - this.offset_clause(); - this.state = 8905; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 880, this.context) ) { - case 1: - { - this.state = 8904; - this.fetch_clause(); - } - break; - } - } - break; - case PostgreSqlParser.KW_FETCH: - this.enterOuterAlt(localContext, 3); - { - this.state = 8907; - this.fetch_clause(); - this.state = 8909; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 79) { - { - this.state = 8908; - this.offset_clause(); - } - } - - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_select_limit(): Opt_select_limitContext { - let localContext = new Opt_select_limitContext(this.context, this.state); - this.enterRule(localContext, 1052, PostgreSqlParser.RULE_opt_select_limit); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8913; - this.select_limit(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public limit_clause(): Limit_clauseContext { - let localContext = new Limit_clauseContext(this.context, this.state); - this.enterRule(localContext, 1054, PostgreSqlParser.RULE_limit_clause); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8915; - this.match(PostgreSqlParser.KW_LIMIT); - this.state = 8916; - this.select_limit_value(); - this.state = 8919; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 6) { - { - this.state = 8917; - this.match(PostgreSqlParser.COMMA); - this.state = 8918; - this.select_offset_value(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public fetch_clause(): Fetch_clauseContext { - let localContext = new Fetch_clauseContext(this.context, this.state); - this.enterRule(localContext, 1056, PostgreSqlParser.RULE_fetch_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8921; - this.match(PostgreSqlParser.KW_FETCH); - this.state = 8922; - this.first_or_next(); - this.state = 8936; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 886, this.context) ) { - case 1: - { - this.state = 8923; - this.select_fetch_first_value(); - this.state = 8924; - this.row_or_rows(); - this.state = 8928; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_ONLY: - { - this.state = 8925; - this.match(PostgreSqlParser.KW_ONLY); - } - break; - case PostgreSqlParser.KW_WITH: - { - this.state = 8926; - this.match(PostgreSqlParser.KW_WITH); - this.state = 8927; - this.match(PostgreSqlParser.KW_TIES); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 2: - { - this.state = 8930; - this.row_or_rows(); - this.state = 8934; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_ONLY: - { - this.state = 8931; - this.match(PostgreSqlParser.KW_ONLY); - } - break; - case PostgreSqlParser.KW_WITH: - { - this.state = 8932; - this.match(PostgreSqlParser.KW_WITH); - this.state = 8933; - this.match(PostgreSqlParser.KW_TIES); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public offset_clause(): Offset_clauseContext { - let localContext = new Offset_clauseContext(this.context, this.state); - this.enterRule(localContext, 1058, PostgreSqlParser.RULE_offset_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8938; - this.match(PostgreSqlParser.KW_OFFSET); - this.state = 8943; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 887, this.context) ) { - case 1: - { - this.state = 8939; - this.select_fetch_first_value(); - this.state = 8940; - this.row_or_rows(); - } - break; - case 2: - { - this.state = 8942; - this.select_offset_value(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public select_limit_value(): Select_limit_valueContext { - let localContext = new Select_limit_valueContext(this.context, this.state); - this.enterRule(localContext, 1060, PostgreSqlParser.RULE_select_limit_value); - try { - this.state = 8947; + this.state = 6642; + this.colid(); + this.state = 6661; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.OPEN_PAREN: - case PostgreSqlParser.PLUS: - case PostgreSqlParser.MINUS: - case PostgreSqlParser.PARAM: - case PostgreSqlParser.Operator: case PostgreSqlParser.KW_AND: case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_CASE: - case PostgreSqlParser.KW_CAST: case PostgreSqlParser.KW_COLLATE: case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_CURRENT_CATALOG: - case PostgreSqlParser.KW_CURRENT_DATE: - case PostgreSqlParser.KW_CURRENT_ROLE: - case PostgreSqlParser.KW_CURRENT_TIME: - case PostgreSqlParser.KW_CURRENT_TIMESTAMP: - case PostgreSqlParser.KW_CURRENT_USER: case PostgreSqlParser.KW_DEFAULT: case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FALSE: case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_LOCALTIME: - case PostgreSqlParser.KW_LOCALTIMESTAMP: - case PostgreSqlParser.KW_NOT: - case PostgreSqlParser.KW_NULL: - case PostgreSqlParser.KW_SESSION_USER: - case PostgreSqlParser.KW_TRUE: - case PostgreSqlParser.KW_UNIQUE: - case PostgreSqlParser.KW_USER: case PostgreSqlParser.KW_AUTHORIZATION: case PostgreSqlParser.KW_BINARY: case PostgreSqlParser.KW_COLLATION: @@ -43997,29 +40145,160 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.StringConstant: case PostgreSqlParser.UnicodeEscapeStringConstant: case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.BinaryStringConstant: - case PostgreSqlParser.HexadecimalStringConstant: - case PostgreSqlParser.Integral: - case PostgreSqlParser.Numeric: case PostgreSqlParser.PLSQLVARIABLENAME: case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); { - this.state = 8945; - this.a_expr(); + this.state = 6643; + this.typename(); + this.state = 6657; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || _la === 77 || _la === 78 || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 268451969) !== 0) || ((((_la - 153)) & ~0x1F) === 0 && ((1 << (_la - 153)) & 540945) !== 0) || _la === 207 || _la === 210 || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & 419430657) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & 268451841) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & 1051713) !== 0) || _la === 360 || _la === 433 || _la === 434 || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & 3959414785) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & 3071) !== 0) || ((((_la - 549)) & ~0x1F) === 0 && ((1 << (_la - 549)) & 100674083) !== 0) || _la === 584) { + { + this.state = 6653; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + this.state = 6653; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 6646; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 893, this.context) ) { + case 1: + { + this.state = 6644; + this.match(PostgreSqlParser.KW_DEFAULT); + } + break; + case 2: + { + this.state = 6645; + this.identifier(); + } + break; + } + this.state = 6648; + this.expression(); + } + break; + case PostgreSqlParser.KW_NOT: + case PostgreSqlParser.KW_NULL: + { + this.state = 6650; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { + { + this.state = 6649; + this.match(PostgreSqlParser.KW_NOT); + } + } + + this.state = 6652; + this.match(PostgreSqlParser.KW_NULL); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + this.state = 6655; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || _la === 77 || _la === 78 || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 268451969) !== 0) || ((((_la - 153)) & ~0x1F) === 0 && ((1 << (_la - 153)) & 540945) !== 0) || _la === 207 || _la === 210 || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & 419430657) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & 268451841) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & 1051713) !== 0) || _la === 360 || _la === 433 || _la === 434 || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & 3959414785) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & 3071) !== 0) || ((((_la - 549)) & ~0x1F) === 0 && ((1 << (_la - 549)) & 100674083) !== 0) || _la === 584); + } + } + } break; - case PostgreSqlParser.KW_ALL: - this.enterOuterAlt(localContext, 2); + case PostgreSqlParser.KW_FOR: { - this.state = 8946; - this.match(PostgreSqlParser.KW_ALL); + this.state = 6659; + this.match(PostgreSqlParser.KW_FOR); + this.state = 6660; + this.match(PostgreSqlParser.KW_ORDINALITY); } break; default: throw new antlr.NoViableAltException(this); } + } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -44035,14 +40314,33 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public select_offset_value(): Select_offset_valueContext { - let localContext = new Select_offset_valueContext(this.context, this.state); - this.enterRule(localContext, 1062, PostgreSqlParser.RULE_select_offset_value); + public xml_namespace_el(): Xml_namespace_elContext { + let localContext = new Xml_namespace_elContext(this.context, this.state); + this.enterRule(localContext, 650, PostgreSqlParser.RULE_xml_namespace_el); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 8949; - this.a_expr(); + this.state = 6669; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 899, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 6663; + this.primaryExpression(0); + this.state = 6664; + this.match(PostgreSqlParser.KW_AS); + this.state = 6665; + this.collabel(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 6667; + this.match(PostgreSqlParser.KW_DEFAULT); + this.state = 6668; + this.primaryExpression(0); + } + break; } } catch (re) { @@ -44059,477 +40357,260 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public select_fetch_first_value(): Select_fetch_first_valueContext { - let localContext = new Select_fetch_first_valueContext(this.context, this.state); - this.enterRule(localContext, 1064, PostgreSqlParser.RULE_select_fetch_first_value); + public typename(): TypenameContext { + let localContext = new TypenameContext(this.context, this.state); + this.enterRule(localContext, 652, PostgreSqlParser.RULE_typename); + let _la: number; try { - this.state = 8956; + let alternative: number; + this.state = 6697; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.PLUS: + switch (this.interpreter.adaptivePredict(this.tokenStream, 905, this.context) ) { + case 1: this.enterOuterAlt(localContext, 1); { - this.state = 8951; - this.match(PostgreSqlParser.PLUS); - this.state = 8952; - this.i_or_f_const(); + this.state = 6672; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 415) { + { + this.state = 6671; + this.match(PostgreSqlParser.KW_SETOF); + } + } + + this.state = 6674; + this.simpletypename(); + this.state = 6691; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 904, this.context) ) { + case 1: + { + { + this.state = 6682; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 902, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 6675; + this.match(PostgreSqlParser.OPEN_BRACKET); + this.state = 6677; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 571) { + { + this.state = 6676; + this.match(PostgreSqlParser.Integral); + } + } + + this.state = 6679; + this.match(PostgreSqlParser.CLOSE_BRACKET); + } + } + } + this.state = 6684; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 902, this.context); + } + } + } + break; + case 2: + { + this.state = 6685; + this.match(PostgreSqlParser.KW_ARRAY); + this.state = 6689; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 903, this.context) ) { + case 1: + { + this.state = 6686; + this.match(PostgreSqlParser.OPEN_BRACKET); + this.state = 6687; + this.match(PostgreSqlParser.Integral); + this.state = 6688; + this.match(PostgreSqlParser.CLOSE_BRACKET); + } + break; + } + } + break; + } } break; - case PostgreSqlParser.MINUS: + case 2: this.enterOuterAlt(localContext, 2); { - this.state = 8953; - this.match(PostgreSqlParser.MINUS); - this.state = 8954; - this.i_or_f_const(); + this.state = 6693; + this.qualified_name(); + this.state = 6694; + this.match(PostgreSqlParser.PERCENT); + this.state = 6695; + _la = this.tokenStream.LA(1); + if(!(_la === 360 || _la === 477)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } } break; - case PostgreSqlParser.OPEN_PAREN: - case PostgreSqlParser.PARAM: - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_CASE: - case PostgreSqlParser.KW_CAST: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_CURRENT_CATALOG: - case PostgreSqlParser.KW_CURRENT_DATE: - case PostgreSqlParser.KW_CURRENT_ROLE: - case PostgreSqlParser.KW_CURRENT_TIME: - case PostgreSqlParser.KW_CURRENT_TIMESTAMP: - case PostgreSqlParser.KW_CURRENT_USER: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FALSE: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_LOCALTIME: - case PostgreSqlParser.KW_LOCALTIMESTAMP: - case PostgreSqlParser.KW_NULL: - case PostgreSqlParser.KW_SESSION_USER: - case PostgreSqlParser.KW_TRUE: - case PostgreSqlParser.KW_UNIQUE: - case PostgreSqlParser.KW_USER: - case PostgreSqlParser.KW_AUTHORIZATION: - case PostgreSqlParser.KW_BINARY: - case PostgreSqlParser.KW_COLLATION: - case PostgreSqlParser.KW_CONCURRENTLY: - case PostgreSqlParser.KW_CROSS: - case PostgreSqlParser.KW_CURRENT_SCHEMA: - case PostgreSqlParser.KW_FREEZE: - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_ILIKE: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_ISNULL: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_LIKE: - case PostgreSqlParser.KW_NATURAL: - case PostgreSqlParser.KW_NOTNULL: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_OVERLAPS: - case PostgreSqlParser.KW_RIGHT: - case PostgreSqlParser.KW_SIMILAR: - case PostgreSqlParser.KW_VERBOSE: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public simpletypename(): SimpletypenameContext { + let localContext = new SimpletypenameContext(this.context, this.state); + this.enterRule(localContext, 654, PostgreSqlParser.RULE_simpletypename); + try { + this.state = 6714; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 910, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 6699; + this.type_function_name(); + this.state = 6701; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 906, this.context) ) { + case 1: + { + this.state = 6700; + this.attrs(); + } + break; + } + this.state = 6704; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 907, this.context) ) { + case 1: + { + this.state = 6703; + this.execute_param_clause(); + } + break; + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 6706; + this.consttypename(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 6707; + this.match(PostgreSqlParser.KW_INTERVAL); + this.state = 6712; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 909, this.context) ) { + case 1: + { + this.state = 6709; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 908, this.context) ) { + case 1: + { + this.state = 6708; + this.opt_interval(); + } + break; + } + } + break; + case 2: + { + this.state = 6711; + this.opt_float(); + } + break; + } + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public consttypename(): ConsttypenameContext { + let localContext = new ConsttypenameContext(this.context, this.state); + this.enterRule(localContext, 656, PostgreSqlParser.RULE_consttypename); + try { + this.state = 6720; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: case PostgreSqlParser.KW_DEC: case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: case PostgreSqlParser.KW_INT: case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: + this.enterOuterAlt(localContext, 1); + { + this.state = 6716; + this.numeric(); + } + break; + case PostgreSqlParser.KW_BIT: + this.enterOuterAlt(localContext, 2); + { + this.state = 6717; + this.bit(); + } + break; + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_VARCHAR: + this.enterOuterAlt(localContext, 3); + { + this.state = 6718; + this.character(); + } + break; case PostgreSqlParser.KW_TIME: case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_TABLESAMPLE: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.BinaryStringConstant: - case PostgreSqlParser.HexadecimalStringConstant: - case PostgreSqlParser.Integral: - case PostgreSqlParser.Numeric: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 3); + this.enterOuterAlt(localContext, 4); { - this.state = 8955; - this.c_expr(); + this.state = 6719; + this.constdatetime(); } break; default: @@ -44550,25 +40631,106 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public i_or_f_const(): I_or_f_constContext { - let localContext = new I_or_f_constContext(this.context, this.state); - this.enterRule(localContext, 1066, PostgreSqlParser.RULE_i_or_f_const); + public numeric(): NumericContext { + let localContext = new NumericContext(this.context, this.state); + this.enterRule(localContext, 658, PostgreSqlParser.RULE_numeric); + let _la: number; try { - this.state = 8960; + this.state = 6738; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.Integral: + case PostgreSqlParser.KW_INT: this.enterOuterAlt(localContext, 1); { - this.state = 8958; - this.iconst(); + this.state = 6722; + this.match(PostgreSqlParser.KW_INT); } break; - case PostgreSqlParser.Numeric: + case PostgreSqlParser.KW_INTEGER: this.enterOuterAlt(localContext, 2); { - this.state = 8959; - this.fconst(); + this.state = 6723; + this.match(PostgreSqlParser.KW_INTEGER); + } + break; + case PostgreSqlParser.KW_SMALLINT: + this.enterOuterAlt(localContext, 3); + { + this.state = 6724; + this.match(PostgreSqlParser.KW_SMALLINT); + } + break; + case PostgreSqlParser.KW_BIGINT: + this.enterOuterAlt(localContext, 4); + { + this.state = 6725; + this.match(PostgreSqlParser.KW_BIGINT); + } + break; + case PostgreSqlParser.KW_REAL: + this.enterOuterAlt(localContext, 5); + { + this.state = 6726; + this.match(PostgreSqlParser.KW_REAL); + } + break; + case PostgreSqlParser.KW_FLOAT: + this.enterOuterAlt(localContext, 6); + { + this.state = 6727; + this.match(PostgreSqlParser.KW_FLOAT); + this.state = 6729; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 912, this.context) ) { + case 1: + { + this.state = 6728; + this.opt_float(); + } + break; + } + } + break; + case PostgreSqlParser.KW_DOUBLE: + this.enterOuterAlt(localContext, 7); + { + this.state = 6731; + this.match(PostgreSqlParser.KW_DOUBLE); + this.state = 6732; + this.match(PostgreSqlParser.KW_PRECISION); + } + break; + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_NUMERIC: + this.enterOuterAlt(localContext, 8); + { + this.state = 6733; + _la = this.tokenStream.LA(1); + if(!(((((_la - 394)) & ~0x1F) === 0 && ((1 << (_la - 394)) & 32771) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6735; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 913, this.context) ) { + case 1: + { + this.state = 6734; + this.execute_param_clause(); + } + break; + } + } + break; + case PostgreSqlParser.KW_BOOLEAN: + this.enterOuterAlt(localContext, 9); + { + this.state = 6737; + this.match(PostgreSqlParser.KW_BOOLEAN); } break; default: @@ -44589,22 +40751,18 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public row_or_rows(): Row_or_rowsContext { - let localContext = new Row_or_rowsContext(this.context, this.state); - this.enterRule(localContext, 1068, PostgreSqlParser.RULE_row_or_rows); - let _la: number; + public opt_float(): Opt_floatContext { + let localContext = new Opt_floatContext(this.context, this.state); + this.enterRule(localContext, 660, PostgreSqlParser.RULE_opt_float); try { this.enterOuterAlt(localContext, 1); { - this.state = 8962; - _la = this.tokenStream.LA(1); - if(!(_la === 320 || _la === 414)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } + this.state = 6740; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6741; + this.match(PostgreSqlParser.Integral); + this.state = 6742; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -44621,21 +40779,33 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public first_or_next(): First_or_nextContext { - let localContext = new First_or_nextContext(this.context, this.state); - this.enterRule(localContext, 1070, PostgreSqlParser.RULE_first_or_next); - let _la: number; + public bit(): BitContext { + let localContext = new BitContext(this.context, this.state); + this.enterRule(localContext, 662, PostgreSqlParser.RULE_bit); try { this.enterOuterAlt(localContext, 1); { - this.state = 8964; - _la = this.tokenStream.LA(1); - if(!(_la === 207 || _la === 268)) { - this.errorHandler.recoverInline(this); + this.state = 6744; + this.match(PostgreSqlParser.KW_BIT); + this.state = 6746; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 915, this.context) ) { + case 1: + { + this.state = 6745; + this.match(PostgreSqlParser.KW_VARYING); + } + break; } - else { - this.errorHandler.reportMatch(this); - this.consume(); + this.state = 6749; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 916, this.context) ) { + case 1: + { + this.state = 6748; + this.execute_param_clause(); + } + break; } } } @@ -44653,28 +40823,85 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public group_clause(): Group_clauseContext { - let localContext = new Group_clauseContext(this.context, this.state); - this.enterRule(localContext, 1072, PostgreSqlParser.RULE_group_clause); + public character(): CharacterContext { + let localContext = new CharacterContext(this.context, this.state); + this.enterRule(localContext, 664, PostgreSqlParser.RULE_character); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8966; - this.match(PostgreSqlParser.KW_GROUP); - this.state = 8967; - this.match(PostgreSqlParser.KW_BY); - this.state = 8969; + this.state = 6761; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 891, this.context) ) { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_NCHAR: + { + this.state = 6751; + _la = this.tokenStream.LA(1); + if(!(((((_la - 391)) & ~0x1F) === 0 && ((1 << (_la - 391)) & 32771) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6753; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 917, this.context) ) { + case 1: + { + this.state = 6752; + this.match(PostgreSqlParser.KW_VARYING); + } + break; + } + } + break; + case PostgreSqlParser.KW_VARCHAR: + { + this.state = 6755; + this.match(PostgreSqlParser.KW_VARCHAR); + } + break; + case PostgreSqlParser.KW_NATIONAL: + { + this.state = 6756; + this.match(PostgreSqlParser.KW_NATIONAL); + this.state = 6757; + _la = this.tokenStream.LA(1); + if(!(_la === 391 || _la === 392)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6759; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 918, this.context) ) { + case 1: + { + this.state = 6758; + this.match(PostgreSqlParser.KW_VARYING); + } + break; + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 6764; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 920, this.context) ) { case 1: { - this.state = 8968; - this.all_or_distinct(); + this.state = 6763; + this.opt_float(); } break; } - this.state = 8971; - this.group_by_list(); } } catch (re) { @@ -44691,32 +40918,52 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public group_by_list(): Group_by_listContext { - let localContext = new Group_by_listContext(this.context, this.state); - this.enterRule(localContext, 1074, PostgreSqlParser.RULE_group_by_list); + public constdatetime(): ConstdatetimeContext { + let localContext = new ConstdatetimeContext(this.context, this.state); + this.enterRule(localContext, 666, PostgreSqlParser.RULE_constdatetime); + let _la: number; try { - let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 8973; - this.group_by_item(); - this.state = 8978; + this.state = 6766; + _la = this.tokenStream.LA(1); + if(!(_la === 418 || _la === 419)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6768; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 892, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 8974; - this.match(PostgreSqlParser.COMMA); - this.state = 8975; - this.group_by_item(); - } - } + switch (this.interpreter.adaptivePredict(this.tokenStream, 921, this.context) ) { + case 1: + { + this.state = 6767; + this.opt_float(); } - this.state = 8980; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 892, this.context); + break; + } + this.state = 6773; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 922, this.context) ) { + case 1: + { + this.state = 6770; + _la = this.tokenStream.LA(1); + if(!(_la === 105 || _la === 379)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6771; + this.match(PostgreSqlParser.KW_TIME); + this.state = 6772; + this.match(PostgreSqlParser.KW_ZONE); + } + break; } } } @@ -44734,59 +40981,143 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public group_by_item(): Group_by_itemContext { - let localContext = new Group_by_itemContext(this.context, this.state); - this.enterRule(localContext, 1076, PostgreSqlParser.RULE_group_by_item); + public opt_interval(): Opt_intervalContext { + let localContext = new Opt_intervalContext(this.context, this.state); + this.enterRule(localContext, 668, PostgreSqlParser.RULE_opt_interval); try { - this.state = 8990; + this.state = 6804; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 893, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_MONTH: this.enterOuterAlt(localContext, 1); { - this.state = 8981; - this.column_expr_noparen(); + this.state = 6775; + this.match(PostgreSqlParser.KW_MONTH); } break; - case 2: + case PostgreSqlParser.KW_SECOND: this.enterOuterAlt(localContext, 2); { - this.state = 8982; - this.empty_grouping_set(); + this.state = 6776; + this.interval_second(); } break; - case 3: + case PostgreSqlParser.KW_YEAR: this.enterOuterAlt(localContext, 3); { - this.state = 8983; - this.cube_clause(); + this.state = 6777; + this.match(PostgreSqlParser.KW_YEAR); + this.state = 6780; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 923, this.context) ) { + case 1: + { + this.state = 6778; + this.match(PostgreSqlParser.KW_TO); + this.state = 6779; + this.match(PostgreSqlParser.KW_MONTH); + } + break; + } } break; - case 4: + case PostgreSqlParser.KW_DAY: this.enterOuterAlt(localContext, 4); { - this.state = 8984; - this.rollup_clause(); + this.state = 6782; + this.match(PostgreSqlParser.KW_DAY); + this.state = 6789; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 925, this.context) ) { + case 1: + { + this.state = 6783; + this.match(PostgreSqlParser.KW_TO); + this.state = 6787; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_HOUR: + { + this.state = 6784; + this.match(PostgreSqlParser.KW_HOUR); + } + break; + case PostgreSqlParser.KW_MINUTE: + { + this.state = 6785; + this.match(PostgreSqlParser.KW_MINUTE); + } + break; + case PostgreSqlParser.KW_SECOND: + { + this.state = 6786; + this.interval_second(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + } } break; - case 5: + case PostgreSqlParser.KW_HOUR: this.enterOuterAlt(localContext, 5); { - this.state = 8985; - this.grouping_sets_clause(); + this.state = 6791; + this.match(PostgreSqlParser.KW_HOUR); + this.state = 6797; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 927, this.context) ) { + case 1: + { + this.state = 6792; + this.match(PostgreSqlParser.KW_TO); + this.state = 6795; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_MINUTE: + { + this.state = 6793; + this.match(PostgreSqlParser.KW_MINUTE); + } + break; + case PostgreSqlParser.KW_SECOND: + { + this.state = 6794; + this.interval_second(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + } } break; - case 6: + case PostgreSqlParser.KW_MINUTE: this.enterOuterAlt(localContext, 6); { - this.state = 8986; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8987; - this.column_expr_list_noparen(); - this.state = 8988; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6799; + this.match(PostgreSqlParser.KW_MINUTE); + this.state = 6802; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 928, this.context) ) { + case 1: + { + this.state = 6800; + this.match(PostgreSqlParser.KW_TO); + this.state = 6801; + this.interval_second(); + } + break; + } } break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -44803,16 +41134,24 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public empty_grouping_set(): Empty_grouping_setContext { - let localContext = new Empty_grouping_setContext(this.context, this.state); - this.enterRule(localContext, 1078, PostgreSqlParser.RULE_empty_grouping_set); + public interval_second(): Interval_secondContext { + let localContext = new Interval_secondContext(this.context, this.state); + this.enterRule(localContext, 670, PostgreSqlParser.RULE_interval_second); try { this.enterOuterAlt(localContext, 1); { - this.state = 8992; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8993; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6806; + this.match(PostgreSqlParser.KW_SECOND); + this.state = 6808; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 930, this.context) ) { + case 1: + { + this.state = 6807; + this.opt_float(); + } + break; + } } } catch (re) { @@ -44829,50 +41168,22 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public rollup_clause(): Rollup_clauseContext { - let localContext = new Rollup_clauseContext(this.context, this.state); - this.enterRule(localContext, 1080, PostgreSqlParser.RULE_rollup_clause); + public comparisonOperator(): ComparisonOperatorContext { + let localContext = new ComparisonOperatorContext(this.context, this.state); + this.enterRule(localContext, 672, PostgreSqlParser.RULE_comparisonOperator); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 8995; - this.match(PostgreSqlParser.KW_ROLLUP); - this.state = 8996; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 8997; - this.column_expr_list_noparen(); - this.state = 8998; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6810; + _la = this.tokenStream.LA(1); + if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 44237824) !== 0))) { + this.errorHandler.recoverInline(this); } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + else { + this.errorHandler.reportMatch(this); + this.consume(); } - } - finally { - this.exitRule(); - } - return localContext; - } - public cube_clause(): Cube_clauseContext { - let localContext = new Cube_clauseContext(this.context, this.state); - this.enterRule(localContext, 1082, PostgreSqlParser.RULE_cube_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9000; - this.match(PostgreSqlParser.KW_CUBE); - this.state = 9001; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9002; - this.column_expr_list_noparen(); - this.state = 9003; - this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -44889,22 +41200,14 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public grouping_sets_clause(): Grouping_sets_clauseContext { - let localContext = new Grouping_sets_clauseContext(this.context, this.state); - this.enterRule(localContext, 1084, PostgreSqlParser.RULE_grouping_sets_clause); + public expression(): ExpressionContext { + let localContext = new ExpressionContext(this.context, this.state); + this.enterRule(localContext, 674, PostgreSqlParser.RULE_expression); try { this.enterOuterAlt(localContext, 1); { - this.state = 9005; - this.match(PostgreSqlParser.KW_GROUPING); - this.state = 9006; - this.match(PostgreSqlParser.KW_SETS); - this.state = 9007; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9008; - this.group_by_list(); - this.state = 9009; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6812; + this.booleanExpression(0); } } catch (re) { @@ -44921,81 +41224,556 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public having_clause(): Having_clauseContext { - let localContext = new Having_clauseContext(this.context, this.state); - this.enterRule(localContext, 1086, PostgreSqlParser.RULE_having_clause); + + public booleanExpression(): BooleanExpressionContext; + public booleanExpression(_p: number): BooleanExpressionContext; + public booleanExpression(_p?: number): BooleanExpressionContext { + if (_p === undefined) { + _p = 0; + } + + let parentContext = this.context; + let parentState = this.state; + let localContext = new BooleanExpressionContext(this.context, parentState); + let previousContext = localContext; + let _startState = 676; + this.enterRecursionRule(localContext, 676, PostgreSqlParser.RULE_booleanExpression, _p); try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 9011; - this.match(PostgreSqlParser.KW_HAVING); - this.state = 9012; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public for_locking_clause(): For_locking_clauseContext { - let localContext = new For_locking_clauseContext(this.context, this.state); - this.enterRule(localContext, 1088, PostgreSqlParser.RULE_for_locking_clause); - try { - this.state = 9018; + this.state = 6821; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 894, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 9014; - this.for_locking_items(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 9015; - this.match(PostgreSqlParser.KW_FOR); - this.state = 9016; - this.match(PostgreSqlParser.KW_READ); - this.state = 9017; - this.match(PostgreSqlParser.KW_ONLY); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.OPEN_PAREN: + case PostgreSqlParser.PLUS: + case PostgreSqlParser.MINUS: + case PostgreSqlParser.PARAM: + case PostgreSqlParser.Operator: + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_CASE: + case PostgreSqlParser.KW_CAST: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_CURRENT_CATALOG: + case PostgreSqlParser.KW_CURRENT_DATE: + case PostgreSqlParser.KW_CURRENT_ROLE: + case PostgreSqlParser.KW_CURRENT_TIME: + case PostgreSqlParser.KW_CURRENT_TIMESTAMP: + case PostgreSqlParser.KW_CURRENT_USER: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FALSE: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_LOCALTIME: + case PostgreSqlParser.KW_LOCALTIMESTAMP: + case PostgreSqlParser.KW_NULL: + case PostgreSqlParser.KW_SESSION_USER: + case PostgreSqlParser.KW_TRUE: + case PostgreSqlParser.KW_UNIQUE: + case PostgreSqlParser.KW_USER: + case PostgreSqlParser.KW_AUTHORIZATION: + case PostgreSqlParser.KW_BINARY: + case PostgreSqlParser.KW_COLLATION: + case PostgreSqlParser.KW_CONCURRENTLY: + case PostgreSqlParser.KW_CROSS: + case PostgreSqlParser.KW_CURRENT_SCHEMA: + case PostgreSqlParser.KW_FREEZE: + case PostgreSqlParser.KW_FULL: + case PostgreSqlParser.KW_ILIKE: + case PostgreSqlParser.KW_INNER: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_ISNULL: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_LIKE: + case PostgreSqlParser.KW_NATURAL: + case PostgreSqlParser.KW_NOTNULL: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_OVERLAPS: + case PostgreSqlParser.KW_RIGHT: + case PostgreSqlParser.KW_SIMILAR: + case PostgreSqlParser.KW_VERBOSE: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_TABLESAMPLE: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.BinaryStringConstant: + case PostgreSqlParser.HexadecimalStringConstant: + case PostgreSqlParser.Integral: + case PostgreSqlParser.Numeric: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + localContext = new PredicatedContext(localContext); + this.context = localContext; + previousContext = localContext; + + this.state = 6815; + (localContext as PredicatedContext)._valueExpression = this.valueExpression(0); + this.state = 6817; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 931, this.context) ) { + case 1: + { + this.state = 6816; + this.predicate((localContext as PredicatedContext)._valueExpression); + } + break; + } + } + break; + case PostgreSqlParser.KW_NOT: + { + localContext = new LogicalNotContext(localContext); + this.context = localContext; + previousContext = localContext; + this.state = 6819; + this.match(PostgreSqlParser.KW_NOT); + this.state = 6820; + this.booleanExpression(3); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.context!.stop = this.tokenStream.LT(-1); + this.state = 6831; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 934, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + previousContext = localContext; + { + this.state = 6829; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 933, this.context) ) { + case 1: + { + localContext = new LogicalBinaryContext(new BooleanExpressionContext(parentContext, parentState)); + (localContext as LogicalBinaryContext)._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_booleanExpression); + this.state = 6823; + if (!(this.precpred(this.context, 2))) { + throw this.createFailedPredicateException("this.precpred(this.context, 2)"); + } + this.state = 6824; + (localContext as LogicalBinaryContext)._operator = this.match(PostgreSqlParser.KW_AND); + this.state = 6825; + (localContext as LogicalBinaryContext)._right = this.booleanExpression(3); + } + break; + case 2: + { + localContext = new LogicalBinaryContext(new BooleanExpressionContext(parentContext, parentState)); + (localContext as LogicalBinaryContext)._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_booleanExpression); + this.state = 6826; + if (!(this.precpred(this.context, 1))) { + throw this.createFailedPredicateException("this.precpred(this.context, 1)"); + } + this.state = 6827; + (localContext as LogicalBinaryContext)._operator = this.match(PostgreSqlParser.KW_OR); + this.state = 6828; + (localContext as LogicalBinaryContext)._right = this.booleanExpression(2); + } + break; + } + } + } + this.state = 6833; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 934, this.context); } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_for_locking_clause(): Opt_for_locking_clauseContext { - let localContext = new Opt_for_locking_clauseContext(this.context, this.state); - this.enterRule(localContext, 1090, PostgreSqlParser.RULE_opt_for_locking_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9020; - this.for_locking_clause(); } } catch (re) { @@ -45008,142 +41786,260 @@ export class PostgreSqlParser extends SQLParserBase { } } finally { - this.exitRule(); + this.unrollRecursionContexts(parentContext); } return localContext; } - public for_locking_items(): For_locking_itemsContext { - let localContext = new For_locking_itemsContext(this.context, this.state); - this.enterRule(localContext, 1092, PostgreSqlParser.RULE_for_locking_items); + public predicate(value: antlr.ParserRuleContext): PredicateContext { + let localContext = new PredicateContext(this.context, this.state, value); + this.enterRule(localContext, 678, PostgreSqlParser.RULE_predicate); let _la: number; try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9023; + this.state = 6905; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - do { + switch (this.interpreter.adaptivePredict(this.tokenStream, 946, this.context) ) { + case 1: + localContext = new ComparisonContext(localContext); + this.enterOuterAlt(localContext, 1); { + this.state = 6834; + this.comparisonOperator(); + this.state = 6835; + (localContext as ComparisonContext)._right = this.valueExpression(0); + } + break; + case 2: + localContext = new QuantifiedComparisonContext(localContext); + this.enterOuterAlt(localContext, 2); { - this.state = 9022; - this.for_locking_item(); + this.state = 6837; + this.comparisonOperator(); + this.state = 6838; + this.subquery_Op(); + this.state = 6839; + this.sub_type(); + this.state = 6845; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 935, this.context) ) { + case 1: + { + this.state = 6840; + this.select_with_parens(); + } + break; + case 2: + { + this.state = 6841; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6842; + this.expression(); + this.state = 6843; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; } } - this.state = 9025; + break; + case 3: + localContext = new BetweenContext(localContext); + this.enterOuterAlt(localContext, 3); + { + this.state = 6848; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - } while (_la === 62); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public for_locking_item(): For_locking_itemContext { - let localContext = new For_locking_itemContext(this.context, this.state); - this.enterRule(localContext, 1094, PostgreSqlParser.RULE_for_locking_item); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9027; - this.for_locking_strength(); - this.state = 9029; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 896, this.context) ) { - case 1: + if (_la === 77) { + { + this.state = 6847; + this.match(PostgreSqlParser.KW_NOT); + } + } + + this.state = 6850; + this.match(PostgreSqlParser.KW_BETWEEN); + this.state = 6851; + (localContext as BetweenContext)._lower = this.valueExpression(0); + this.state = 6852; + this.match(PostgreSqlParser.KW_AND); + this.state = 6853; + (localContext as BetweenContext)._upper = this.valueExpression(0); + } + break; + case 4: + localContext = new InListContext(localContext); + this.enterOuterAlt(localContext, 4); { - this.state = 9028; - this.locked_rels_list(); + this.state = 6856; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { + { + this.state = 6855; + this.match(PostgreSqlParser.KW_NOT); + } + } + + this.state = 6858; + this.match(PostgreSqlParser.KW_IN); + this.state = 6859; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6860; + this.expression(); + this.state = 6865; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 6861; + this.match(PostgreSqlParser.COMMA); + this.state = 6862; + this.expression(); + } + } + this.state = 6867; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 6868; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; - } - this.state = 9032; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 897, this.context) ) { - case 1: + case 5: + localContext = new InSubqueryContext(localContext); + this.enterOuterAlt(localContext, 5); { - this.state = 9031; - this.opt_nowait_or_skip(); + this.state = 6871; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { + { + this.state = 6870; + this.match(PostgreSqlParser.KW_NOT); + } + } + + this.state = 6873; + this.match(PostgreSqlParser.KW_IN); + this.state = 6874; + this.select_with_parens(); } break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public for_locking_strength(): For_locking_strengthContext { - let localContext = new For_locking_strengthContext(this.context, this.state); - this.enterRule(localContext, 1096, PostgreSqlParser.RULE_for_locking_strength); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9034; - this.match(PostgreSqlParser.KW_FOR); - this.state = 9044; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_UPDATE: + case 6: + localContext = new LikeContext(localContext); + this.enterOuterAlt(localContext, 6); { - this.state = 9037; + this.state = 6876; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 269) { + if (_la === 77) { { - this.state = 9035; - this.match(PostgreSqlParser.KW_NO); - this.state = 9036; - this.match(PostgreSqlParser.KW_KEY); + this.state = 6875; + this.match(PostgreSqlParser.KW_NOT); } } - this.state = 9039; - this.match(PostgreSqlParser.KW_UPDATE); + this.state = 6886; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_LIKE: + { + this.state = 6878; + this.match(PostgreSqlParser.KW_LIKE); + } + break; + case PostgreSqlParser.KW_ILIKE: + { + this.state = 6879; + this.match(PostgreSqlParser.KW_ILIKE); + } + break; + case PostgreSqlParser.KW_SIMILAR: + { + this.state = 6880; + this.match(PostgreSqlParser.KW_SIMILAR); + this.state = 6881; + this.match(PostgreSqlParser.KW_TO); + } + break; + case PostgreSqlParser.KW_BETWEEN: + { + this.state = 6882; + this.match(PostgreSqlParser.KW_BETWEEN); + this.state = 6884; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 91) { + { + this.state = 6883; + this.match(PostgreSqlParser.KW_SYMMETRIC); + } + } + + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 6888; + (localContext as LikeContext)._pattern = this.valueExpression(0); + this.state = 6891; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 943, this.context) ) { + case 1: + { + this.state = 6889; + this.match(PostgreSqlParser.KW_ESCAPE); + this.state = 6890; + (localContext as LikeContext)._escape = this.valueExpression(0); + } + break; + } } break; - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_SHARE: + case 7: + localContext = new NullPredicateContext(localContext); + this.enterOuterAlt(localContext, 7); { - this.state = 9041; + this.state = 6893; + this.match(PostgreSqlParser.KW_IS); + this.state = 6895; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 245) { + if (_la === 77) { { - this.state = 9040; - this.match(PostgreSqlParser.KW_KEY); + this.state = 6894; + this.match(PostgreSqlParser.KW_NOT); } } - this.state = 9043; - this.match(PostgreSqlParser.KW_SHARE); + this.state = 6897; + this.match(PostgreSqlParser.KW_NULL); + } + break; + case 8: + localContext = new DistinctFromContext(localContext); + this.enterOuterAlt(localContext, 8); + { + this.state = 6898; + this.match(PostgreSqlParser.KW_IS); + this.state = 6900; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { + { + this.state = 6899; + this.match(PostgreSqlParser.KW_NOT); + } + } + + this.state = 6902; + this.match(PostgreSqlParser.KW_DISTINCT); + this.state = 6903; + this.match(PostgreSqlParser.KW_FROM); + this.state = 6904; + (localContext as DistinctFromContext)._right = this.valueExpression(0); } break; - default: - throw new antlr.NoViableAltException(this); - } } } catch (re) { @@ -45160,135 +42056,157 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public locked_rels_list(): Locked_rels_listContext { - let localContext = new Locked_rels_listContext(this.context, this.state); - this.enterRule(localContext, 1098, PostgreSqlParser.RULE_locked_rels_list); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9046; - this.match(PostgreSqlParser.KW_OF); - this.state = 9047; - this.qualified_name_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); + + public valueExpression(): ValueExpressionContext; + public valueExpression(_p: number): ValueExpressionContext; + public valueExpression(_p?: number): ValueExpressionContext { + if (_p === undefined) { + _p = 0; } - return localContext; - } - public values_clause(): Values_clauseContext { - let localContext = new Values_clauseContext(this.context, this.state); - this.enterRule(localContext, 1100, PostgreSqlParser.RULE_values_clause); + + let parentContext = this.context; + let parentState = this.state; + let localContext = new ValueExpressionContext(this.context, parentState); + let previousContext = localContext; + let _startState = 680; + this.enterRecursionRule(localContext, 680, PostgreSqlParser.RULE_valueExpression, _p); let _la: number; try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 9049; - this.match(PostgreSqlParser.KW_VALUES); - this.state = 9050; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9051; - this.expr_list(); - this.state = 9052; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 9060; + this.state = 6911; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 947, this.context) ) { + case 1: { + localContext = new ValueExpressionDefaultContext(localContext); + this.context = localContext; + previousContext = localContext; + + this.state = 6908; + this.primaryExpression(0); + } + break; + case 2: { - this.state = 9053; - this.match(PostgreSqlParser.COMMA); - this.state = 9054; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9055; - this.expr_list(); - this.state = 9056; - this.match(PostgreSqlParser.CLOSE_PAREN); + localContext = new ArithmeticUnaryContext(localContext); + this.context = localContext; + previousContext = localContext; + this.state = 6909; + (localContext as ArithmeticUnaryContext)._operator = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 12 || _la === 13)) { + (localContext as ArithmeticUnaryContext)._operator = this.errorHandler.recoverInline(this); } + else { + this.errorHandler.reportMatch(this); + this.consume(); } - this.state = 9062; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public from_clause(): From_clauseContext { - let localContext = new From_clauseContext(this.context, this.state); - this.enterRule(localContext, 1102, PostgreSqlParser.RULE_from_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9063; - this.match(PostgreSqlParser.KW_FROM); - this.state = 9064; - this.from_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + this.state = 6910; + this.valueExpression(4); + } + break; } - } - finally { - this.exitRule(); - } - return localContext; - } - public from_list(): From_listContext { - let localContext = new From_listContext(this.context, this.state); - this.enterRule(localContext, 1104, PostgreSqlParser.RULE_from_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 9066; - this.table_ref(); - this.state = 9071; + this.context!.stop = this.tokenStream.LT(-1); + this.state = 6929; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 902, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 949, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + previousContext = localContext; { - { - this.state = 9067; - this.match(PostgreSqlParser.COMMA); - this.state = 9068; - this.table_ref(); + this.state = 6927; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 948, this.context) ) { + case 1: + { + localContext = new ArithmeticBinaryContext(new ValueExpressionContext(parentContext, parentState)); + (localContext as ArithmeticBinaryContext)._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_valueExpression); + this.state = 6913; + if (!(this.precpred(this.context, 3))) { + throw this.createFailedPredicateException("this.precpred(this.context, 3)"); + } + this.state = 6914; + (localContext as ArithmeticBinaryContext)._operator = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 134234624) !== 0))) { + (localContext as ArithmeticBinaryContext)._operator = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6915; + (localContext as ArithmeticBinaryContext)._right = this.valueExpression(4); + } + break; + case 2: + { + localContext = new ArithmeticBinaryContext(new ValueExpressionContext(parentContext, parentState)); + (localContext as ArithmeticBinaryContext)._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_valueExpression); + this.state = 6916; + if (!(this.precpred(this.context, 2))) { + throw this.createFailedPredicateException("this.precpred(this.context, 2)"); + } + this.state = 6917; + (localContext as ArithmeticBinaryContext)._operator = this.tokenStream.LT(1); + _la = this.tokenStream.LA(1); + if(!(_la === 12 || _la === 13)) { + (localContext as ArithmeticBinaryContext)._operator = this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6918; + (localContext as ArithmeticBinaryContext)._right = this.valueExpression(3); + } + break; + case 3: + { + localContext = new ConcatenationContext(new ValueExpressionContext(parentContext, parentState)); + (localContext as ConcatenationContext)._left = previousContext; + this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_valueExpression); + this.state = 6919; + if (!(this.precpred(this.context, 1))) { + throw this.createFailedPredicateException("this.precpred(this.context, 1)"); + } + this.state = 6920; + this.match(PostgreSqlParser.CARET); + this.state = 6921; + (localContext as ConcatenationContext)._right = this.valueExpression(2); + } + break; + case 4: + { + localContext = new AtTimeZoneContext(new ValueExpressionContext(parentContext, parentState)); + this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_valueExpression); + this.state = 6922; + if (!(this.precpred(this.context, 5))) { + throw this.createFailedPredicateException("this.precpred(this.context, 5)"); + } + this.state = 6923; + this.match(PostgreSqlParser.KW_AT); + this.state = 6924; + this.match(PostgreSqlParser.KW_TIME); + this.state = 6925; + this.match(PostgreSqlParser.KW_ZONE); + this.state = 6926; + this.expression(); + } + break; } } } - this.state = 9073; + this.state = 6931; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 902, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 949, this.context); } } } @@ -45302,321 +42220,493 @@ export class PostgreSqlParser extends SQLParserBase { } } finally { - this.exitRule(); + this.unrollRecursionContexts(parentContext); } return localContext; } - public table_ref(): Table_refContext { - let localContext = new Table_refContext(this.context, this.state); - this.enterRule(localContext, 1106, PostgreSqlParser.RULE_table_ref); + + public primaryExpression(): PrimaryExpressionContext; + public primaryExpression(_p: number): PrimaryExpressionContext; + public primaryExpression(_p?: number): PrimaryExpressionContext { + if (_p === undefined) { + _p = 0; + } + + let parentContext = this.context; + let parentState = this.state; + let localContext = new PrimaryExpressionContext(this.context, parentState); + let previousContext = localContext; + let _startState = 682; + this.enterRecursionRule(localContext, 682, PostgreSqlParser.RULE_primaryExpression, _p); let _la: number; try { let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 9135; + this.state = 7020; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 917, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 960, this.context) ) { case 1: { - this.state = 9076; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 903, this.context) ) { - case 1: - { - this.state = 9074; - this.relation_expr(); - } - break; - case 2: - { - this.state = 9075; - this.view_relation_expr(); - } - break; - } - this.state = 9079; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 904, this.context) ) { - case 1: - { - this.state = 9078; - this.opt_alias_clause(); - } - break; - } - this.state = 9082; - this.errorHandler.sync(this); + this.state = 6933; _la = this.tokenStream.LA(1); - if (_la === 472) { - { - this.state = 9081; - this.tablesample_clause(); - } + if(!(_la === 98 || _la === 396)) { + this.errorHandler.recoverInline(this); } - + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 6934; + this.select_with_parens(); } break; case 2: { - this.state = 9084; - this.func_table(); - this.state = 9086; + this.state = 6935; + this.match(PostgreSqlParser.KW_ARRAY); + this.state = 6938; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 906, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.OPEN_PAREN: + { + this.state = 6936; + this.select_with_parens(); + } + break; + case PostgreSqlParser.OPEN_BRACKET: { - this.state = 9085; - this.func_alias_clause(); + this.state = 6937; + this.array_expr(); } break; + default: + throw new antlr.NoViableAltException(this); } } break; case 3: { - this.state = 9088; - this.xmltable(); - this.state = 9090; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 907, this.context) ) { - case 1: - { - this.state = 9089; - this.opt_alias_clause(); - } - break; - } + this.state = 6940; + this.match(PostgreSqlParser.PARAM); + this.state = 6941; + this.opt_indirection(); } break; case 4: { - this.state = 9092; - this.select_with_parens(); - this.state = 9094; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 908, this.context) ) { - case 1: - { - this.state = 9093; - this.opt_alias_clause(); - } - break; - } + this.state = 6942; + this.match(PostgreSqlParser.KW_GROUPING); + this.state = 6943; + this.execute_param_clause(); } break; case 5: { - this.state = 9096; - this.match(PostgreSqlParser.KW_LATERAL); - this.state = 9109; + this.state = 6944; + this.match(PostgreSqlParser.Integral); + } + break; + case 6: + { + this.state = 6945; + this.match(PostgreSqlParser.Numeric); + } + break; + case 7: + { + this.state = 6946; + this.match(PostgreSqlParser.BinaryStringConstant); + } + break; + case 8: + { + this.state = 6947; + this.match(PostgreSqlParser.HexadecimalStringConstant); + } + break; + case 9: + { + this.state = 6948; + this.function_name(); + this.state = 6958; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 912, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.EscapeStringConstant: { - this.state = 9097; - this.xmltable(); - this.state = 9099; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 909, this.context) ) { - case 1: - { - this.state = 9098; - this.opt_alias_clause(); - } - break; - } + this.state = 6949; + this.sconst(); } break; - case 2: + case PostgreSqlParser.OPEN_PAREN: { - this.state = 9101; - this.func_table(); - this.state = 9103; + this.state = 6950; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 6951; + this.func_arg_list(); + this.state = 6953; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 910, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 83) { { - this.state = 9102; - this.func_alias_clause(); + this.state = 6952; + this.sort_clause(); } - break; } + + this.state = 6955; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6956; + this.sconst(); } break; - case 3: - { - this.state = 9105; - this.select_with_parens(); - this.state = 9107; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 911, this.context) ) { - case 1: - { - this.state = 9106; - this.opt_alias_clause(); + default: + throw new antlr.NoViableAltException(this); + } + } + break; + case 10: + { + this.state = 6961; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 190 || ((((_la - 388)) & ~0x1F) === 0 && ((1 << (_la - 388)) & 3525731551) !== 0) || _la === 423) { + { + this.state = 6960; + this.consttypename(); + } + } + + this.state = 6963; + this.sconst(); + } + break; + case 11: + { + this.state = 6964; + this.match(PostgreSqlParser.KW_INTERVAL); + this.state = 6972; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 6965; + this.sconst(); + this.state = 6967; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 954, this.context) ) { + case 1: + { + this.state = 6966; + this.opt_interval(); } break; } } break; + case PostgreSqlParser.OPEN_PAREN: + { + this.state = 6969; + this.opt_float(); + this.state = 6970; + this.sconst(); + } + break; + default: + throw new antlr.NoViableAltException(this); } } break; - case 6: + case 12: + { + this.state = 6974; + this.match(PostgreSqlParser.KW_TRUE); + } + break; + case 13: + { + this.state = 6975; + this.match(PostgreSqlParser.KW_FALSE); + } + break; + case 14: + { + this.state = 6976; + this.match(PostgreSqlParser.KW_NULL); + } + break; + case 15: + { + this.state = 6977; + this.match(PostgreSqlParser.PLSQLVARIABLENAME); + } + break; + case 16: { - this.state = 9111; + this.state = 6978; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9112; - this.table_ref(); - this.state = 9129; + this.state = 6979; + localContext._a_expr_in_parens = this.expression(); + this.state = 6980; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 6981; + this.opt_indirection(); + } + break; + case 17: + { + this.state = 6983; + this.match(PostgreSqlParser.KW_CASE); + this.state = 6985; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_CROSS: + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { { - this.state = 9113; - this.match(PostgreSqlParser.KW_CROSS); - this.state = 9114; - this.match(PostgreSqlParser.KW_JOIN); - this.state = 9115; - this.table_ref(); + this.state = 6984; + this.expression(); } - break; - case PostgreSqlParser.KW_NATURAL: + } + + this.state = 6988; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { { - this.state = 9116; - this.match(PostgreSqlParser.KW_NATURAL); - this.state = 9118; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & 8261) !== 0)) { - { - this.state = 9117; - this.join_type(); - } + { + this.state = 6987; + this.when_clause(); } - - this.state = 9120; - this.match(PostgreSqlParser.KW_JOIN); - this.state = 9121; - this.table_ref(); } - break; - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_RIGHT: - { - this.state = 9123; + this.state = 6990; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & 8261) !== 0)) { - { - this.state = 9122; - this.join_type(); - } + } while (_la === 102); + this.state = 6994; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 58) { + { + this.state = 6992; + this.match(PostgreSqlParser.KW_ELSE); + this.state = 6993; + this.expression(); } + } - this.state = 9125; - this.match(PostgreSqlParser.KW_JOIN); - this.state = 9126; - this.table_ref(); - this.state = 9127; - this.join_qual(); - } - break; - case PostgreSqlParser.CLOSE_PAREN: - break; - default: - break; + this.state = 6996; + this.match(PostgreSqlParser.KW_END); } - this.state = 9131; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 9133; + break; + case 18: + { + this.state = 6998; + this.func_expr(); + } + break; + case 19: + { + this.state = 6999; + this.select_with_parens(); + this.state = 7001; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 916, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 959, this.context) ) { case 1: { - this.state = 9132; - this.opt_alias_clause(); + this.state = 7000; + this.indirection(); } break; } } break; + case 20: + { + this.state = 7003; + this.explicit_row(); + } + break; + case 21: + { + this.state = 7004; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7005; + this.expression(); + this.state = 7006; + this.match(PostgreSqlParser.COMMA); + this.state = 7007; + this.expr_list(); + this.state = 7008; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case 22: + { + this.state = 7010; + this.row(); + this.state = 7011; + this.match(PostgreSqlParser.KW_OVERLAPS); + this.state = 7012; + this.row(); + } + break; + case 23: + { + this.state = 7014; + this.qualified_name(); + } + break; + case 24: + { + this.state = 7015; + _la = this.tokenStream.LA(1); + if(!(_la === 12 || _la === 13)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 7016; + this.primaryExpression(5); + } + break; + case 25: + { + this.state = 7017; + this.qual_op(); + this.state = 7018; + this.primaryExpression(2); + } + break; } - this.state = 9155; + this.context!.stop = this.tokenStream.LT(-1); + this.state = 7049; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 921, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 965, this.context); while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { if (alternative === 1) { + if (this._parseListeners != null) { + this.triggerExitRuleEvent(); + } + previousContext = localContext; { - this.state = 9153; + this.state = 7047; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_CROSS: + switch (this.interpreter.adaptivePredict(this.tokenStream, 964, this.context) ) { + case 1: { - this.state = 9137; - this.match(PostgreSqlParser.KW_CROSS); - this.state = 9138; - this.match(PostgreSqlParser.KW_JOIN); - this.state = 9139; - this.table_ref(); + localContext = new PrimaryExpressionContext(parentContext, parentState); + this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_primaryExpression); + this.state = 7022; + if (!(this.precpred(this.context, 3))) { + throw this.createFailedPredicateException("this.precpred(this.context, 3)"); + } + this.state = 7023; + this.mathop(); + this.state = 7024; + this.primaryExpression(4); } break; - case PostgreSqlParser.KW_NATURAL: + case 2: { - this.state = 9140; - this.match(PostgreSqlParser.KW_NATURAL); - this.state = 9142; + localContext = new PrimaryExpressionContext(parentContext, parentState); + this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_primaryExpression); + this.state = 7026; + if (!(this.precpred(this.context, 6))) { + throw this.createFailedPredicateException("this.precpred(this.context, 6)"); + } + this.state = 7027; + this.match(PostgreSqlParser.TYPECAST); + this.state = 7028; + this.typename(); + } + break; + case 3: + { + localContext = new PrimaryExpressionContext(parentContext, parentState); + this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_primaryExpression); + this.state = 7029; + if (!(this.precpred(this.context, 4))) { + throw this.createFailedPredicateException("this.precpred(this.context, 4)"); + } + this.state = 7030; + this.qual_op(); + this.state = 7032; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & 8261) !== 0)) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 961, this.context) ) { + case 1: { - this.state = 9141; - this.join_type(); + this.state = 7031; + this.primaryExpression(0); } + break; } - - this.state = 9144; - this.match(PostgreSqlParser.KW_JOIN); - this.state = 9145; - this.table_ref(); } break; - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_RIGHT: + case 4: { - this.state = 9147; + localContext = new PrimaryExpressionContext(parentContext, parentState); + this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_primaryExpression); + this.state = 7034; + if (!(this.precpred(this.context, 1))) { + throw this.createFailedPredicateException("this.precpred(this.context, 1)"); + } + this.state = 7035; + this.match(PostgreSqlParser.KW_IS); + this.state = 7037; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & 8261) !== 0)) { + if (_la === 77) { { - this.state = 9146; - this.join_type(); + this.state = 7036; + this.match(PostgreSqlParser.KW_NOT); } } - this.state = 9149; - this.match(PostgreSqlParser.KW_JOIN); - this.state = 9150; - this.table_ref(); - this.state = 9151; - this.join_qual(); + this.state = 7045; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_DISTINCT: + { + this.state = 7039; + this.match(PostgreSqlParser.KW_DISTINCT); + this.state = 7040; + this.match(PostgreSqlParser.KW_FROM); + this.state = 7041; + this.primaryExpression(0); + } + break; + case PostgreSqlParser.KW_OF: + { + this.state = 7042; + this.match(PostgreSqlParser.KW_OF); + this.state = 7043; + this.prep_type_clause(); + } + break; + case PostgreSqlParser.KW_DOCUMENT: + { + this.state = 7044; + this.match(PostgreSqlParser.KW_DOCUMENT); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } break; - default: - throw new antlr.NoViableAltException(this); } } } - this.state = 9157; + this.state = 7051; this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 921, this.context); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 965, this.context); } } } @@ -45630,130 +42720,81 @@ export class PostgreSqlParser extends SQLParserBase { } } finally { - this.exitRule(); + this.unrollRecursionContexts(parentContext); } return localContext; } - public alias_clause(): Alias_clauseContext { - let localContext = new Alias_clauseContext(this.context, this.state); - this.enterRule(localContext, 1108, PostgreSqlParser.RULE_alias_clause); + public func_application(): Func_applicationContext { + let localContext = new Func_applicationContext(this.context, this.state); + this.enterRule(localContext, 684, PostgreSqlParser.RULE_func_application); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 9159; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 36) { - { - this.state = 9158; - this.match(PostgreSqlParser.KW_AS); - } - } - - this.state = 9161; - this.colid(); - this.state = 9166; + this.state = 7052; + this.function_name(); + this.state = 7078; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 923, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 971, this.context) ) { case 1: { - this.state = 9162; + this.state = 7053; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9163; - this.name_list(); - this.state = 9164; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_alias_clause(): Opt_alias_clauseContext { - let localContext = new Opt_alias_clauseContext(this.context, this.state); - this.enterRule(localContext, 1110, PostgreSqlParser.RULE_opt_alias_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9168; - this.alias_clause(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public func_alias_clause(): Func_alias_clauseContext { - let localContext = new Func_alias_clauseContext(this.context, this.state); - this.enterRule(localContext, 1112, PostgreSqlParser.RULE_func_alias_clause); - let _la: number; - try { - this.state = 9182; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 926, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 9170; - this.alias_clause(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 9176; + this.state = 7075; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AS: - { - this.state = 9171; - this.match(PostgreSqlParser.KW_AS); - this.state = 9173; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { - { - this.state = 9172; - this.colid(); - } - } - - } - break; + case PostgreSqlParser.OPEN_PAREN: + case PostgreSqlParser.PLUS: + case PostgreSqlParser.MINUS: + case PostgreSqlParser.PARAM: + case PostgreSqlParser.Operator: case PostgreSqlParser.KW_AND: case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_CASE: + case PostgreSqlParser.KW_CAST: case PostgreSqlParser.KW_COLLATE: case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_CURRENT_CATALOG: + case PostgreSqlParser.KW_CURRENT_DATE: + case PostgreSqlParser.KW_CURRENT_ROLE: + case PostgreSqlParser.KW_CURRENT_TIME: + case PostgreSqlParser.KW_CURRENT_TIMESTAMP: + case PostgreSqlParser.KW_CURRENT_USER: case PostgreSqlParser.KW_DEFAULT: case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FALSE: case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_LOCALTIME: + case PostgreSqlParser.KW_LOCALTIMESTAMP: + case PostgreSqlParser.KW_NOT: + case PostgreSqlParser.KW_NULL: + case PostgreSqlParser.KW_SESSION_USER: + case PostgreSqlParser.KW_TRUE: + case PostgreSqlParser.KW_UNIQUE: + case PostgreSqlParser.KW_USER: + case PostgreSqlParser.KW_AUTHORIZATION: + case PostgreSqlParser.KW_BINARY: + case PostgreSqlParser.KW_COLLATION: + case PostgreSqlParser.KW_CONCURRENTLY: + case PostgreSqlParser.KW_CROSS: + case PostgreSqlParser.KW_CURRENT_SCHEMA: + case PostgreSqlParser.KW_FREEZE: + case PostgreSqlParser.KW_FULL: + case PostgreSqlParser.KW_ILIKE: + case PostgreSqlParser.KW_INNER: case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_ISNULL: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_LIKE: + case PostgreSqlParser.KW_NATURAL: + case PostgreSqlParser.KW_NOTNULL: case PostgreSqlParser.KW_OUTER: case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_OVERLAPS: + case PostgreSqlParser.KW_RIGHT: + case PostgreSqlParser.KW_SIMILAR: + case PostgreSqlParser.KW_VERBOSE: case PostgreSqlParser.KW_ABORT: case PostgreSqlParser.KW_ABSOLUTE: case PostgreSqlParser.KW_ACCESS: @@ -46087,6 +43128,7 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.KW_CUBE: case PostgreSqlParser.KW_GROUPING: case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_TABLESAMPLE: case PostgreSqlParser.KW_ORDINALITY: case PostgreSqlParser.KW_XMLTABLE: case PostgreSqlParser.KW_COLUMNS: @@ -46140,67 +43182,105 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.StringConstant: case PostgreSqlParser.UnicodeEscapeStringConstant: case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.BinaryStringConstant: + case PostgreSqlParser.HexadecimalStringConstant: + case PostgreSqlParser.Integral: + case PostgreSqlParser.Numeric: case PostgreSqlParser.PLSQLVARIABLENAME: case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 9175; - this.colid(); + this.state = 7054; + this.func_arg_list(); + this.state = 7058; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 6) { + { + this.state = 7055; + this.match(PostgreSqlParser.COMMA); + this.state = 7056; + this.match(PostgreSqlParser.KW_VARIADIC); + this.state = 7057; + this.func_arg_expr(); + } + } + + this.state = 7061; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 83) { + { + this.state = 7060; + this.sort_clause(); + } + } + + } + break; + case PostgreSqlParser.KW_VARIADIC: + { + this.state = 7063; + this.match(PostgreSqlParser.KW_VARIADIC); + this.state = 7064; + this.func_arg_expr(); + this.state = 7066; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 83) { + { + this.state = 7065; + this.sort_clause(); + } + } + + } + break; + case PostgreSqlParser.KW_ALL: + case PostgreSqlParser.KW_DISTINCT: + { + this.state = 7068; + _la = this.tokenStream.LA(1); + if(!(_la === 30 || _la === 56)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 7069; + this.func_arg_list(); + this.state = 7071; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 83) { + { + this.state = 7070; + this.sort_clause(); + } + } + + } + break; + case PostgreSqlParser.STAR: + { + this.state = 7073; + this.match(PostgreSqlParser.STAR); + } + break; + case PostgreSqlParser.CLOSE_PAREN: + // tslint:disable-next-line:no-empty + { } break; default: throw new antlr.NoViableAltException(this); } - this.state = 9178; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9179; - this.tablefuncelementlist(); - this.state = 9180; + this.state = 7077; this.match(PostgreSqlParser.CLOSE_PAREN); } break; } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public join_type(): Join_typeContext { - let localContext = new Join_typeContext(this.context, this.state); - this.enterRule(localContext, 1114, PostgreSqlParser.RULE_join_type); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9184; - _la = this.tokenStream.LA(1); - if(!(((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & 8261) !== 0))) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9186; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 123) { - { - this.state = 9185; - this.match(PostgreSqlParser.KW_OUTER); - } - } - } } catch (re) { @@ -46217,37 +43297,489 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public join_qual(): Join_qualContext { - let localContext = new Join_qualContext(this.context, this.state); - this.enterRule(localContext, 1116, PostgreSqlParser.RULE_join_qual); + public func_expr(): Func_exprContext { + let localContext = new Func_exprContext(this.context, this.state); + this.enterRule(localContext, 686, PostgreSqlParser.RULE_func_expr); try { - this.state = 9195; + this.state = 7105; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_USING: + switch (this.interpreter.adaptivePredict(this.tokenStream, 976, this.context) ) { + case 1: this.enterOuterAlt(localContext, 1); { - this.state = 9188; - this.match(PostgreSqlParser.KW_USING); - this.state = 9189; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9190; - this.column_list(); - this.state = 9191; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 7080; + this.func_application(); + this.state = 7087; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 972, this.context) ) { + case 1: + { + this.state = 7081; + this.match(PostgreSqlParser.KW_WITHIN); + this.state = 7082; + this.match(PostgreSqlParser.KW_GROUP); + this.state = 7083; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7084; + this.sort_clause(); + this.state = 7085; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + } + this.state = 7095; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 973, this.context) ) { + case 1: + { + this.state = 7089; + this.match(PostgreSqlParser.KW_FILTER); + this.state = 7090; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7091; + this.match(PostgreSqlParser.KW_WHERE); + this.state = 7092; + this.expression(); + this.state = 7093; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + } + this.state = 7102; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 975, this.context) ) { + case 1: + { + this.state = 7097; + this.match(PostgreSqlParser.KW_OVER); + this.state = 7100; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.OPEN_PAREN: + { + this.state = 7098; + this.window_specification(); + } + break; + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 7099; + this.colid(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + } } break; - case PostgreSqlParser.KW_ON: + case 2: this.enterOuterAlt(localContext, 2); { - this.state = 9193; - this.match(PostgreSqlParser.KW_ON); - this.state = 9194; - this.a_expr(); + this.state = 7104; + this.func_expr_common_subexpr(); } break; - default: - throw new antlr.NoViableAltException(this); } } catch (re) { @@ -46264,893 +43796,668 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public relation_expr(): Relation_exprContext { - let localContext = new Relation_exprContext(this.context, this.state); - this.enterRule(localContext, 1118, PostgreSqlParser.RULE_relation_expr); - let _la: number; + public func_expr_windowless(): Func_expr_windowlessContext { + let localContext = new Func_expr_windowlessContext(this.context, this.state); + this.enterRule(localContext, 688, PostgreSqlParser.RULE_func_expr_windowless); try { - this.state = 9218; + this.state = 7109; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 933, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 977, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 9198; + this.state = 7107; + this.func_application(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 7108; + this.func_expr_common_subexpr(); + } + break; + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public func_expr_common_subexpr(): Func_expr_common_subexprContext { + let localContext = new Func_expr_common_subexprContext(this.context, this.state); + this.enterRule(localContext, 690, PostgreSqlParser.RULE_func_expr_common_subexpr); + let _la: number; + try { + this.state = 7285; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_COLLATION: + this.enterOuterAlt(localContext, 1); + { + this.state = 7111; + this.match(PostgreSqlParser.KW_COLLATION); + this.state = 7112; + this.match(PostgreSqlParser.KW_FOR); + this.state = 7113; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7114; + this.expression(); + this.state = 7115; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_CURRENT_DATE: + this.enterOuterAlt(localContext, 2); + { + this.state = 7117; + this.match(PostgreSqlParser.KW_CURRENT_DATE); + } + break; + case PostgreSqlParser.KW_CURRENT_TIME: + case PostgreSqlParser.KW_CURRENT_TIMESTAMP: + case PostgreSqlParser.KW_LOCALTIME: + case PostgreSqlParser.KW_LOCALTIMESTAMP: + this.enterOuterAlt(localContext, 3); + { + this.state = 7118; + _la = this.tokenStream.LA(1); + if(!(((((_la - 50)) & ~0x1F) === 0 && ((1 << (_la - 50)) & 100663299) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 7120; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 978, this.context) ) { + case 1: + { + this.state = 7119; + this.opt_float(); + } + break; + } + } + break; + case PostgreSqlParser.KW_CURRENT_ROLE: + this.enterOuterAlt(localContext, 4); + { + this.state = 7122; + this.match(PostgreSqlParser.KW_CURRENT_ROLE); + } + break; + case PostgreSqlParser.KW_CURRENT_USER: + this.enterOuterAlt(localContext, 5); + { + this.state = 7123; + this.match(PostgreSqlParser.KW_CURRENT_USER); + } + break; + case PostgreSqlParser.KW_SESSION_USER: + this.enterOuterAlt(localContext, 6); + { + this.state = 7124; + this.match(PostgreSqlParser.KW_SESSION_USER); + } + break; + case PostgreSqlParser.KW_USER: + this.enterOuterAlt(localContext, 7); + { + this.state = 7125; + this.match(PostgreSqlParser.KW_USER); + } + break; + case PostgreSqlParser.KW_CURRENT_CATALOG: + this.enterOuterAlt(localContext, 8); + { + this.state = 7126; + this.match(PostgreSqlParser.KW_CURRENT_CATALOG); + } + break; + case PostgreSqlParser.KW_CURRENT_SCHEMA: + this.enterOuterAlt(localContext, 9); + { + this.state = 7127; + this.match(PostgreSqlParser.KW_CURRENT_SCHEMA); + } + break; + case PostgreSqlParser.KW_CAST: + case PostgreSqlParser.KW_TREAT: + this.enterOuterAlt(localContext, 10); + { + this.state = 7128; + _la = this.tokenStream.LA(1); + if(!(_la === 41 || _la === 420)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 7129; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7130; + this.expression(); + this.state = 7131; + this.match(PostgreSqlParser.KW_AS); + this.state = 7132; + this.typename(); + this.state = 7133; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_EXTRACT: + this.enterOuterAlt(localContext, 11); + { + this.state = 7135; + this.match(PostgreSqlParser.KW_EXTRACT); + this.state = 7136; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7141; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 81) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 268451969) !== 0) || ((((_la - 153)) & ~0x1F) === 0 && ((1 << (_la - 153)) & 8929553) !== 0) || ((((_la - 207)) & ~0x1F) === 0 && ((1 << (_la - 207)) & 2057) !== 0) || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & 428867841) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & 268451841) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & 1059905) !== 0) || _la === 360 || _la === 384 || _la === 433 || _la === 434 || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & 3959414785) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & 3071) !== 0) || ((((_la - 549)) & ~0x1F) === 0 && ((1 << (_la - 549)) & 100674083) !== 0) || _la === 584) { { - this.state = 9197; - this.match(PostgreSqlParser.KW_ONLY); + this.state = 7137; + this.extract_arg(); + this.state = 7138; + this.match(PostgreSqlParser.KW_FROM); + this.state = 7139; + this.expression(); } } - this.state = 9200; - this.table_name(); - this.state = 9202; + this.state = 7143; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_NORMALIZE: + this.enterOuterAlt(localContext, 12); + { + this.state = 7144; + this.match(PostgreSqlParser.KW_NORMALIZE); + this.state = 7145; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7146; + this.expression(); + this.state = 7149; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 9) { + if (_la === 6) { { - this.state = 9201; - this.match(PostgreSqlParser.STAR); + this.state = 7147; + this.match(PostgreSqlParser.COMMA); + this.state = 7148; + this.unicode_normal_form(); } } + this.state = 7151; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; - case 2: - this.enterOuterAlt(localContext, 2); + case PostgreSqlParser.KW_OVERLAY: + this.enterOuterAlt(localContext, 13); { - this.state = 9204; - this.match(PostgreSqlParser.KW_ONLY); - this.state = 9210; + this.state = 7153; + this.match(PostgreSqlParser.KW_OVERLAY); + this.state = 7154; + this.match(PostgreSqlParser.OPEN_PAREN); + { + this.state = 7155; + this.expression(); + this.state = 7156; + this.match(PostgreSqlParser.KW_PLACING); + this.state = 7157; + this.expression(); + this.state = 7158; + this.match(PostgreSqlParser.KW_FROM); + this.state = 7159; + this.expression(); + this.state = 7162; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: + _la = this.tokenStream.LA(1); + if (_la === 62) { { - this.state = 9205; - this.table_name(); + this.state = 7160; + this.match(PostgreSqlParser.KW_FOR); + this.state = 7161; + this.expression(); + } + } + + } + this.state = 7164; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_POSITION: + this.enterOuterAlt(localContext, 14); + { + this.state = 7166; + this.match(PostgreSqlParser.KW_POSITION); + this.state = 7167; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7172; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763019) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { + { + this.state = 7168; + this.primaryExpression(0); + this.state = 7169; + this.match(PostgreSqlParser.KW_IN); + this.state = 7170; + this.primaryExpression(0); + } + } + + this.state = 7174; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_SUBSTRING: + this.enterOuterAlt(localContext, 15); + { + this.state = 7175; + this.match(PostgreSqlParser.KW_SUBSTRING); + this.state = 7176; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7178; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { + { + this.state = 7177; + this.substr_list(); + } + } + + this.state = 7180; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_TRIM: + this.enterOuterAlt(localContext, 16); + { + this.state = 7181; + this.match(PostgreSqlParser.KW_TRIM); + this.state = 7182; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7184; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 39 || _la === 73 || _la === 95) { + { + this.state = 7183; + _la = this.tokenStream.LA(1); + if(!(_la === 39 || _la === 73 || _la === 95)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + + { + this.state = 7190; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 986, this.context) ) { + case 1: + { + this.state = 7187; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { + { + this.state = 7186; + this.expression(); + } + } + + this.state = 7189; + this.match(PostgreSqlParser.KW_FROM); } break; - case PostgreSqlParser.OPEN_PAREN: + } + this.state = 7192; + this.expr_list(); + } + this.state = 7194; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_NULLIF: + this.enterOuterAlt(localContext, 17); + { + this.state = 7196; + this.match(PostgreSqlParser.KW_NULLIF); + this.state = 7197; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7198; + this.expression(); + this.state = 7199; + this.match(PostgreSqlParser.COMMA); + this.state = 7200; + this.expression(); + this.state = 7201; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_XMLCONCAT: + this.enterOuterAlt(localContext, 18); + { + this.state = 7203; + _la = this.tokenStream.LA(1); + if(!(((((_la - 393)) & ~0x1F) === 0 && ((1 << (_la - 393)) & 2113) !== 0) || _la === 425)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 7204; + this.execute_param_clause(); + } + break; + case PostgreSqlParser.KW_XMLELEMENT: + this.enterOuterAlt(localContext, 19); + { + this.state = 7205; + this.match(PostgreSqlParser.KW_XMLELEMENT); + this.state = 7206; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7207; + this.match(PostgreSqlParser.KW_NAME); + this.state = 7208; + this.collabel(); + this.state = 7218; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 6) { { - this.state = 9206; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9207; - this.table_name(); - this.state = 9208; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 7209; + this.match(PostgreSqlParser.COMMA); + this.state = 7216; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 987, this.context) ) { + case 1: + { + { + this.state = 7210; + this.match(PostgreSqlParser.KW_XMLATTRIBUTES); + this.state = 7211; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7212; + this.xml_attribute_list(); + this.state = 7213; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + } + break; + case 2: + { + this.state = 7215; + this.expr_list(); + } + break; + } + } + } + + this.state = 7220; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_XMLEXISTS: + this.enterOuterAlt(localContext, 20); + { + this.state = 7222; + this.match(PostgreSqlParser.KW_XMLEXISTS); + this.state = 7223; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7224; + this.primaryExpression(0); + this.state = 7225; + this.xmlexists_argument(); + this.state = 7226; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_XMLFOREST: + this.enterOuterAlt(localContext, 21); + { + this.state = 7228; + this.match(PostgreSqlParser.KW_XMLFOREST); + this.state = 7229; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7230; + this.xml_attribute_list(); + this.state = 7231; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_XMLPARSE: + this.enterOuterAlt(localContext, 22); + { + this.state = 7233; + this.match(PostgreSqlParser.KW_XMLPARSE); + this.state = 7234; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7235; + this.document_or_content(); + this.state = 7236; + this.expression(); + this.state = 7239; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 292 || _la === 347) { + { + this.state = 7237; + _la = this.tokenStream.LA(1); + if(!(_la === 292 || _la === 347)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 7238; + this.match(PostgreSqlParser.KW_WHITESPACE); + } + } + + this.state = 7241; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_XMLPI: + this.enterOuterAlt(localContext, 23); + { + this.state = 7243; + this.match(PostgreSqlParser.KW_XMLPI); + this.state = 7244; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7245; + this.match(PostgreSqlParser.KW_NAME); + this.state = 7246; + this.collabel(); + this.state = 7249; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 6) { + { + this.state = 7247; + this.match(PostgreSqlParser.COMMA); + this.state = 7248; + this.expression(); + } + } + + this.state = 7251; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_XMLROOT: + this.enterOuterAlt(localContext, 24); + { + this.state = 7253; + this.match(PostgreSqlParser.KW_XMLROOT); + this.state = 7254; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7255; + this.match(PostgreSqlParser.KW_XML); + this.state = 7256; + this.expression(); + this.state = 7257; + this.match(PostgreSqlParser.COMMA); + this.state = 7258; + this.match(PostgreSqlParser.KW_VERSION); + this.state = 7262; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 991, this.context) ) { + case 1: + { + { + this.state = 7259; + this.match(PostgreSqlParser.KW_NO); + this.state = 7260; + this.match(PostgreSqlParser.KW_VALUE); + } } break; - default: - throw new antlr.NoViableAltException(this); + case 2: + { + this.state = 7261; + this.expression(); + } + break; + } + this.state = 7273; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 6) { + { + this.state = 7264; + this.match(PostgreSqlParser.COMMA); + this.state = 7265; + this.match(PostgreSqlParser.KW_STANDALONE); + this.state = 7271; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_VALUE: + { + { + this.state = 7267; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269) { + { + this.state = 7266; + this.match(PostgreSqlParser.KW_NO); + } + } + + this.state = 7269; + this.match(PostgreSqlParser.KW_VALUE); + } + } + break; + case PostgreSqlParser.KW_YES: + { + this.state = 7270; + this.match(PostgreSqlParser.KW_YES); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } } + + this.state = 7275; + this.match(PostgreSqlParser.CLOSE_PAREN); } break; - case 3: - this.enterOuterAlt(localContext, 3); + case PostgreSqlParser.KW_XMLSERIALIZE: + this.enterOuterAlt(localContext, 25); { - this.state = 9212; - this.match(PostgreSqlParser.KW_IN); - this.state = 9213; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 9216; + this.state = 7277; + this.match(PostgreSqlParser.KW_XMLSERIALIZE); + this.state = 7278; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7279; + this.document_or_content(); + this.state = 7280; + this.expression(); + this.state = 7281; + this.match(PostgreSqlParser.KW_AS); + this.state = 7282; + this.simpletypename(); + this.state = 7283; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public xml_attribute_list(): Xml_attribute_listContext { + let localContext = new Xml_attribute_listContext(this.context, this.state); + this.enterRule(localContext, 692, PostgreSqlParser.RULE_xml_attribute_list); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7287; + this.xml_attribute_el(); + this.state = 7292; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 7288; + this.match(PostgreSqlParser.COMMA); + this.state = 7289; + this.xml_attribute_el(); + } + } + this.state = 7294; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - { - this.state = 9214; - this.schema_name(); - } - break; - case PostgreSqlParser.KW_CURRENT_SCHEMA: - { - this.state = 9215; - this.match(PostgreSqlParser.KW_CURRENT_SCHEMA); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; + _la = this.tokenStream.LA(1); + } } } catch (re) { @@ -47167,55 +44474,106 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public view_relation_expr(): View_relation_exprContext { - let localContext = new View_relation_exprContext(this.context, this.state); - this.enterRule(localContext, 1120, PostgreSqlParser.RULE_view_relation_expr); + public xml_attribute_el(): Xml_attribute_elContext { + let localContext = new Xml_attribute_elContext(this.context, this.state); + this.enterRule(localContext, 694, PostgreSqlParser.RULE_xml_attribute_el); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 9221; + this.state = 7295; + this.expression(); + this.state = 7298; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (_la === 81) { + if (_la === 36) { { - this.state = 9220; - this.match(PostgreSqlParser.KW_ONLY); + this.state = 7296; + this.match(PostgreSqlParser.KW_AS); + this.state = 7297; + this.collabel(); } } - this.state = 9223; - this.view_name(); - this.state = 9225; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 935, this.context) ) { - case 1: - { - this.state = 9224; - this.match(PostgreSqlParser.STAR); - } - break; } - this.state = 9228; + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public document_or_content(): Document_or_contentContext { + let localContext = new Document_or_contentContext(this.context, this.state); + this.enterRule(localContext, 696, PostgreSqlParser.RULE_document_or_content); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7300; + _la = this.tokenStream.LA(1); + if(!(_la === 166 || _la === 188)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public xmlexists_argument(): Xmlexists_argumentContext { + let localContext = new Xmlexists_argumentContext(this.context, this.state); + this.enterRule(localContext, 698, PostgreSqlParser.RULE_xmlexists_argument); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7302; + this.match(PostgreSqlParser.KW_PASSING); + this.state = 7304; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 936, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 998, this.context) ) { case 1: { - this.state = 9227; - this.column_list(); + this.state = 7303; + this.xml_passing_mech(); } break; } - this.state = 9231; + this.state = 7306; + this.primaryExpression(0); + this.state = 7308; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 937, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 147) { { - this.state = 9230; - this.where_clause(); + this.state = 7307; + this.xml_passing_mech(); } - break; } + } } catch (re) { @@ -47232,921 +44590,763 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public publication_relation_expr(): Publication_relation_exprContext { - let localContext = new Publication_relation_exprContext(this.context, this.state); - this.enterRule(localContext, 1122, PostgreSqlParser.RULE_publication_relation_expr); + public xml_passing_mech(): Xml_passing_mechContext { + let localContext = new Xml_passing_mechContext(this.context, this.state); + this.enterRule(localContext, 700, PostgreSqlParser.RULE_xml_passing_mech); let _la: number; try { - this.state = 9266; + this.enterOuterAlt(localContext, 1); + { + this.state = 7310; + this.match(PostgreSqlParser.KW_BY); + this.state = 7311; + _la = this.tokenStream.LA(1); + if(!(_la === 304 || _la === 450)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public window_clause(): Window_clauseContext { + let localContext = new Window_clauseContext(this.context, this.state); + this.enterRule(localContext, 702, PostgreSqlParser.RULE_window_clause); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 7313; + this.match(PostgreSqlParser.KW_WINDOW); + this.state = 7314; + this.window_definition(); + this.state = 7319; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 944, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 9233; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 9235; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 81) { + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1000, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { { - this.state = 9234; - this.match(PostgreSqlParser.KW_ONLY); + { + this.state = 7315; + this.match(PostgreSqlParser.COMMA); + this.state = 7316; + this.window_definition(); + } } } - - this.state = 9237; - this.table_name(); - this.state = 9239; + this.state = 7321; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 9) { - { - this.state = 9238; - this.match(PostgreSqlParser.STAR); - } - } - - this.state = 9245; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 940, this.context) ) { - case 1: - { - this.state = 9241; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9242; - this.column_list(); - this.state = 9243; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - this.state = 9248; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 103) { - { - this.state = 9247; - this.where_clause(); - } + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1000, this.context); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public window_definition(): Window_definitionContext { + let localContext = new Window_definitionContext(this.context, this.state); + this.enterRule(localContext, 704, PostgreSqlParser.RULE_window_definition); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7322; + this.colid(); + this.state = 7323; + this.match(PostgreSqlParser.KW_AS); + this.state = 7324; + this.window_specification(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public over_clause(): Over_clauseContext { + let localContext = new Over_clauseContext(this.context, this.state); + this.enterRule(localContext, 706, PostgreSqlParser.RULE_over_clause); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7326; + this.match(PostgreSqlParser.KW_OVER); + this.state = 7329; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.OPEN_PAREN: + { + this.state = 7327; + this.window_specification(); } - + break; + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 7328; + this.colid(); } break; - case 2: - this.enterOuterAlt(localContext, 2); + default: + throw new antlr.NoViableAltException(this); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public window_specification(): Window_specificationContext { + let localContext = new Window_specificationContext(this.context, this.state); + this.enterRule(localContext, 708, PostgreSqlParser.RULE_window_specification); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7331; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7333; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1002, this.context) ) { + case 1: { - this.state = 9250; - this.match(PostgreSqlParser.KW_TABLE); - this.state = 9251; - this.match(PostgreSqlParser.KW_ONLY); - this.state = 9257; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: + this.state = 7332; + this.colid(); + } + break; + } + this.state = 7338; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 285) { + { + this.state = 7335; + this.match(PostgreSqlParser.KW_PARTITION); + this.state = 7336; + this.match(PostgreSqlParser.KW_BY); + this.state = 7337; + this.expr_list(); + } + } + + this.state = 7341; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 83) { + { + this.state = 7340; + this.sort_clause(); + } + } + + this.state = 7344; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 299 || _la === 320 || _la === 481) { + { + this.state = 7343; + this.opt_frame_clause(); + } + } + + this.state = 7346; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public opt_frame_clause(): Opt_frame_clauseContext { + let localContext = new Opt_frame_clauseContext(this.context, this.state); + this.enterRule(localContext, 710, PostgreSqlParser.RULE_opt_frame_clause); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7348; + _la = this.tokenStream.LA(1); + if(!(_la === 299 || _la === 320 || _la === 481)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + { + this.state = 7353; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1006, this.context) ) { + case 1: + { + this.state = 7349; + this.match(PostgreSqlParser.KW_BETWEEN); + this.state = 7350; + this.frame_bound(); + this.state = 7351; + this.match(PostgreSqlParser.KW_AND); + } + break; + } + this.state = 7355; + this.frame_bound(); + } + this.state = 7366; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 199) { + { + this.state = 7357; + this.match(PostgreSqlParser.KW_EXCLUDE); + this.state = 7364; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: + { + this.state = 7358; + this.match(PostgreSqlParser.KW_CURRENT); + this.state = 7359; + this.match(PostgreSqlParser.KW_ROW); + } + break; + case PostgreSqlParser.KW_GROUP: + { + this.state = 7360; + this.match(PostgreSqlParser.KW_GROUP); + } + break; case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: { - this.state = 9252; - this.table_name(); + this.state = 7361; + this.match(PostgreSqlParser.KW_TIES); } break; - case PostgreSqlParser.OPEN_PAREN: + case PostgreSqlParser.KW_NO: { - this.state = 9253; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9254; - this.table_name(); - this.state = 9255; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 7362; + this.match(PostgreSqlParser.KW_NO); + this.state = 7363; + this.match(PostgreSqlParser.KW_OTHERS); } break; default: throw new antlr.NoViableAltException(this); } } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 9259; - this.match(PostgreSqlParser.KW_TABLES); - this.state = 9260; - this.match(PostgreSqlParser.KW_IN); - this.state = 9261; - this.match(PostgreSqlParser.KW_SCHEMA); - this.state = 9264; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: + } + + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; + } + public frame_bound(): Frame_boundContext { + let localContext = new Frame_boundContext(this.context, this.state); + this.enterRule(localContext, 712, PostgreSqlParser.RULE_frame_bound); + let _la: number; + try { + this.state = 7375; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1010, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 7370; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1009, this.context) ) { + case 1: { - this.state = 9262; - this.schema_name(); + this.state = 7368; + this.match(PostgreSqlParser.KW_UNBOUNDED); } break; - case PostgreSqlParser.KW_CURRENT_SCHEMA: + case 2: { - this.state = 9263; - this.match(PostgreSqlParser.KW_CURRENT_SCHEMA); + this.state = 7369; + this.expression(); } break; - default: - throw new antlr.NoViableAltException(this); } + this.state = 7372; + _la = this.tokenStream.LA(1); + if(!(_la === 208 || _la === 289)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 7373; + this.match(PostgreSqlParser.KW_CURRENT); + this.state = 7374; + this.match(PostgreSqlParser.KW_ROW); } break; } @@ -48165,31 +45365,37 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public relation_expr_list(): Relation_expr_listContext { - let localContext = new Relation_expr_listContext(this.context, this.state); - this.enterRule(localContext, 1124, PostgreSqlParser.RULE_relation_expr_list); - let _la: number; + public row(): RowContext { + let localContext = new RowContext(this.context, this.state); + this.enterRule(localContext, 714, PostgreSqlParser.RULE_row); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9268; - this.relation_expr(); - this.state = 9273; + this.state = 7384; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_ROW: + this.enterOuterAlt(localContext, 1); { + this.state = 7377; + this.explicit_row(); + } + break; + case PostgreSqlParser.OPEN_PAREN: + this.enterOuterAlt(localContext, 2); { - this.state = 9269; + this.state = 7378; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7379; + this.expr_list(); + this.state = 7380; this.match(PostgreSqlParser.COMMA); - this.state = 9270; - this.relation_expr(); - } + this.state = 7381; + this.expression(); + this.state = 7382; + this.match(PostgreSqlParser.CLOSE_PAREN); } - this.state = 9275; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } + break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -48206,31 +45412,29 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public publication_relation_expr_list(): Publication_relation_expr_listContext { - let localContext = new Publication_relation_expr_listContext(this.context, this.state); - this.enterRule(localContext, 1126, PostgreSqlParser.RULE_publication_relation_expr_list); + public explicit_row(): Explicit_rowContext { + let localContext = new Explicit_rowContext(this.context, this.state); + this.enterRule(localContext, 716, PostgreSqlParser.RULE_explicit_row); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 9276; - this.publication_relation_expr(); - this.state = 9281; + this.state = 7386; + this.match(PostgreSqlParser.KW_ROW); + this.state = 7387; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7389; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - while (_la === 6) { - { + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { { - this.state = 9277; - this.match(PostgreSqlParser.COMMA); - this.state = 9278; - this.publication_relation_expr(); - } + this.state = 7388; + this.expr_list(); } - this.state = 9283; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); } + + this.state = 7391; + this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -48247,34 +45451,21 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public relation_expr_opt_alias(): Relation_expr_opt_aliasContext { - let localContext = new Relation_expr_opt_aliasContext(this.context, this.state); - this.enterRule(localContext, 1128, PostgreSqlParser.RULE_relation_expr_opt_alias); + public sub_type(): Sub_typeContext { + let localContext = new Sub_typeContext(this.context, this.state); + this.enterRule(localContext, 718, PostgreSqlParser.RULE_sub_type); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 9284; - this.relation_expr(); - this.state = 9289; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 948, this.context) ) { - case 1: - { - this.state = 9286; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 36) { - { - this.state = 9285; - this.match(PostgreSqlParser.KW_AS); - } - } - - this.state = 9288; - this.colid(); - } - break; + this.state = 7393; + _la = this.tokenStream.LA(1); + if(!(_la === 30 || _la === 34 || _la === 90)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); } } } @@ -48292,32 +45483,40 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public tablesample_clause(): Tablesample_clauseContext { - let localContext = new Tablesample_clauseContext(this.context, this.state); - this.enterRule(localContext, 1130, PostgreSqlParser.RULE_tablesample_clause); + public all_op(): All_opContext { + let localContext = new All_opContext(this.context, this.state); + this.enterRule(localContext, 720, PostgreSqlParser.RULE_all_op); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9291; - this.match(PostgreSqlParser.KW_TABLESAMPLE); - this.state = 9292; - this.function_name(); - this.state = 9293; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9294; - this.expr_list(); - this.state = 9295; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 9297; + this.state = 7397; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 949, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.Operator: + this.enterOuterAlt(localContext, 1); { - this.state = 9296; - this.opt_repeatable_clause(); + this.state = 7395; + this.match(PostgreSqlParser.Operator); } break; - } + case PostgreSqlParser.STAR: + case PostgreSqlParser.EQUAL: + case PostgreSqlParser.PLUS: + case PostgreSqlParser.MINUS: + case PostgreSqlParser.SLASH: + case PostgreSqlParser.CARET: + case PostgreSqlParser.LT: + case PostgreSqlParser.GT: + case PostgreSqlParser.LESS_EQUALS: + case PostgreSqlParser.GREATER_EQUALS: + case PostgreSqlParser.NOT_EQUALS: + case PostgreSqlParser.PERCENT: + this.enterOuterAlt(localContext, 2); + { + this.state = 7396; + this.mathop(); + } + break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -48334,20 +45533,22 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_repeatable_clause(): Opt_repeatable_clauseContext { - let localContext = new Opt_repeatable_clauseContext(this.context, this.state); - this.enterRule(localContext, 1132, PostgreSqlParser.RULE_opt_repeatable_clause); + public mathop(): MathopContext { + let localContext = new MathopContext(this.context, this.state); + this.enterRule(localContext, 722, PostgreSqlParser.RULE_mathop); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 9299; - this.match(PostgreSqlParser.KW_REPEATABLE); - this.state = 9300; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9301; - this.a_expr(); - this.state = 9302; - this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 7399; + _la = this.tokenStream.LA(1); + if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 178517504) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } } } catch (re) { @@ -48364,55 +45565,35 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public func_table(): Func_tableContext { - let localContext = new Func_tableContext(this.context, this.state); - this.enterRule(localContext, 1134, PostgreSqlParser.RULE_func_table); + public qual_op(): Qual_opContext { + let localContext = new Qual_opContext(this.context, this.state); + this.enterRule(localContext, 724, PostgreSqlParser.RULE_qual_op); try { - this.state = 9316; + this.state = 7407; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 952, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.Operator: this.enterOuterAlt(localContext, 1); { - this.state = 9304; - this.func_expr_windowless(); - this.state = 9306; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 950, this.context) ) { - case 1: - { - this.state = 9305; - this.opt_ordinality(); - } - break; - } + this.state = 7401; + this.match(PostgreSqlParser.Operator); } break; - case 2: + case PostgreSqlParser.KW_OPERATOR: this.enterOuterAlt(localContext, 2); { - this.state = 9308; - this.match(PostgreSqlParser.KW_ROWS); - this.state = 9309; - this.match(PostgreSqlParser.KW_FROM); - this.state = 9310; + this.state = 7402; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 7403; this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9311; - this.rowsfrom_list(); - this.state = 9312; + this.state = 7404; + this.any_operator(); + this.state = 7405; this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 9314; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 951, this.context) ) { - case 1: - { - this.state = 9313; - this.opt_ordinality(); - } - break; - } } break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -48429,25 +45610,47 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public rowsfrom_item(): Rowsfrom_itemContext { - let localContext = new Rowsfrom_itemContext(this.context, this.state); - this.enterRule(localContext, 1136, PostgreSqlParser.RULE_rowsfrom_item); - let _la: number; + public qual_all_op(): Qual_all_opContext { + let localContext = new Qual_all_opContext(this.context, this.state); + this.enterRule(localContext, 726, PostgreSqlParser.RULE_qual_all_op); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9318; - this.func_expr_windowless(); - this.state = 9320; + this.state = 7415; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 36) { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.STAR: + case PostgreSqlParser.EQUAL: + case PostgreSqlParser.PLUS: + case PostgreSqlParser.MINUS: + case PostgreSqlParser.SLASH: + case PostgreSqlParser.CARET: + case PostgreSqlParser.LT: + case PostgreSqlParser.GT: + case PostgreSqlParser.LESS_EQUALS: + case PostgreSqlParser.GREATER_EQUALS: + case PostgreSqlParser.NOT_EQUALS: + case PostgreSqlParser.PERCENT: + case PostgreSqlParser.Operator: + this.enterOuterAlt(localContext, 1); { - this.state = 9319; - this.opt_col_def_list(); + this.state = 7409; + this.all_op(); } - } - + break; + case PostgreSqlParser.KW_OPERATOR: + this.enterOuterAlt(localContext, 2); + { + this.state = 7410; + this.match(PostgreSqlParser.KW_OPERATOR); + this.state = 7411; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7412; + this.any_operator(); + this.state = 7413; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -48464,61 +45667,62 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public rowsfrom_list(): Rowsfrom_listContext { - let localContext = new Rowsfrom_listContext(this.context, this.state); - this.enterRule(localContext, 1138, PostgreSqlParser.RULE_rowsfrom_list); + public subquery_Op(): Subquery_OpContext { + let localContext = new Subquery_OpContext(this.context, this.state); + this.enterRule(localContext, 728, PostgreSqlParser.RULE_subquery_Op); let _la: number; try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9322; - this.rowsfrom_item(); - this.state = 9327; + this.state = 7422; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.STAR: + case PostgreSqlParser.EQUAL: + case PostgreSqlParser.PLUS: + case PostgreSqlParser.MINUS: + case PostgreSqlParser.SLASH: + case PostgreSqlParser.CARET: + case PostgreSqlParser.LT: + case PostgreSqlParser.GT: + case PostgreSqlParser.LESS_EQUALS: + case PostgreSqlParser.GREATER_EQUALS: + case PostgreSqlParser.NOT_EQUALS: + case PostgreSqlParser.PERCENT: + case PostgreSqlParser.Operator: + case PostgreSqlParser.KW_OPERATOR: + this.enterOuterAlt(localContext, 1); { - this.state = 9323; - this.match(PostgreSqlParser.COMMA); - this.state = 9324; - this.rowsfrom_item(); - } + this.state = 7417; + this.qual_all_op(); } - this.state = 9329; + break; + case PostgreSqlParser.KW_NOT: + case PostgreSqlParser.KW_ILIKE: + case PostgreSqlParser.KW_LIKE: + this.enterOuterAlt(localContext, 2); + { + this.state = 7419; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_col_def_list(): Opt_col_def_listContext { - let localContext = new Opt_col_def_listContext(this.context, this.state); - this.enterRule(localContext, 1140, PostgreSqlParser.RULE_opt_col_def_list); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9330; - this.match(PostgreSqlParser.KW_AS); - this.state = 9331; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9332; - this.tablefuncelementlist(); - this.state = 9333; - this.match(PostgreSqlParser.CLOSE_PAREN); + if (_la === 77) { + { + this.state = 7418; + this.match(PostgreSqlParser.KW_NOT); + } + } + + this.state = 7421; + _la = this.tokenStream.LA(1); + if(!(_la === 114 || _la === 120)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); } } catch (re) { @@ -48535,42 +45739,33 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_ordinality(): Opt_ordinalityContext { - let localContext = new Opt_ordinalityContext(this.context, this.state); - this.enterRule(localContext, 1142, PostgreSqlParser.RULE_opt_ordinality); + public expr_list(): Expr_listContext { + let localContext = new Expr_listContext(this.context, this.state); + this.enterRule(localContext, 730, PostgreSqlParser.RULE_expr_list); try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 9335; - this.match(PostgreSqlParser.KW_WITH); - this.state = 9336; - this.match(PostgreSqlParser.KW_ORDINALITY); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + this.state = 7424; + this.expression(); + this.state = 7429; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1018, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 7425; + this.match(PostgreSqlParser.COMMA); + this.state = 7426; + this.expression(); + } + } + } + this.state = 7431; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1018, this.context); } - } - finally { - this.exitRule(); - } - return localContext; - } - public where_clause(): Where_clauseContext { - let localContext = new Where_clauseContext(this.context, this.state); - this.enterRule(localContext, 1144, PostgreSqlParser.RULE_where_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9338; - this.match(PostgreSqlParser.KW_WHERE); - this.state = 9339; - this.column_expr_noparen(); } } catch (re) { @@ -48587,59 +45782,34 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public where_or_current_clause(): Where_or_current_clauseContext { - let localContext = new Where_or_current_clauseContext(this.context, this.state); - this.enterRule(localContext, 1146, PostgreSqlParser.RULE_where_or_current_clause); + public column_expr(): Column_exprContext { + let localContext = new Column_exprContext(this.context, this.state); + this.enterRule(localContext, 732, PostgreSqlParser.RULE_column_expr); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9341; - this.match(PostgreSqlParser.KW_WHERE); - this.state = 9346; + this.state = 7437; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 955, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1019, this.context) ) { case 1: + this.enterOuterAlt(localContext, 1); { - this.state = 9342; - this.match(PostgreSqlParser.KW_CURRENT); - this.state = 9343; - this.match(PostgreSqlParser.KW_OF); - this.state = 9344; - this.cursor_name(); + { + this.state = 7432; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7433; + this.expression(); + this.state = 7434; + this.match(PostgreSqlParser.CLOSE_PAREN); + } } break; case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 9345; - this.a_expr(); + this.state = 7436; + this.column_name(); } break; } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opttablefuncelementlist(): OpttablefuncelementlistContext { - let localContext = new OpttablefuncelementlistContext(this.context, this.state); - this.enterRule(localContext, 1148, PostgreSqlParser.RULE_opttablefuncelementlist); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9348; - this.tablefuncelementlist(); - } } catch (re) { if (re instanceof antlr.RecognitionException) { @@ -48655,31 +45825,27 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public tablefuncelementlist(): TablefuncelementlistContext { - let localContext = new TablefuncelementlistContext(this.context, this.state); - this.enterRule(localContext, 1150, PostgreSqlParser.RULE_tablefuncelementlist); - let _la: number; + public column_expr_noparen(): Column_expr_noparenContext { + let localContext = new Column_expr_noparenContext(this.context, this.state); + this.enterRule(localContext, 734, PostgreSqlParser.RULE_column_expr_noparen); try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9350; - this.tablefuncelement(); - this.state = 9355; + this.state = 7441; this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1020, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); { - this.state = 9351; - this.match(PostgreSqlParser.COMMA); - this.state = 9352; - this.tablefuncelement(); + this.state = 7439; + this.expression(); } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 7440; + this.column_name(); } - this.state = 9357; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } + break; } } catch (re) { @@ -48696,25 +45862,32 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public tablefuncelement(): TablefuncelementContext { - let localContext = new TablefuncelementContext(this.context, this.state); - this.enterRule(localContext, 1152, PostgreSqlParser.RULE_tablefuncelement); + public func_arg_list(): Func_arg_listContext { + let localContext = new Func_arg_listContext(this.context, this.state); + this.enterRule(localContext, 736, PostgreSqlParser.RULE_func_arg_list); try { + let alternative: number; this.enterOuterAlt(localContext, 1); { - this.state = 9358; - this.colid(); - this.state = 9359; - this.typename(); - this.state = 9361; + this.state = 7443; + this.func_arg_expr(); + this.state = 7448; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 957, this.context) ) { - case 1: - { - this.state = 9360; - this.opt_collate_clause(); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1021, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 7444; + this.match(PostgreSqlParser.COMMA); + this.state = 7445; + this.func_arg_expr(); + } + } } - break; + this.state = 7450; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1021, this.context); } } } @@ -48732,97 +45905,39 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public xmltable(): XmltableContext { - let localContext = new XmltableContext(this.context, this.state); - this.enterRule(localContext, 1154, PostgreSqlParser.RULE_xmltable); + public func_arg_expr(): Func_arg_exprContext { + let localContext = new Func_arg_exprContext(this.context, this.state); + this.enterRule(localContext, 738, PostgreSqlParser.RULE_func_arg_expr); + let _la: number; try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9363; - this.match(PostgreSqlParser.KW_XMLTABLE); - this.state = 9364; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9380; + this.state = 7456; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 958, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1022, this.context) ) { case 1: + this.enterOuterAlt(localContext, 1); { - this.state = 9365; - this.c_expr(); - this.state = 9366; - this.xmlexists_argument(); - this.state = 9367; - this.match(PostgreSqlParser.KW_COLUMNS); - this.state = 9368; - this.xmltable_column_list(); + this.state = 7451; + this.expression(); } break; case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 9370; - this.match(PostgreSqlParser.KW_XMLNAMESPACES); - this.state = 9371; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9372; - this.xml_namespace_list(); - this.state = 9373; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 9374; - this.match(PostgreSqlParser.COMMA); - this.state = 9375; - this.c_expr(); - this.state = 9376; - this.xmlexists_argument(); - this.state = 9377; - this.match(PostgreSqlParser.KW_COLUMNS); - this.state = 9378; - this.xmltable_column_list(); + this.state = 7452; + this.type_function_name(); + this.state = 7453; + _la = this.tokenStream.LA(1); + if(!(_la === 20 || _la === 22)) { + this.errorHandler.recoverInline(this); } - break; - } - this.state = 9382; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public xmltable_column_list(): Xmltable_column_listContext { - let localContext = new Xmltable_column_listContext(this.context, this.state); - this.enterRule(localContext, 1156, PostgreSqlParser.RULE_xmltable_column_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9384; - this.xmltable_column_el(); - this.state = 9389; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 9385; - this.match(PostgreSqlParser.COMMA); - this.state = 9386; - this.xmltable_column_el(); + else { + this.errorHandler.reportMatch(this); + this.consume(); } + this.state = 7454; + this.expression(); } - this.state = 9391; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } + break; } } catch (re) { @@ -48839,25 +45954,47 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public xmltable_column_el(): Xmltable_column_elContext { - let localContext = new Xmltable_column_elContext(this.context, this.state); - this.enterRule(localContext, 1158, PostgreSqlParser.RULE_xmltable_column_el); + public array_expr(): Array_exprContext { + let localContext = new Array_exprContext(this.context, this.state); + this.enterRule(localContext, 740, PostgreSqlParser.RULE_array_expr); let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 9392; - this.colid(); - this.state = 9399; + this.state = 7458; + this.match(PostgreSqlParser.OPEN_BRACKET); + this.state = 7468; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.OPEN_PAREN: + case PostgreSqlParser.PLUS: + case PostgreSqlParser.MINUS: + case PostgreSqlParser.PARAM: + case PostgreSqlParser.Operator: case PostgreSqlParser.KW_AND: case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_CASE: + case PostgreSqlParser.KW_CAST: case PostgreSqlParser.KW_COLLATE: case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_CURRENT_CATALOG: + case PostgreSqlParser.KW_CURRENT_DATE: + case PostgreSqlParser.KW_CURRENT_ROLE: + case PostgreSqlParser.KW_CURRENT_TIME: + case PostgreSqlParser.KW_CURRENT_TIMESTAMP: + case PostgreSqlParser.KW_CURRENT_USER: case PostgreSqlParser.KW_DEFAULT: case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FALSE: case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_LOCALTIME: + case PostgreSqlParser.KW_LOCALTIMESTAMP: + case PostgreSqlParser.KW_NOT: + case PostgreSqlParser.KW_NULL: + case PostgreSqlParser.KW_SESSION_USER: + case PostgreSqlParser.KW_TRUE: + case PostgreSqlParser.KW_UNIQUE: + case PostgreSqlParser.KW_USER: case PostgreSqlParser.KW_AUTHORIZATION: case PostgreSqlParser.KW_BINARY: case PostgreSqlParser.KW_COLLATION: @@ -49268,72 +46405,49 @@ export class PostgreSqlParser extends SQLParserBase { case PostgreSqlParser.StringConstant: case PostgreSqlParser.UnicodeEscapeStringConstant: case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.BinaryStringConstant: + case PostgreSqlParser.HexadecimalStringConstant: + case PostgreSqlParser.Integral: + case PostgreSqlParser.Numeric: case PostgreSqlParser.PLSQLVARIABLENAME: case PostgreSqlParser.PLSQLIDENTIFIER: case PostgreSqlParser.EscapeStringConstant: { - this.state = 9393; - this.typename(); - this.state = 9395; + this.state = 7459; + this.expr_list(); + } + break; + case PostgreSqlParser.OPEN_BRACKET: + { + { + this.state = 7460; + this.array_expr(); + this.state = 7465; this.errorHandler.sync(this); _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || _la === 77 || _la === 78 || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 268451969) !== 0) || ((((_la - 153)) & ~0x1F) === 0 && ((1 << (_la - 153)) & 540945) !== 0) || _la === 207 || _la === 210 || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & 419430657) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & 268451841) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & 1051713) !== 0) || _la === 360 || _la === 433 || _la === 434 || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & 3959414785) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & 3071) !== 0) || ((((_la - 549)) & ~0x1F) === 0 && ((1 << (_la - 549)) & 100674083) !== 0) || _la === 584) { + while (_la === 6) { { - this.state = 9394; - this.xmltable_column_option_list(); + { + this.state = 7461; + this.match(PostgreSqlParser.COMMA); + this.state = 7462; + this.array_expr(); + } } + this.state = 7467; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); } - } - break; - case PostgreSqlParser.KW_FOR: - { - this.state = 9397; - this.match(PostgreSqlParser.KW_FOR); - this.state = 9398; - this.match(PostgreSqlParser.KW_ORDINALITY); } break; + case PostgreSqlParser.CLOSE_BRACKET: + break; default: - throw new antlr.NoViableAltException(this); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + break; } - } - finally { - this.exitRule(); - } - return localContext; - } - public xmltable_column_option_list(): Xmltable_column_option_listContext { - let localContext = new Xmltable_column_option_listContext(this.context, this.state); - this.enterRule(localContext, 1160, PostgreSqlParser.RULE_xmltable_column_option_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9402; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - do { - { - { - this.state = 9401; - this.xmltable_column_option_el(); - } - } - this.state = 9404; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } while (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || _la === 77 || _la === 78 || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 268451969) !== 0) || ((((_la - 153)) & ~0x1F) === 0 && ((1 << (_la - 153)) & 540945) !== 0) || _la === 207 || _la === 210 || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & 419430657) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & 268451841) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & 1051713) !== 0) || _la === 360 || _la === 433 || _la === 434 || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & 3959414785) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & 3071) !== 0) || ((((_la - 549)) & ~0x1F) === 0 && ((1 << (_la - 549)) & 100674083) !== 0) || _la === 584); + this.state = 7470; + this.match(PostgreSqlParser.CLOSE_BRACKET); } } catch (re) { @@ -49350,433 +46464,69 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public xmltable_column_option_el(): Xmltable_column_option_elContext { - let localContext = new Xmltable_column_option_elContext(this.context, this.state); - this.enterRule(localContext, 1162, PostgreSqlParser.RULE_xmltable_column_option_el); + public extract_arg(): Extract_argContext { + let localContext = new Extract_argContext(this.context, this.state); + this.enterRule(localContext, 742, PostgreSqlParser.RULE_extract_arg); try { - this.state = 9414; + this.state = 7480; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 963, this.context) ) { + switch (this.interpreter.adaptivePredict(this.tokenStream, 1025, this.context) ) { case 1: this.enterOuterAlt(localContext, 1); { - this.state = 9406; - this.match(PostgreSqlParser.KW_DEFAULT); - this.state = 9407; - this.a_expr(); + this.state = 7472; + this.identifier(); } break; case 2: this.enterOuterAlt(localContext, 2); { - this.state = 9408; - this.identifier(); - this.state = 9409; - this.a_expr(); + this.state = 7473; + this.match(PostgreSqlParser.KW_YEAR); } break; case 3: this.enterOuterAlt(localContext, 3); { - this.state = 9411; - this.match(PostgreSqlParser.KW_NOT); - this.state = 9412; - this.match(PostgreSqlParser.KW_NULL); + this.state = 7474; + this.match(PostgreSqlParser.KW_MONTH); } break; case 4: this.enterOuterAlt(localContext, 4); { - this.state = 9413; - this.match(PostgreSqlParser.KW_NULL); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public xml_namespace_list(): Xml_namespace_listContext { - let localContext = new Xml_namespace_listContext(this.context, this.state); - this.enterRule(localContext, 1164, PostgreSqlParser.RULE_xml_namespace_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9416; - this.xml_namespace_el(); - this.state = 9421; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 9417; - this.match(PostgreSqlParser.COMMA); - this.state = 9418; - this.xml_namespace_el(); - } - } - this.state = 9423; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public xml_namespace_el(): Xml_namespace_elContext { - let localContext = new Xml_namespace_elContext(this.context, this.state); - this.enterRule(localContext, 1166, PostgreSqlParser.RULE_xml_namespace_el); - try { - this.state = 9430; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 965, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 9424; - this.b_expr(0); - this.state = 9425; - this.match(PostgreSqlParser.KW_AS); - this.state = 9426; - this.collabel(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 9428; - this.match(PostgreSqlParser.KW_DEFAULT); - this.state = 9429; - this.b_expr(0); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public typename(): TypenameContext { - let localContext = new TypenameContext(this.context, this.state); - this.enterRule(localContext, 1168, PostgreSqlParser.RULE_typename); - let _la: number; - try { - this.state = 9450; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 969, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 9433; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 415) { - { - this.state = 9432; - this.match(PostgreSqlParser.KW_SETOF); - } - } - - this.state = 9435; - this.simpletypename(); - this.state = 9444; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 968, this.context) ) { - case 1: - { - this.state = 9436; - this.opt_array_bounds(); - } - break; - case 2: - { - this.state = 9437; - this.match(PostgreSqlParser.KW_ARRAY); - this.state = 9442; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 967, this.context) ) { - case 1: - { - this.state = 9438; - this.match(PostgreSqlParser.OPEN_BRACKET); - this.state = 9439; - this.iconst(); - this.state = 9440; - this.match(PostgreSqlParser.CLOSE_BRACKET); - } - break; - } - } - break; - } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 9446; - this.qualified_name(); - this.state = 9447; - this.match(PostgreSqlParser.PERCENT); - this.state = 9448; - _la = this.tokenStream.LA(1); - if(!(_la === 360 || _la === 477)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_array_bounds(): Opt_array_boundsContext { - let localContext = new Opt_array_boundsContext(this.context, this.state); - this.enterRule(localContext, 1170, PostgreSqlParser.RULE_opt_array_bounds); - let _la: number; - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 9459; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 971, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 9452; - this.match(PostgreSqlParser.OPEN_BRACKET); - this.state = 9454; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 571) { - { - this.state = 9453; - this.iconst(); - } - } - - this.state = 9456; - this.match(PostgreSqlParser.CLOSE_BRACKET); - } - } - } - this.state = 9461; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 971, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public simpletypename(): SimpletypenameContext { - let localContext = new SimpletypenameContext(this.context, this.state); - this.enterRule(localContext, 1172, PostgreSqlParser.RULE_simpletypename); - try { - this.state = 9477; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 974, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 9462; - this.generictype(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 9463; - this.numeric(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 9464; - this.bit(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 9465; - this.character(); + this.state = 7475; + this.match(PostgreSqlParser.KW_DAY); } break; case 5: this.enterOuterAlt(localContext, 5); { - this.state = 9466; - this.constdatetime(); + this.state = 7476; + this.match(PostgreSqlParser.KW_HOUR); } break; case 6: this.enterOuterAlt(localContext, 6); { - this.state = 9467; - this.constinterval(); - this.state = 9475; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 973, this.context) ) { - case 1: - { - this.state = 9469; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 972, this.context) ) { - case 1: - { - this.state = 9468; - this.opt_interval(); - } - break; - } - } - break; - case 2: - { - this.state = 9471; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9472; - this.iconst(); - this.state = 9473; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public consttypename(): ConsttypenameContext { - let localContext = new ConsttypenameContext(this.context, this.state); - this.enterRule(localContext, 1174, PostgreSqlParser.RULE_consttypename); - try { - this.state = 9483; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_SMALLINT: - this.enterOuterAlt(localContext, 1); - { - this.state = 9479; - this.numeric(); - } - break; - case PostgreSqlParser.KW_BIT: - this.enterOuterAlt(localContext, 2); - { - this.state = 9480; - this.constbit(); + this.state = 7477; + this.match(PostgreSqlParser.KW_MINUTE); } break; - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_VARCHAR: - this.enterOuterAlt(localContext, 3); + case 7: + this.enterOuterAlt(localContext, 7); { - this.state = 9481; - this.constcharacter(); + this.state = 7478; + this.match(PostgreSqlParser.KW_SECOND); } break; - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - this.enterOuterAlt(localContext, 4); + case 8: + this.enterOuterAlt(localContext, 8); { - this.state = 9482; - this.constdatetime(); + this.state = 7479; + this.sconst(); } break; - default: - throw new antlr.NoViableAltException(this); } } catch (re) { @@ -49793,62 +46543,22 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public generictype(): GenerictypeContext { - let localContext = new GenerictypeContext(this.context, this.state); - this.enterRule(localContext, 1176, PostgreSqlParser.RULE_generictype); + public unicode_normal_form(): Unicode_normal_formContext { + let localContext = new Unicode_normal_formContext(this.context, this.state); + this.enterRule(localContext, 744, PostgreSqlParser.RULE_unicode_normal_form); + let _la: number; try { this.enterOuterAlt(localContext, 1); { - this.state = 9485; - this.type_function_name(); - this.state = 9487; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 976, this.context) ) { - case 1: - { - this.state = 9486; - this.attrs(); - } - break; - } - this.state = 9490; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 977, this.context) ) { - case 1: - { - this.state = 9489; - this.opt_type_modifiers(); - } - break; - } + this.state = 7482; + _la = this.tokenStream.LA(1); + if(!(((((_la - 483)) & ~0x1F) === 0 && ((1 << (_la - 483)) & 15) !== 0))) { + this.errorHandler.recoverInline(this); } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; + else { + this.errorHandler.reportMatch(this); + this.consume(); } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_type_modifiers(): Opt_type_modifiersContext { - let localContext = new Opt_type_modifiersContext(this.context, this.state); - this.enterRule(localContext, 1178, PostgreSqlParser.RULE_opt_type_modifiers); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9492; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9493; - this.expr_list(); - this.state = 9494; - this.match(PostgreSqlParser.CLOSE_PAREN); } } catch (re) { @@ -49865,134 +46575,82 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public numeric(): NumericContext { - let localContext = new NumericContext(this.context, this.state); - this.enterRule(localContext, 1180, PostgreSqlParser.RULE_numeric); + public substr_list(): Substr_listContext { + let localContext = new Substr_listContext(this.context, this.state); + this.enterRule(localContext, 746, PostgreSqlParser.RULE_substr_list); + let _la: number; try { - this.state = 9520; + this.state = 7505; this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_INT: + switch (this.interpreter.adaptivePredict(this.tokenStream, 1028, this.context) ) { + case 1: this.enterOuterAlt(localContext, 1); { - this.state = 9496; - this.match(PostgreSqlParser.KW_INT); - } - break; - case PostgreSqlParser.KW_INTEGER: - this.enterOuterAlt(localContext, 2); - { - this.state = 9497; - this.match(PostgreSqlParser.KW_INTEGER); - } - break; - case PostgreSqlParser.KW_SMALLINT: - this.enterOuterAlt(localContext, 3); - { - this.state = 9498; - this.match(PostgreSqlParser.KW_SMALLINT); - } - break; - case PostgreSqlParser.KW_BIGINT: - this.enterOuterAlt(localContext, 4); - { - this.state = 9499; - this.match(PostgreSqlParser.KW_BIGINT); - } - break; - case PostgreSqlParser.KW_REAL: - this.enterOuterAlt(localContext, 5); - { - this.state = 9500; - this.match(PostgreSqlParser.KW_REAL); - } - break; - case PostgreSqlParser.KW_FLOAT: - this.enterOuterAlt(localContext, 6); - { - this.state = 9501; - this.match(PostgreSqlParser.KW_FLOAT); - this.state = 9503; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 978, this.context) ) { - case 1: - { - this.state = 9502; - this.opt_float(); - } - break; - } - } - break; - case PostgreSqlParser.KW_DOUBLE: - this.enterOuterAlt(localContext, 7); - { - this.state = 9505; - this.match(PostgreSqlParser.KW_DOUBLE); - this.state = 9506; - this.match(PostgreSqlParser.KW_PRECISION); - } - break; - case PostgreSqlParser.KW_DECIMAL: - this.enterOuterAlt(localContext, 8); - { - this.state = 9507; - this.match(PostgreSqlParser.KW_DECIMAL); - this.state = 9509; + this.state = 7484; + this.expression(); + this.state = 7485; + this.match(PostgreSqlParser.KW_FROM); + this.state = 7486; + this.expression(); + this.state = 7489; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 979, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 62) { { - this.state = 9508; - this.opt_type_modifiers(); + this.state = 7487; + this.match(PostgreSqlParser.KW_FOR); + this.state = 7488; + this.expression(); } - break; } + } break; - case PostgreSqlParser.KW_DEC: - this.enterOuterAlt(localContext, 9); + case 2: + this.enterOuterAlt(localContext, 2); { - this.state = 9511; - this.match(PostgreSqlParser.KW_DEC); - this.state = 9513; + this.state = 7491; + this.expression(); + this.state = 7492; + this.match(PostgreSqlParser.KW_FOR); + this.state = 7493; + this.expression(); + this.state = 7496; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 980, this.context) ) { - case 1: + _la = this.tokenStream.LA(1); + if (_la === 64) { { - this.state = 9512; - this.opt_type_modifiers(); + this.state = 7494; + this.match(PostgreSqlParser.KW_FROM); + this.state = 7495; + this.expression(); } - break; } + } break; - case PostgreSqlParser.KW_NUMERIC: - this.enterOuterAlt(localContext, 10); + case 3: + this.enterOuterAlt(localContext, 3); { - this.state = 9515; - this.match(PostgreSqlParser.KW_NUMERIC); - this.state = 9517; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 981, this.context) ) { - case 1: - { - this.state = 9516; - this.opt_type_modifiers(); - } - break; - } + this.state = 7498; + this.expression(); + this.state = 7499; + this.match(PostgreSqlParser.KW_SIMILAR); + this.state = 7500; + this.expression(); + this.state = 7501; + this.match(PostgreSqlParser.KW_ESCAPE); + this.state = 7502; + this.expression(); } break; - case PostgreSqlParser.KW_BOOLEAN: - this.enterOuterAlt(localContext, 11); + case 4: + this.enterOuterAlt(localContext, 4); { - this.state = 9519; - this.match(PostgreSqlParser.KW_BOOLEAN); + this.state = 7504; + this.expr_list(); } break; - default: - throw new antlr.NoViableAltException(this); } } catch (re) { @@ -50009,55 +46667,20 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public opt_float(): Opt_floatContext { - let localContext = new Opt_floatContext(this.context, this.state); - this.enterRule(localContext, 1182, PostgreSqlParser.RULE_opt_float); + public when_clause(): When_clauseContext { + let localContext = new When_clauseContext(this.context, this.state); + this.enterRule(localContext, 748, PostgreSqlParser.RULE_when_clause); try { this.enterOuterAlt(localContext, 1); { - this.state = 9522; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9523; - this.iconst(); - this.state = 9524; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public bit(): BitContext { - let localContext = new BitContext(this.context, this.state); - this.enterRule(localContext, 1184, PostgreSqlParser.RULE_bit); - try { - this.state = 9528; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 983, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 9526; - this.bitwithlength(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 9527; - this.bitwithoutlength(); - } - break; + this.state = 7507; + this.match(PostgreSqlParser.KW_WHEN); + this.state = 7508; + this.expression(); + this.state = 7509; + this.match(PostgreSqlParser.KW_THEN); + this.state = 7510; + this.expression(); } } catch (re) { @@ -50074,34111 +46697,11996 @@ export class PostgreSqlParser extends SQLParserBase { } return localContext; } - public constbit(): ConstbitContext { - let localContext = new ConstbitContext(this.context, this.state); - this.enterRule(localContext, 1186, PostgreSqlParser.RULE_constbit); + public indirection_el(): Indirection_elContext { + let localContext = new Indirection_elContext(this.context, this.state); + this.enterRule(localContext, 750, PostgreSqlParser.RULE_indirection_el); + let _la: number; try { - this.state = 9532; + this.state = 7529; this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 984, this.context) ) { - case 1: + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.DOT: this.enterOuterAlt(localContext, 1); { - this.state = 9530; - this.bitwithlength(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 9531; - this.bitwithoutlength(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public bitwithlength(): BitwithlengthContext { - let localContext = new BitwithlengthContext(this.context, this.state); - this.enterRule(localContext, 1188, PostgreSqlParser.RULE_bitwithlength); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9534; - this.match(PostgreSqlParser.KW_BIT); - this.state = 9536; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 374) { - { - this.state = 9535; - this.opt_varying(); - } - } - - this.state = 9538; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9539; - this.expr_list(); - this.state = 9540; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public bitwithoutlength(): BitwithoutlengthContext { - let localContext = new BitwithoutlengthContext(this.context, this.state); - this.enterRule(localContext, 1190, PostgreSqlParser.RULE_bitwithoutlength); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9542; - this.match(PostgreSqlParser.KW_BIT); - this.state = 9544; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 986, this.context) ) { - case 1: - { - this.state = 9543; - this.opt_varying(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public character(): CharacterContext { - let localContext = new CharacterContext(this.context, this.state); - this.enterRule(localContext, 1192, PostgreSqlParser.RULE_character); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9546; - this.character_c(); - this.state = 9551; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 987, this.context) ) { - case 1: - { - this.state = 9547; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9548; - this.iconst(); - this.state = 9549; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public constcharacter(): ConstcharacterContext { - let localContext = new ConstcharacterContext(this.context, this.state); - this.enterRule(localContext, 1194, PostgreSqlParser.RULE_constcharacter); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9553; - this.character_c(); - this.state = 9558; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2) { - { - this.state = 9554; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9555; - this.iconst(); - this.state = 9556; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public character_c(): Character_cContext { - let localContext = new Character_cContext(this.context, this.state); - this.enterRule(localContext, 1196, PostgreSqlParser.RULE_character_c); - let _la: number; - try { - this.state = 9570; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_NCHAR: - this.enterOuterAlt(localContext, 1); - { - this.state = 9560; - _la = this.tokenStream.LA(1); - if(!(((((_la - 391)) & ~0x1F) === 0 && ((1 << (_la - 391)) & 32771) !== 0))) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9562; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 989, this.context) ) { - case 1: - { - this.state = 9561; - this.opt_varying(); - } - break; - } - } - break; - case PostgreSqlParser.KW_VARCHAR: - this.enterOuterAlt(localContext, 2); - { - this.state = 9564; - this.match(PostgreSqlParser.KW_VARCHAR); - } - break; - case PostgreSqlParser.KW_NATIONAL: - this.enterOuterAlt(localContext, 3); - { - this.state = 9565; - this.match(PostgreSqlParser.KW_NATIONAL); - this.state = 9566; - _la = this.tokenStream.LA(1); - if(!(_la === 391 || _la === 392)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9568; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 990, this.context) ) { - case 1: - { - this.state = 9567; - this.opt_varying(); - } - break; - } - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_varying(): Opt_varyingContext { - let localContext = new Opt_varyingContext(this.context, this.state); - this.enterRule(localContext, 1198, PostgreSqlParser.RULE_opt_varying); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9572; - this.match(PostgreSqlParser.KW_VARYING); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public constdatetime(): ConstdatetimeContext { - let localContext = new ConstdatetimeContext(this.context, this.state); - this.enterRule(localContext, 1200, PostgreSqlParser.RULE_constdatetime); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9574; - _la = this.tokenStream.LA(1); - if(!(_la === 418 || _la === 419)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9579; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 992, this.context) ) { - case 1: - { - this.state = 9575; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9576; - this.iconst(); - this.state = 9577; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - this.state = 9582; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 993, this.context) ) { - case 1: - { - this.state = 9581; - this.opt_timezone(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public constinterval(): ConstintervalContext { - let localContext = new ConstintervalContext(this.context, this.state); - this.enterRule(localContext, 1202, PostgreSqlParser.RULE_constinterval); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9584; - this.match(PostgreSqlParser.KW_INTERVAL); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_timezone(): Opt_timezoneContext { - let localContext = new Opt_timezoneContext(this.context, this.state); - this.enterRule(localContext, 1204, PostgreSqlParser.RULE_opt_timezone); - try { - this.state = 9592; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_WITH: - this.enterOuterAlt(localContext, 1); - { - this.state = 9586; - this.match(PostgreSqlParser.KW_WITH); - this.state = 9587; - this.match(PostgreSqlParser.KW_TIME); - this.state = 9588; - this.match(PostgreSqlParser.KW_ZONE); - } - break; - case PostgreSqlParser.KW_WITHOUT: - this.enterOuterAlt(localContext, 2); - { - this.state = 9589; - this.match(PostgreSqlParser.KW_WITHOUT); - this.state = 9590; - this.match(PostgreSqlParser.KW_TIME); - this.state = 9591; - this.match(PostgreSqlParser.KW_ZONE); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_interval(): Opt_intervalContext { - let localContext = new Opt_intervalContext(this.context, this.state); - this.enterRule(localContext, 1206, PostgreSqlParser.RULE_opt_interval); - try { - this.state = 9619; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 997, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 9594; - this.match(PostgreSqlParser.KW_YEAR); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 9595; - this.match(PostgreSqlParser.KW_MONTH); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 9596; - this.match(PostgreSqlParser.KW_DAY); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 9597; - this.match(PostgreSqlParser.KW_HOUR); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 9598; - this.match(PostgreSqlParser.KW_MINUTE); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 9599; - this.interval_second(); - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 9600; - this.match(PostgreSqlParser.KW_YEAR); - this.state = 9601; - this.match(PostgreSqlParser.KW_TO); - this.state = 9602; - this.match(PostgreSqlParser.KW_MONTH); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 9603; - this.match(PostgreSqlParser.KW_DAY); - this.state = 9604; - this.match(PostgreSqlParser.KW_TO); - this.state = 9608; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_HOUR: - { - this.state = 9605; - this.match(PostgreSqlParser.KW_HOUR); - } - break; - case PostgreSqlParser.KW_MINUTE: - { - this.state = 9606; - this.match(PostgreSqlParser.KW_MINUTE); - } - break; - case PostgreSqlParser.KW_SECOND: - { - this.state = 9607; - this.interval_second(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 9610; - this.match(PostgreSqlParser.KW_HOUR); - this.state = 9611; - this.match(PostgreSqlParser.KW_TO); - this.state = 9614; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_MINUTE: - { - this.state = 9612; - this.match(PostgreSqlParser.KW_MINUTE); - } - break; - case PostgreSqlParser.KW_SECOND: - { - this.state = 9613; - this.interval_second(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 9616; - this.match(PostgreSqlParser.KW_MINUTE); - this.state = 9617; - this.match(PostgreSqlParser.KW_TO); - this.state = 9618; - this.interval_second(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public interval_second(): Interval_secondContext { - let localContext = new Interval_secondContext(this.context, this.state); - this.enterRule(localContext, 1208, PostgreSqlParser.RULE_interval_second); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9621; - this.match(PostgreSqlParser.KW_SECOND); - this.state = 9626; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 998, this.context) ) { - case 1: - { - this.state = 9622; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9623; - this.iconst(); - this.state = 9624; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_escape(): Opt_escapeContext { - let localContext = new Opt_escapeContext(this.context, this.state); - this.enterRule(localContext, 1210, PostgreSqlParser.RULE_opt_escape); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9628; - this.match(PostgreSqlParser.KW_ESCAPE); - this.state = 9629; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr(): A_exprContext { - let localContext = new A_exprContext(this.context, this.state); - this.enterRule(localContext, 1212, PostgreSqlParser.RULE_a_expr); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9631; - this.a_expr_qual(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_qual(): A_expr_qualContext { - let localContext = new A_expr_qualContext(this.context, this.state); - this.enterRule(localContext, 1214, PostgreSqlParser.RULE_a_expr_qual); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9633; - this.a_expr_lessless(); - this.state = 9635; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 999, this.context) ) { - case 1: - { - this.state = 9634; - this.qual_op(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_lessless(): A_expr_lesslessContext { - let localContext = new A_expr_lesslessContext(this.context, this.state); - this.enterRule(localContext, 1216, PostgreSqlParser.RULE_a_expr_lessless); - let _la: number; - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 9637; - this.a_expr_or(); - this.state = 9642; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1000, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 9638; - _la = this.tokenStream.LA(1); - if(!(_la === 18 || _la === 19)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9639; - this.a_expr_or(); - } - } - } - this.state = 9644; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1000, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_or(): A_expr_orContext { - let localContext = new A_expr_orContext(this.context, this.state); - this.enterRule(localContext, 1218, PostgreSqlParser.RULE_a_expr_or); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 9645; - this.a_expr_and(); - this.state = 9650; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1001, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 9646; - this.match(PostgreSqlParser.KW_OR); - this.state = 9647; - this.a_expr_and(); - } - } - } - this.state = 9652; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1001, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_and(): A_expr_andContext { - let localContext = new A_expr_andContext(this.context, this.state); - this.enterRule(localContext, 1220, PostgreSqlParser.RULE_a_expr_and); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 9653; - this.a_expr_in(); - this.state = 9658; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1002, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 9654; - this.match(PostgreSqlParser.KW_AND); - this.state = 9655; - this.a_expr_in(); - } - } - } - this.state = 9660; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1002, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_in(): A_expr_inContext { - let localContext = new A_expr_inContext(this.context, this.state); - this.enterRule(localContext, 1222, PostgreSqlParser.RULE_a_expr_in); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9661; - this.a_expr_unary_not(); - this.state = 9667; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1004, this.context) ) { - case 1: - { - this.state = 9663; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 77) { - { - this.state = 9662; - this.match(PostgreSqlParser.KW_NOT); - } - } - - this.state = 9665; - this.match(PostgreSqlParser.KW_IN); - this.state = 9666; - this.in_expr(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_unary_not(): A_expr_unary_notContext { - let localContext = new A_expr_unary_notContext(this.context, this.state); - this.enterRule(localContext, 1224, PostgreSqlParser.RULE_a_expr_unary_not); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9670; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 77) { - { - this.state = 9669; - this.match(PostgreSqlParser.KW_NOT); - } - } - - this.state = 9672; - this.a_expr_isnull(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_isnull(): A_expr_isnullContext { - let localContext = new A_expr_isnullContext(this.context, this.state); - this.enterRule(localContext, 1226, PostgreSqlParser.RULE_a_expr_isnull); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9674; - this.a_expr_is_not(); - this.state = 9676; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1006, this.context) ) { - case 1: - { - this.state = 9675; - _la = this.tokenStream.LA(1); - if(!(_la === 117 || _la === 122)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_is_not(): A_expr_is_notContext { - let localContext = new A_expr_is_notContext(this.context, this.state); - this.enterRule(localContext, 1228, PostgreSqlParser.RULE_a_expr_is_not); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9678; - this.a_expr_compare(); - this.state = 9702; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1010, this.context) ) { - case 1: - { - this.state = 9679; - this.match(PostgreSqlParser.KW_IS); - this.state = 9681; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 77) { - { - this.state = 9680; - this.match(PostgreSqlParser.KW_NOT); - } - } - - this.state = 9700; + this.state = 7512; + this.match(PostgreSqlParser.DOT); + this.state = 7515; this.errorHandler.sync(this); switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_ALL: + case PostgreSqlParser.KW_ANALYSE: + case PostgreSqlParser.KW_ANALYZE: + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ANY: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_AS: + case PostgreSqlParser.KW_ASC: + case PostgreSqlParser.KW_ASYMMETRIC: + case PostgreSqlParser.KW_BOTH: + case PostgreSqlParser.KW_CASE: + case PostgreSqlParser.KW_CAST: + case PostgreSqlParser.KW_CHECK: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_COLUMN: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_CREATE: + case PostgreSqlParser.KW_CURRENT_CATALOG: + case PostgreSqlParser.KW_CURRENT_DATE: + case PostgreSqlParser.KW_CURRENT_ROLE: + case PostgreSqlParser.KW_CURRENT_TIME: + case PostgreSqlParser.KW_CURRENT_TIMESTAMP: + case PostgreSqlParser.KW_CURRENT_USER: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DEFERRABLE: + case PostgreSqlParser.KW_DESC: + case PostgreSqlParser.KW_DISTINCT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_ELSE: + case PostgreSqlParser.KW_EXCEPT: + case PostgreSqlParser.KW_FALSE: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_FOR: + case PostgreSqlParser.KW_FOREIGN: + case PostgreSqlParser.KW_FROM: + case PostgreSqlParser.KW_GRANT: + case PostgreSqlParser.KW_GROUP: + case PostgreSqlParser.KW_HAVING: + case PostgreSqlParser.KW_IN: + case PostgreSqlParser.KW_INITIALLY: + case PostgreSqlParser.KW_INTERSECT: + case PostgreSqlParser.KW_LATERAL: + case PostgreSqlParser.KW_LEADING: + case PostgreSqlParser.KW_LIMIT: + case PostgreSqlParser.KW_LOCALTIME: + case PostgreSqlParser.KW_LOCALTIMESTAMP: + case PostgreSqlParser.KW_NOT: case PostgreSqlParser.KW_NULL: - { - this.state = 9683; - this.match(PostgreSqlParser.KW_NULL); - } - break; + case PostgreSqlParser.KW_OFFSET: + case PostgreSqlParser.KW_ON: + case PostgreSqlParser.KW_ONLY: + case PostgreSqlParser.KW_OR: + case PostgreSqlParser.KW_ORDER: + case PostgreSqlParser.KW_PLACING: + case PostgreSqlParser.KW_PRIMARY: + case PostgreSqlParser.KW_REFERENCES: + case PostgreSqlParser.KW_RETURNING: + case PostgreSqlParser.KW_SELECT: + case PostgreSqlParser.KW_SESSION_USER: + case PostgreSqlParser.KW_SOME: + case PostgreSqlParser.KW_SYMMETRIC: + case PostgreSqlParser.KW_TABLE: + case PostgreSqlParser.KW_THEN: + case PostgreSqlParser.KW_TO: + case PostgreSqlParser.KW_TRAILING: case PostgreSqlParser.KW_TRUE: - { - this.state = 9684; - this.match(PostgreSqlParser.KW_TRUE); - } - break; - case PostgreSqlParser.KW_FALSE: - { - this.state = 9685; - this.match(PostgreSqlParser.KW_FALSE); - } - break; - case PostgreSqlParser.KW_UNKNOWN: - { - this.state = 9686; - this.match(PostgreSqlParser.KW_UNKNOWN); - } - break; - case PostgreSqlParser.KW_DISTINCT: - { - this.state = 9687; - this.match(PostgreSqlParser.KW_DISTINCT); - this.state = 9688; - this.match(PostgreSqlParser.KW_FROM); - this.state = 9689; - this.a_expr(); - } - break; - case PostgreSqlParser.KW_OF: - { - this.state = 9690; - this.match(PostgreSqlParser.KW_OF); - this.state = 9691; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9692; - this.type_list(); - this.state = 9693; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_DOCUMENT: - { - this.state = 9695; - this.match(PostgreSqlParser.KW_DOCUMENT); - } - break; - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - { - this.state = 9697; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 483)) & ~0x1F) === 0 && ((1 << (_la - 483)) & 15) !== 0)) { - { - this.state = 9696; - this.unicode_normal_form(); - } - } - - this.state = 9699; - this.match(PostgreSqlParser.KW_NORMALIZED); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_compare(): A_expr_compareContext { - let localContext = new A_expr_compareContext(this.context, this.state); - this.enterRule(localContext, 1230, PostgreSqlParser.RULE_a_expr_compare); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9704; - this.a_expr_like(); - this.state = 9716; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1012, this.context) ) { - case 1: - { - this.state = 9705; - _la = this.tokenStream.LA(1); - if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 44237824) !== 0))) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9706; - this.a_expr_like(); - } - break; - case 2: - { - this.state = 9707; - this.subquery_Op(); - this.state = 9708; - this.sub_type(); - this.state = 9714; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1011, this.context) ) { - case 1: - { - this.state = 9709; - this.select_with_parens(); - } - break; - case 2: - { - this.state = 9710; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9711; - this.a_expr(); - this.state = 9712; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_like(): A_expr_likeContext { - let localContext = new A_expr_likeContext(this.context, this.state); - this.enterRule(localContext, 1232, PostgreSqlParser.RULE_a_expr_like); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9718; - this.a_expr_qual_op(); - this.state = 9736; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1017, this.context) ) { - case 1: - { - this.state = 9720; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 77) { - { - this.state = 9719; - this.match(PostgreSqlParser.KW_NOT); - } - } - - this.state = 9730; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_LIKE: - { - this.state = 9722; - this.match(PostgreSqlParser.KW_LIKE); - } - break; + case PostgreSqlParser.KW_UNION: + case PostgreSqlParser.KW_UNIQUE: + case PostgreSqlParser.KW_USER: + case PostgreSqlParser.KW_USING: + case PostgreSqlParser.KW_VARIADIC: + case PostgreSqlParser.KW_WHEN: + case PostgreSqlParser.KW_WHERE: + case PostgreSqlParser.KW_WINDOW: + case PostgreSqlParser.KW_WITH: + case PostgreSqlParser.KW_AUTHORIZATION: + case PostgreSqlParser.KW_BINARY: + case PostgreSqlParser.KW_COLLATION: + case PostgreSqlParser.KW_CONCURRENTLY: + case PostgreSqlParser.KW_CROSS: + case PostgreSqlParser.KW_CURRENT_SCHEMA: + case PostgreSqlParser.KW_FREEZE: + case PostgreSqlParser.KW_FULL: case PostgreSqlParser.KW_ILIKE: - { - this.state = 9723; - this.match(PostgreSqlParser.KW_ILIKE); - } - break; - case PostgreSqlParser.KW_SIMILAR: - { - this.state = 9724; - this.match(PostgreSqlParser.KW_SIMILAR); - this.state = 9725; - this.match(PostgreSqlParser.KW_TO); - } - break; - case PostgreSqlParser.KW_BETWEEN: - { - this.state = 9726; - this.match(PostgreSqlParser.KW_BETWEEN); - this.state = 9728; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 91) { - { - this.state = 9727; - this.match(PostgreSqlParser.KW_SYMMETRIC); - } - } - - } - break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 9732; - this.a_expr_qual_op(); - this.state = 9734; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1016, this.context) ) { - case 1: - { - this.state = 9733; - this.opt_escape(); - } - break; - } - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_qual_op(): A_expr_qual_opContext { - let localContext = new A_expr_qual_opContext(this.context, this.state); - this.enterRule(localContext, 1234, PostgreSqlParser.RULE_a_expr_qual_op); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 9738; - this.a_expr_unary_qualop(); - this.state = 9744; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1018, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 9739; - this.qual_op(); - this.state = 9740; - this.a_expr_unary_qualop(); - } - } - } - this.state = 9746; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1018, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_unary_qualop(): A_expr_unary_qualopContext { - let localContext = new A_expr_unary_qualopContext(this.context, this.state); - this.enterRule(localContext, 1236, PostgreSqlParser.RULE_a_expr_unary_qualop); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9748; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1019, this.context) ) { - case 1: - { - this.state = 9747; - this.qual_op(); - } - break; - } - this.state = 9750; - this.a_expr_add(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_add(): A_expr_addContext { - let localContext = new A_expr_addContext(this.context, this.state); - this.enterRule(localContext, 1238, PostgreSqlParser.RULE_a_expr_add); - let _la: number; - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 9752; - this.a_expr_mul(); - this.state = 9757; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1020, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 9753; - _la = this.tokenStream.LA(1); - if(!(_la === 12 || _la === 13)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9754; - this.a_expr_mul(); - } - } - } - this.state = 9759; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1020, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_mul(): A_expr_mulContext { - let localContext = new A_expr_mulContext(this.context, this.state); - this.enterRule(localContext, 1240, PostgreSqlParser.RULE_a_expr_mul); - let _la: number; - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 9760; - this.a_expr_caret(); - this.state = 9765; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1021, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 9761; - _la = this.tokenStream.LA(1); - if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 134234624) !== 0))) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9762; - this.a_expr_caret(); - } - } - } - this.state = 9767; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1021, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_caret(): A_expr_caretContext { - let localContext = new A_expr_caretContext(this.context, this.state); - this.enterRule(localContext, 1242, PostgreSqlParser.RULE_a_expr_caret); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9768; - this.a_expr_unary_sign(); - this.state = 9771; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1022, this.context) ) { - case 1: - { - this.state = 9769; - this.match(PostgreSqlParser.CARET); - this.state = 9770; - this.a_expr(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_unary_sign(): A_expr_unary_signContext { - let localContext = new A_expr_unary_signContext(this.context, this.state); - this.enterRule(localContext, 1244, PostgreSqlParser.RULE_a_expr_unary_sign); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9774; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 12 || _la === 13) { - { - this.state = 9773; - _la = this.tokenStream.LA(1); - if(!(_la === 12 || _la === 13)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - - this.state = 9776; - this.a_expr_at_time_zone(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_at_time_zone(): A_expr_at_time_zoneContext { - let localContext = new A_expr_at_time_zoneContext(this.context, this.state); - this.enterRule(localContext, 1246, PostgreSqlParser.RULE_a_expr_at_time_zone); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9778; - this.a_expr_collate(); - this.state = 9783; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1024, this.context) ) { - case 1: - { - this.state = 9779; - this.match(PostgreSqlParser.KW_AT); - this.state = 9780; - this.match(PostgreSqlParser.KW_TIME); - this.state = 9781; - this.match(PostgreSqlParser.KW_ZONE); - this.state = 9782; - this.a_expr(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_collate(): A_expr_collateContext { - let localContext = new A_expr_collateContext(this.context, this.state); - this.enterRule(localContext, 1248, PostgreSqlParser.RULE_a_expr_collate); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9785; - this.a_expr_typecast(); - this.state = 9788; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1025, this.context) ) { - case 1: - { - this.state = 9786; - this.match(PostgreSqlParser.KW_COLLATE); - this.state = 9787; - this.any_name(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public a_expr_typecast(): A_expr_typecastContext { - let localContext = new A_expr_typecastContext(this.context, this.state); - this.enterRule(localContext, 1250, PostgreSqlParser.RULE_a_expr_typecast); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 9790; - this.c_expr(); - this.state = 9795; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1026, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 9791; - this.match(PostgreSqlParser.TYPECAST); - this.state = 9792; - this.typename(); - } - } - } - this.state = 9797; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1026, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - - public b_expr(): B_exprContext; - public b_expr(_p: number): B_exprContext; - public b_expr(_p?: number): B_exprContext { - if (_p === undefined) { - _p = 0; - } - - let parentContext = this.context; - let parentState = this.state; - let localContext = new B_exprContext(this.context, parentState); - let previousContext = localContext; - let _startState = 1252; - this.enterRecursionRule(localContext, 1252, PostgreSqlParser.RULE_b_expr, _p); - let _la: number; - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 9805; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1027, this.context) ) { - case 1: - { - this.state = 9799; - this.c_expr(); - } - break; - case 2: - { - this.state = 9800; - _la = this.tokenStream.LA(1); - if(!(_la === 12 || _la === 13)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9801; - this.b_expr(9); - } - break; - case 3: - { - this.state = 9802; - this.qual_op(); - this.state = 9803; - this.b_expr(3); - } - break; - } - this.context!.stop = this.tokenStream.LT(-1); - this.state = 9846; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1031, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - if (this._parseListeners != null) { - this.triggerExitRuleEvent(); - } - previousContext = localContext; - { - this.state = 9844; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1030, this.context) ) { - case 1: - { - localContext = new B_exprContext(parentContext, parentState); - this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_b_expr); - this.state = 9807; - if (!(this.precpred(this.context, 8))) { - throw this.createFailedPredicateException("this.precpred(this.context, 8)"); - } - this.state = 9808; - this.match(PostgreSqlParser.CARET); - this.state = 9809; - this.b_expr(9); - } - break; - case 2: - { - localContext = new B_exprContext(parentContext, parentState); - this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_b_expr); - this.state = 9810; - if (!(this.precpred(this.context, 7))) { - throw this.createFailedPredicateException("this.precpred(this.context, 7)"); - } - this.state = 9811; - _la = this.tokenStream.LA(1); - if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 134234624) !== 0))) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9812; - this.b_expr(8); - } - break; - case 3: - { - localContext = new B_exprContext(parentContext, parentState); - this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_b_expr); - this.state = 9813; - if (!(this.precpred(this.context, 6))) { - throw this.createFailedPredicateException("this.precpred(this.context, 6)"); - } - this.state = 9814; - _la = this.tokenStream.LA(1); - if(!(_la === 12 || _la === 13)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9815; - this.b_expr(7); - } - break; - case 4: - { - localContext = new B_exprContext(parentContext, parentState); - this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_b_expr); - this.state = 9816; - if (!(this.precpred(this.context, 5))) { - throw this.createFailedPredicateException("this.precpred(this.context, 5)"); - } - this.state = 9817; - this.qual_op(); - this.state = 9818; - this.b_expr(6); - } - break; - case 5: - { - localContext = new B_exprContext(parentContext, parentState); - this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_b_expr); - this.state = 9820; - if (!(this.precpred(this.context, 4))) { - throw this.createFailedPredicateException("this.precpred(this.context, 4)"); - } - this.state = 9821; - _la = this.tokenStream.LA(1); - if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 44237824) !== 0))) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9822; - this.b_expr(5); - } - break; - case 6: - { - localContext = new B_exprContext(parentContext, parentState); - this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_b_expr); - this.state = 9823; - if (!(this.precpred(this.context, 10))) { - throw this.createFailedPredicateException("this.precpred(this.context, 10)"); - } - this.state = 9824; - this.match(PostgreSqlParser.TYPECAST); - this.state = 9825; - this.typename(); - } - break; - case 7: - { - localContext = new B_exprContext(parentContext, parentState); - this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_b_expr); - this.state = 9826; - if (!(this.precpred(this.context, 2))) { - throw this.createFailedPredicateException("this.precpred(this.context, 2)"); - } - this.state = 9827; - this.qual_op(); - } - break; - case 8: - { - localContext = new B_exprContext(parentContext, parentState); - this.pushNewRecursionContext(localContext, _startState, PostgreSqlParser.RULE_b_expr); - this.state = 9828; - if (!(this.precpred(this.context, 1))) { - throw this.createFailedPredicateException("this.precpred(this.context, 1)"); - } - this.state = 9829; - this.match(PostgreSqlParser.KW_IS); - this.state = 9831; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 77) { - { - this.state = 9830; - this.match(PostgreSqlParser.KW_NOT); - } - } - - this.state = 9842; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_DISTINCT: - { - this.state = 9833; - this.match(PostgreSqlParser.KW_DISTINCT); - this.state = 9834; - this.match(PostgreSqlParser.KW_FROM); - this.state = 9835; - this.b_expr(0); - } - break; - case PostgreSqlParser.KW_OF: - { - this.state = 9836; - this.match(PostgreSqlParser.KW_OF); - this.state = 9837; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9838; - this.type_list(); - this.state = 9839; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_DOCUMENT: - { - this.state = 9841; - this.match(PostgreSqlParser.KW_DOCUMENT); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - } - } - } - this.state = 9848; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1031, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.unrollRecursionContexts(parentContext); - } - return localContext; - } - public c_expr(): C_exprContext { - let localContext = new C_exprContext(this.context, this.state); - this.enterRule(localContext, 1254, PostgreSqlParser.RULE_c_expr); - try { - this.state = 9885; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1034, this.context) ) { - case 1: - localContext = new C_expr_existsContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 9849; - this.match(PostgreSqlParser.KW_EXISTS); - this.state = 9850; - this.select_with_parens(); - } - break; - case 2: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 2); - { - this.state = 9851; - this.match(PostgreSqlParser.KW_ARRAY); - this.state = 9854; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.OPEN_PAREN: - { - this.state = 9852; - this.select_with_parens(); - } - break; - case PostgreSqlParser.OPEN_BRACKET: - { - this.state = 9853; - this.array_expr(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 3: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 3); - { - this.state = 9856; - this.match(PostgreSqlParser.PARAM); - this.state = 9857; - this.opt_indirection(); - } - break; - case 4: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 4); - { - this.state = 9858; - this.match(PostgreSqlParser.KW_GROUPING); - this.state = 9859; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9860; - this.expr_list(); - this.state = 9861; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case 5: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 5); - { - this.state = 9863; - this.match(PostgreSqlParser.KW_UNIQUE); - this.state = 9864; - this.select_with_parens(); - } - break; - case 6: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 6); - { - this.state = 9865; - this.aexprconst(); - } - break; - case 7: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 7); - { - this.state = 9866; - this.plsqlvariablename(); - } - break; - case 8: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 8); - { - this.state = 9867; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9868; - (localContext as C_expr_exprContext)._a_expr_in_parens = this.a_expr(); - this.state = 9869; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 9870; - this.opt_indirection(); - } - break; - case 9: - localContext = new C_expr_caseContext(localContext); - this.enterOuterAlt(localContext, 9); - { - this.state = 9872; - this.case_expr(); - } - break; - case 10: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 10); - { - this.state = 9873; - this.func_expr(); - } - break; - case 11: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 11); - { - this.state = 9874; - this.select_with_parens(); - this.state = 9876; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1033, this.context) ) { - case 1: - { - this.state = 9875; - this.indirection(); - } - break; - } - } - break; - case 12: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 12); - { - this.state = 9878; - this.explicit_row(); - } - break; - case 13: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 13); - { - this.state = 9879; - this.implicit_row(); - } - break; - case 14: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 14); - { - this.state = 9880; - this.row(); - this.state = 9881; - this.match(PostgreSqlParser.KW_OVERLAPS); - this.state = 9882; - this.row(); - } - break; - case 15: - localContext = new C_expr_exprContext(localContext); - this.enterOuterAlt(localContext, 15); - { - this.state = 9884; - this.columnref(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public plsqlvariablename(): PlsqlvariablenameContext { - let localContext = new PlsqlvariablenameContext(this.context, this.state); - this.enterRule(localContext, 1256, PostgreSqlParser.RULE_plsqlvariablename); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9887; - this.match(PostgreSqlParser.PLSQLVARIABLENAME); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public func_application(): Func_applicationContext { - let localContext = new Func_applicationContext(this.context, this.state); - this.enterRule(localContext, 1258, PostgreSqlParser.RULE_func_application); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 9889; - this.function_name(); - this.state = 9915; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1040, this.context) ) { - case 1: - { - this.state = 9890; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9912; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.OPEN_PAREN: - case PostgreSqlParser.PLUS: - case PostgreSqlParser.MINUS: - case PostgreSqlParser.PARAM: - case PostgreSqlParser.Operator: - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_CASE: - case PostgreSqlParser.KW_CAST: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_CURRENT_CATALOG: - case PostgreSqlParser.KW_CURRENT_DATE: - case PostgreSqlParser.KW_CURRENT_ROLE: - case PostgreSqlParser.KW_CURRENT_TIME: - case PostgreSqlParser.KW_CURRENT_TIMESTAMP: - case PostgreSqlParser.KW_CURRENT_USER: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FALSE: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_LOCALTIME: - case PostgreSqlParser.KW_LOCALTIMESTAMP: - case PostgreSqlParser.KW_NOT: - case PostgreSqlParser.KW_NULL: - case PostgreSqlParser.KW_SESSION_USER: - case PostgreSqlParser.KW_TRUE: - case PostgreSqlParser.KW_UNIQUE: - case PostgreSqlParser.KW_USER: - case PostgreSqlParser.KW_AUTHORIZATION: - case PostgreSqlParser.KW_BINARY: - case PostgreSqlParser.KW_COLLATION: - case PostgreSqlParser.KW_CONCURRENTLY: - case PostgreSqlParser.KW_CROSS: - case PostgreSqlParser.KW_CURRENT_SCHEMA: - case PostgreSqlParser.KW_FREEZE: - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_ILIKE: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_ISNULL: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_LIKE: - case PostgreSqlParser.KW_NATURAL: - case PostgreSqlParser.KW_NOTNULL: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_OVERLAPS: - case PostgreSqlParser.KW_RIGHT: - case PostgreSqlParser.KW_SIMILAR: - case PostgreSqlParser.KW_VERBOSE: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_TABLESAMPLE: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.BinaryStringConstant: - case PostgreSqlParser.HexadecimalStringConstant: - case PostgreSqlParser.Integral: - case PostgreSqlParser.Numeric: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - { - this.state = 9891; - this.func_arg_list(); - this.state = 9895; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 6) { - { - this.state = 9892; - this.match(PostgreSqlParser.COMMA); - this.state = 9893; - this.match(PostgreSqlParser.KW_VARIADIC); - this.state = 9894; - this.func_arg_expr(); - } - } - - this.state = 9898; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 83) { - { - this.state = 9897; - this.opt_sort_clause(); - } - } - - } - break; - case PostgreSqlParser.KW_VARIADIC: - { - this.state = 9900; - this.match(PostgreSqlParser.KW_VARIADIC); - this.state = 9901; - this.func_arg_expr(); - this.state = 9903; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 83) { - { - this.state = 9902; - this.opt_sort_clause(); - } - } - - } - break; - case PostgreSqlParser.KW_ALL: - case PostgreSqlParser.KW_DISTINCT: - { - this.state = 9905; - _la = this.tokenStream.LA(1); - if(!(_la === 30 || _la === 56)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 9906; - this.func_arg_list(); - this.state = 9908; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 83) { - { - this.state = 9907; - this.opt_sort_clause(); - } - } - - } - break; - case PostgreSqlParser.STAR: - { - this.state = 9910; - this.match(PostgreSqlParser.STAR); - } - break; - case PostgreSqlParser.CLOSE_PAREN: - // tslint:disable-next-line:no-empty - { - } - break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 9914; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public func_expr(): Func_exprContext { - let localContext = new Func_exprContext(this.context, this.state); - this.enterRule(localContext, 1260, PostgreSqlParser.RULE_func_expr); - try { - this.state = 9928; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1044, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 9917; - this.func_application(); - this.state = 9919; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1041, this.context) ) { - case 1: - { - this.state = 9918; - this.within_group_clause(); - } - break; - } - this.state = 9922; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1042, this.context) ) { - case 1: - { - this.state = 9921; - this.filter_clause(); - } - break; - } - this.state = 9925; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1043, this.context) ) { - case 1: - { - this.state = 9924; - this.over_clause(); - } - break; - } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 9927; - this.func_expr_common_subexpr(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public func_expr_windowless(): Func_expr_windowlessContext { - let localContext = new Func_expr_windowlessContext(this.context, this.state); - this.enterRule(localContext, 1262, PostgreSqlParser.RULE_func_expr_windowless); - try { - this.state = 9932; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1045, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 9930; - this.func_application(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 9931; - this.func_expr_common_subexpr(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public func_expr_common_subexpr(): Func_expr_common_subexprContext { - let localContext = new Func_expr_common_subexprContext(this.context, this.state); - this.enterRule(localContext, 1264, PostgreSqlParser.RULE_func_expr_common_subexpr); - let _la: number; - try { - this.state = 10118; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_COLLATION: - this.enterOuterAlt(localContext, 1); - { - this.state = 9934; - this.match(PostgreSqlParser.KW_COLLATION); - this.state = 9935; - this.match(PostgreSqlParser.KW_FOR); - this.state = 9936; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9937; - this.a_expr(); - this.state = 9938; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_CURRENT_DATE: - this.enterOuterAlt(localContext, 2); - { - this.state = 9940; - this.match(PostgreSqlParser.KW_CURRENT_DATE); - } - break; - case PostgreSqlParser.KW_CURRENT_TIME: - this.enterOuterAlt(localContext, 3); - { - this.state = 9941; - this.match(PostgreSqlParser.KW_CURRENT_TIME); - this.state = 9946; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1046, this.context) ) { - case 1: - { - this.state = 9942; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9943; - this.iconst(); - this.state = 9944; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - break; - case PostgreSqlParser.KW_CURRENT_TIMESTAMP: - this.enterOuterAlt(localContext, 4); - { - this.state = 9948; - this.match(PostgreSqlParser.KW_CURRENT_TIMESTAMP); - this.state = 9953; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1047, this.context) ) { - case 1: - { - this.state = 9949; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9950; - this.iconst(); - this.state = 9951; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - break; - case PostgreSqlParser.KW_LOCALTIME: - this.enterOuterAlt(localContext, 5); - { - this.state = 9955; - this.match(PostgreSqlParser.KW_LOCALTIME); - this.state = 9960; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1048, this.context) ) { - case 1: - { - this.state = 9956; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9957; - this.iconst(); - this.state = 9958; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - break; - case PostgreSqlParser.KW_LOCALTIMESTAMP: - this.enterOuterAlt(localContext, 6); - { - this.state = 9962; - this.match(PostgreSqlParser.KW_LOCALTIMESTAMP); - this.state = 9967; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1049, this.context) ) { - case 1: - { - this.state = 9963; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9964; - this.iconst(); - this.state = 9965; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - break; - case PostgreSqlParser.KW_CURRENT_ROLE: - this.enterOuterAlt(localContext, 7); - { - this.state = 9969; - this.match(PostgreSqlParser.KW_CURRENT_ROLE); - } - break; - case PostgreSqlParser.KW_CURRENT_USER: - this.enterOuterAlt(localContext, 8); - { - this.state = 9970; - this.match(PostgreSqlParser.KW_CURRENT_USER); - } - break; - case PostgreSqlParser.KW_SESSION_USER: - this.enterOuterAlt(localContext, 9); - { - this.state = 9971; - this.match(PostgreSqlParser.KW_SESSION_USER); - } - break; - case PostgreSqlParser.KW_USER: - this.enterOuterAlt(localContext, 10); - { - this.state = 9972; - this.match(PostgreSqlParser.KW_USER); - } - break; - case PostgreSqlParser.KW_CURRENT_CATALOG: - this.enterOuterAlt(localContext, 11); - { - this.state = 9973; - this.match(PostgreSqlParser.KW_CURRENT_CATALOG); - } - break; - case PostgreSqlParser.KW_CURRENT_SCHEMA: - this.enterOuterAlt(localContext, 12); - { - this.state = 9974; - this.match(PostgreSqlParser.KW_CURRENT_SCHEMA); - } - break; - case PostgreSqlParser.KW_CAST: - this.enterOuterAlt(localContext, 13); - { - this.state = 9975; - this.match(PostgreSqlParser.KW_CAST); - this.state = 9976; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9977; - this.a_expr(); - this.state = 9978; - this.match(PostgreSqlParser.KW_AS); - this.state = 9979; - this.typename(); - this.state = 9980; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_EXTRACT: - this.enterOuterAlt(localContext, 14); - { - this.state = 9982; - this.match(PostgreSqlParser.KW_EXTRACT); - this.state = 9983; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9985; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 268451969) !== 0) || ((((_la - 153)) & ~0x1F) === 0 && ((1 << (_la - 153)) & 8929553) !== 0) || ((((_la - 207)) & ~0x1F) === 0 && ((1 << (_la - 207)) & 2057) !== 0) || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & 428867841) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & 268451841) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & 1059905) !== 0) || _la === 360 || _la === 384 || _la === 433 || _la === 434 || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & 3959414785) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & 3071) !== 0) || ((((_la - 549)) & ~0x1F) === 0 && ((1 << (_la - 549)) & 100674083) !== 0) || _la === 584) { - { - this.state = 9984; - this.extract_list(); - } - } - - this.state = 9987; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_NORMALIZE: - this.enterOuterAlt(localContext, 15); - { - this.state = 9988; - this.match(PostgreSqlParser.KW_NORMALIZE); - this.state = 9989; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9990; - this.a_expr(); - this.state = 9993; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 6) { - { - this.state = 9991; - this.match(PostgreSqlParser.COMMA); - this.state = 9992; - this.unicode_normal_form(); - } - } - - this.state = 9995; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_OVERLAY: - this.enterOuterAlt(localContext, 16); - { - this.state = 9997; - this.match(PostgreSqlParser.KW_OVERLAY); - this.state = 9998; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 9999; - this.overlay_list(); - this.state = 10000; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_POSITION: - this.enterOuterAlt(localContext, 17); - { - this.state = 10002; - this.match(PostgreSqlParser.KW_POSITION); - this.state = 10003; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10005; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763019) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { - { - this.state = 10004; - this.position_list(); - } - } - - this.state = 10007; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_SUBSTRING: - this.enterOuterAlt(localContext, 18); - { - this.state = 10008; - this.match(PostgreSqlParser.KW_SUBSTRING); - this.state = 10009; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10011; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { - { - this.state = 10010; - this.substr_list(); - } - } - - this.state = 10013; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_TREAT: - this.enterOuterAlt(localContext, 19); - { - this.state = 10014; - this.match(PostgreSqlParser.KW_TREAT); - this.state = 10015; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10016; - this.a_expr(); - this.state = 10017; - this.match(PostgreSqlParser.KW_AS); - this.state = 10018; - this.typename(); - this.state = 10019; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_TRIM: - this.enterOuterAlt(localContext, 20); - { - this.state = 10021; - this.match(PostgreSqlParser.KW_TRIM); - this.state = 10022; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10024; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 39 || _la === 73 || _la === 95) { - { - this.state = 10023; - _la = this.tokenStream.LA(1); - if(!(_la === 39 || _la === 73 || _la === 95)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - - this.state = 10026; - this.trim_list(); - this.state = 10027; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_NULLIF: - this.enterOuterAlt(localContext, 21); - { - this.state = 10029; - this.match(PostgreSqlParser.KW_NULLIF); - this.state = 10030; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10031; - this.a_expr(); - this.state = 10032; - this.match(PostgreSqlParser.COMMA); - this.state = 10033; - this.a_expr(); - this.state = 10034; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_COALESCE: - this.enterOuterAlt(localContext, 22); - { - this.state = 10036; - this.match(PostgreSqlParser.KW_COALESCE); - this.state = 10037; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10038; - this.expr_list(); - this.state = 10039; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_GREATEST: - this.enterOuterAlt(localContext, 23); - { - this.state = 10041; - this.match(PostgreSqlParser.KW_GREATEST); - this.state = 10042; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10043; - this.expr_list(); - this.state = 10044; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_LEAST: - this.enterOuterAlt(localContext, 24); - { - this.state = 10046; - this.match(PostgreSqlParser.KW_LEAST); - this.state = 10047; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10048; - this.expr_list(); - this.state = 10049; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_XMLCONCAT: - this.enterOuterAlt(localContext, 25); - { - this.state = 10051; - this.match(PostgreSqlParser.KW_XMLCONCAT); - this.state = 10052; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10053; - this.expr_list(); - this.state = 10054; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_XMLELEMENT: - this.enterOuterAlt(localContext, 26); - { - this.state = 10056; - this.match(PostgreSqlParser.KW_XMLELEMENT); - this.state = 10057; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10058; - this.match(PostgreSqlParser.KW_NAME); - this.state = 10059; - this.collabel(); - this.state = 10065; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 6) { - { - this.state = 10060; - this.match(PostgreSqlParser.COMMA); - this.state = 10063; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1055, this.context) ) { - case 1: - { - this.state = 10061; - this.xml_attributes(); - } - break; - case 2: - { - this.state = 10062; - this.expr_list(); - } - break; - } - } - } - - this.state = 10067; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_XMLEXISTS: - this.enterOuterAlt(localContext, 27); - { - this.state = 10069; - this.match(PostgreSqlParser.KW_XMLEXISTS); - this.state = 10070; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10071; - this.c_expr(); - this.state = 10072; - this.xmlexists_argument(); - this.state = 10073; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_XMLFOREST: - this.enterOuterAlt(localContext, 28); - { - this.state = 10075; - this.match(PostgreSqlParser.KW_XMLFOREST); - this.state = 10076; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10077; - this.xml_attribute_list(); - this.state = 10078; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_XMLPARSE: - this.enterOuterAlt(localContext, 29); - { - this.state = 10080; - this.match(PostgreSqlParser.KW_XMLPARSE); - this.state = 10081; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10082; - this.document_or_content(); - this.state = 10083; - this.a_expr(); - this.state = 10085; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 292 || _la === 347) { - { - this.state = 10084; - this.xml_whitespace_option(); - } - } - - this.state = 10087; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_XMLPI: - this.enterOuterAlt(localContext, 30); - { - this.state = 10089; - this.match(PostgreSqlParser.KW_XMLPI); - this.state = 10090; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10091; - this.match(PostgreSqlParser.KW_NAME); - this.state = 10092; - this.collabel(); - this.state = 10095; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 6) { - { - this.state = 10093; - this.match(PostgreSqlParser.COMMA); - this.state = 10094; - this.a_expr(); - } - } - - this.state = 10097; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_XMLROOT: - this.enterOuterAlt(localContext, 31); - { - this.state = 10099; - this.match(PostgreSqlParser.KW_XMLROOT); - this.state = 10100; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10101; - this.match(PostgreSqlParser.KW_XML); - this.state = 10102; - this.a_expr(); - this.state = 10103; - this.match(PostgreSqlParser.COMMA); - this.state = 10104; - this.xml_root_version(); - this.state = 10106; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 6) { - { - this.state = 10105; - this.opt_xml_root_standalone(); - } - } - - this.state = 10108; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.KW_XMLSERIALIZE: - this.enterOuterAlt(localContext, 32); - { - this.state = 10110; - this.match(PostgreSqlParser.KW_XMLSERIALIZE); - this.state = 10111; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10112; - this.document_or_content(); - this.state = 10113; - this.a_expr(); - this.state = 10114; - this.match(PostgreSqlParser.KW_AS); - this.state = 10115; - this.simpletypename(); - this.state = 10116; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public xml_root_version(): Xml_root_versionContext { - let localContext = new Xml_root_versionContext(this.context, this.state); - this.enterRule(localContext, 1266, PostgreSqlParser.RULE_xml_root_version); - try { - this.state = 10125; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1061, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10120; - this.match(PostgreSqlParser.KW_VERSION); - this.state = 10121; - this.a_expr(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10122; - this.match(PostgreSqlParser.KW_VERSION); - this.state = 10123; - this.match(PostgreSqlParser.KW_NO); - this.state = 10124; - this.match(PostgreSqlParser.KW_VALUE); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_xml_root_standalone(): Opt_xml_root_standaloneContext { - let localContext = new Opt_xml_root_standaloneContext(this.context, this.state); - this.enterRule(localContext, 1268, PostgreSqlParser.RULE_opt_xml_root_standalone); - try { - this.state = 10137; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1062, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10127; - this.match(PostgreSqlParser.COMMA); - this.state = 10128; - this.match(PostgreSqlParser.KW_STANDALONE); - this.state = 10129; - this.match(PostgreSqlParser.KW_YES); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10130; - this.match(PostgreSqlParser.COMMA); - this.state = 10131; - this.match(PostgreSqlParser.KW_STANDALONE); - this.state = 10132; - this.match(PostgreSqlParser.KW_NO); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10133; - this.match(PostgreSqlParser.COMMA); - this.state = 10134; - this.match(PostgreSqlParser.KW_STANDALONE); - this.state = 10135; - this.match(PostgreSqlParser.KW_NO); - this.state = 10136; - this.match(PostgreSqlParser.KW_VALUE); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public xml_attributes(): Xml_attributesContext { - let localContext = new Xml_attributesContext(this.context, this.state); - this.enterRule(localContext, 1270, PostgreSqlParser.RULE_xml_attributes); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10139; - this.match(PostgreSqlParser.KW_XMLATTRIBUTES); - this.state = 10140; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10141; - this.xml_attribute_list(); - this.state = 10142; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public xml_attribute_list(): Xml_attribute_listContext { - let localContext = new Xml_attribute_listContext(this.context, this.state); - this.enterRule(localContext, 1272, PostgreSqlParser.RULE_xml_attribute_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10144; - this.xml_attribute_el(); - this.state = 10149; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10145; - this.match(PostgreSqlParser.COMMA); - this.state = 10146; - this.xml_attribute_el(); - } - } - this.state = 10151; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public xml_attribute_el(): Xml_attribute_elContext { - let localContext = new Xml_attribute_elContext(this.context, this.state); - this.enterRule(localContext, 1274, PostgreSqlParser.RULE_xml_attribute_el); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10152; - this.a_expr(); - this.state = 10155; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 36) { - { - this.state = 10153; - this.match(PostgreSqlParser.KW_AS); - this.state = 10154; - this.collabel(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public document_or_content(): Document_or_contentContext { - let localContext = new Document_or_contentContext(this.context, this.state); - this.enterRule(localContext, 1276, PostgreSqlParser.RULE_document_or_content); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10157; - _la = this.tokenStream.LA(1); - if(!(_la === 166 || _la === 188)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public xml_whitespace_option(): Xml_whitespace_optionContext { - let localContext = new Xml_whitespace_optionContext(this.context, this.state); - this.enterRule(localContext, 1278, PostgreSqlParser.RULE_xml_whitespace_option); - try { - this.state = 10163; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_PRESERVE: - this.enterOuterAlt(localContext, 1); - { - this.state = 10159; - this.match(PostgreSqlParser.KW_PRESERVE); - this.state = 10160; - this.match(PostgreSqlParser.KW_WHITESPACE); - } - break; - case PostgreSqlParser.KW_STRIP: - this.enterOuterAlt(localContext, 2); - { - this.state = 10161; - this.match(PostgreSqlParser.KW_STRIP); - this.state = 10162; - this.match(PostgreSqlParser.KW_WHITESPACE); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public xmlexists_argument(): Xmlexists_argumentContext { - let localContext = new Xmlexists_argumentContext(this.context, this.state); - this.enterRule(localContext, 1280, PostgreSqlParser.RULE_xmlexists_argument); - try { - this.state = 10180; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1066, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10165; - this.match(PostgreSqlParser.KW_PASSING); - this.state = 10166; - this.c_expr(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10167; - this.match(PostgreSqlParser.KW_PASSING); - this.state = 10168; - this.c_expr(); - this.state = 10169; - this.xml_passing_mech(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10171; - this.match(PostgreSqlParser.KW_PASSING); - this.state = 10172; - this.xml_passing_mech(); - this.state = 10173; - this.c_expr(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10175; - this.match(PostgreSqlParser.KW_PASSING); - this.state = 10176; - this.xml_passing_mech(); - this.state = 10177; - this.c_expr(); - this.state = 10178; - this.xml_passing_mech(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public xml_passing_mech(): Xml_passing_mechContext { - let localContext = new Xml_passing_mechContext(this.context, this.state); - this.enterRule(localContext, 1282, PostgreSqlParser.RULE_xml_passing_mech); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10182; - this.match(PostgreSqlParser.KW_BY); - this.state = 10183; - _la = this.tokenStream.LA(1); - if(!(_la === 304 || _la === 450)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public within_group_clause(): Within_group_clauseContext { - let localContext = new Within_group_clauseContext(this.context, this.state); - this.enterRule(localContext, 1284, PostgreSqlParser.RULE_within_group_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10185; - this.match(PostgreSqlParser.KW_WITHIN); - this.state = 10186; - this.match(PostgreSqlParser.KW_GROUP); - this.state = 10187; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10188; - this.sort_clause(); - this.state = 10189; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public filter_clause(): Filter_clauseContext { - let localContext = new Filter_clauseContext(this.context, this.state); - this.enterRule(localContext, 1286, PostgreSqlParser.RULE_filter_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10191; - this.match(PostgreSqlParser.KW_FILTER); - this.state = 10192; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10193; - this.match(PostgreSqlParser.KW_WHERE); - this.state = 10194; - this.a_expr(); - this.state = 10195; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public window_clause(): Window_clauseContext { - let localContext = new Window_clauseContext(this.context, this.state); - this.enterRule(localContext, 1288, PostgreSqlParser.RULE_window_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10197; - this.match(PostgreSqlParser.KW_WINDOW); - this.state = 10198; - this.window_definition_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public window_definition_list(): Window_definition_listContext { - let localContext = new Window_definition_listContext(this.context, this.state); - this.enterRule(localContext, 1290, PostgreSqlParser.RULE_window_definition_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 10200; - this.window_definition(); - this.state = 10205; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1067, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 10201; - this.match(PostgreSqlParser.COMMA); - this.state = 10202; - this.window_definition(); - } - } - } - this.state = 10207; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1067, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public window_definition(): Window_definitionContext { - let localContext = new Window_definitionContext(this.context, this.state); - this.enterRule(localContext, 1292, PostgreSqlParser.RULE_window_definition); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10208; - this.colid(); - this.state = 10209; - this.match(PostgreSqlParser.KW_AS); - this.state = 10210; - this.window_specification(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public over_clause(): Over_clauseContext { - let localContext = new Over_clauseContext(this.context, this.state); - this.enterRule(localContext, 1294, PostgreSqlParser.RULE_over_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10212; - this.match(PostgreSqlParser.KW_OVER); - this.state = 10215; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.OPEN_PAREN: - { - this.state = 10213; - this.window_specification(); - } - break; - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - { - this.state = 10214; - this.colid(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public window_specification(): Window_specificationContext { - let localContext = new Window_specificationContext(this.context, this.state); - this.enterRule(localContext, 1296, PostgreSqlParser.RULE_window_specification); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10217; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10219; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1069, this.context) ) { - case 1: - { - this.state = 10218; - this.opt_existing_window_name(); - } - break; - } - this.state = 10222; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 285) { - { - this.state = 10221; - this.opt_partition_clause(); - } - } - - this.state = 10225; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 83) { - { - this.state = 10224; - this.opt_sort_clause(); - } - } - - this.state = 10228; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 299 || _la === 320 || _la === 481) { - { - this.state = 10227; - this.opt_frame_clause(); - } - } - - this.state = 10230; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_existing_window_name(): Opt_existing_window_nameContext { - let localContext = new Opt_existing_window_nameContext(this.context, this.state); - this.enterRule(localContext, 1298, PostgreSqlParser.RULE_opt_existing_window_name); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10232; - this.colid(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_partition_clause(): Opt_partition_clauseContext { - let localContext = new Opt_partition_clauseContext(this.context, this.state); - this.enterRule(localContext, 1300, PostgreSqlParser.RULE_opt_partition_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10234; - this.match(PostgreSqlParser.KW_PARTITION); - this.state = 10235; - this.match(PostgreSqlParser.KW_BY); - this.state = 10236; - this.expr_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_frame_clause(): Opt_frame_clauseContext { - let localContext = new Opt_frame_clauseContext(this.context, this.state); - this.enterRule(localContext, 1302, PostgreSqlParser.RULE_opt_frame_clause); - let _la: number; - try { - this.state = 10253; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_RANGE: - this.enterOuterAlt(localContext, 1); - { - this.state = 10238; - this.match(PostgreSqlParser.KW_RANGE); - this.state = 10239; - this.frame_extent(); - this.state = 10241; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 199) { - { - this.state = 10240; - this.opt_window_exclusion_clause(); - } - } - - } - break; - case PostgreSqlParser.KW_ROWS: - this.enterOuterAlt(localContext, 2); - { - this.state = 10243; - this.match(PostgreSqlParser.KW_ROWS); - this.state = 10244; - this.frame_extent(); - this.state = 10246; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 199) { - { - this.state = 10245; - this.opt_window_exclusion_clause(); - } - } - - } - break; - case PostgreSqlParser.KW_GROUPS: - this.enterOuterAlt(localContext, 3); - { - this.state = 10248; - this.match(PostgreSqlParser.KW_GROUPS); - this.state = 10249; - this.frame_extent(); - this.state = 10251; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 199) { - { - this.state = 10250; - this.opt_window_exclusion_clause(); - } - } - - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public frame_extent(): Frame_extentContext { - let localContext = new Frame_extentContext(this.context, this.state); - this.enterRule(localContext, 1304, PostgreSqlParser.RULE_frame_extent); - try { - this.state = 10261; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1077, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10255; - this.frame_bound(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10256; - this.match(PostgreSqlParser.KW_BETWEEN); - this.state = 10257; - this.frame_bound(); - this.state = 10258; - this.match(PostgreSqlParser.KW_AND); - this.state = 10259; - this.frame_bound(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public frame_bound(): Frame_boundContext { - let localContext = new Frame_boundContext(this.context, this.state); - this.enterRule(localContext, 1306, PostgreSqlParser.RULE_frame_bound); - let _la: number; - try { - this.state = 10270; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1078, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10263; - this.match(PostgreSqlParser.KW_UNBOUNDED); - this.state = 10264; - _la = this.tokenStream.LA(1); - if(!(_la === 208 || _la === 289)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10265; - this.match(PostgreSqlParser.KW_CURRENT); - this.state = 10266; - this.match(PostgreSqlParser.KW_ROW); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10267; - this.a_expr(); - this.state = 10268; - _la = this.tokenStream.LA(1); - if(!(_la === 208 || _la === 289)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_window_exclusion_clause(): Opt_window_exclusion_clauseContext { - let localContext = new Opt_window_exclusion_clauseContext(this.context, this.state); - this.enterRule(localContext, 1308, PostgreSqlParser.RULE_opt_window_exclusion_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10272; - this.match(PostgreSqlParser.KW_EXCLUDE); - this.state = 10279; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_CURRENT: - { - this.state = 10273; - this.match(PostgreSqlParser.KW_CURRENT); - this.state = 10274; - this.match(PostgreSqlParser.KW_ROW); - } - break; - case PostgreSqlParser.KW_GROUP: - { - this.state = 10275; - this.match(PostgreSqlParser.KW_GROUP); - } - break; - case PostgreSqlParser.KW_TIES: - { - this.state = 10276; - this.match(PostgreSqlParser.KW_TIES); - } - break; - case PostgreSqlParser.KW_NO: - { - this.state = 10277; - this.match(PostgreSqlParser.KW_NO); - this.state = 10278; - this.match(PostgreSqlParser.KW_OTHERS); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public row(): RowContext { - let localContext = new RowContext(this.context, this.state); - this.enterRule(localContext, 1310, PostgreSqlParser.RULE_row); - let _la: number; - try { - this.state = 10293; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_ROW: - this.enterOuterAlt(localContext, 1); - { - this.state = 10281; - this.match(PostgreSqlParser.KW_ROW); - this.state = 10282; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10284; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { - { - this.state = 10283; - this.expr_list(); - } - } - - this.state = 10286; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case PostgreSqlParser.OPEN_PAREN: - this.enterOuterAlt(localContext, 2); - { - this.state = 10287; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10288; - this.expr_list(); - this.state = 10289; - this.match(PostgreSqlParser.COMMA); - this.state = 10290; - this.a_expr(); - this.state = 10291; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public explicit_row(): Explicit_rowContext { - let localContext = new Explicit_rowContext(this.context, this.state); - this.enterRule(localContext, 1312, PostgreSqlParser.RULE_explicit_row); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10295; - this.match(PostgreSqlParser.KW_ROW); - this.state = 10296; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10298; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { - { - this.state = 10297; - this.expr_list(); - } - } - - this.state = 10300; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public implicit_row(): Implicit_rowContext { - let localContext = new Implicit_rowContext(this.context, this.state); - this.enterRule(localContext, 1314, PostgreSqlParser.RULE_implicit_row); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10302; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10303; - this.a_expr(); - this.state = 10304; - this.match(PostgreSqlParser.COMMA); - this.state = 10305; - this.expr_list(); - this.state = 10306; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public sub_type(): Sub_typeContext { - let localContext = new Sub_typeContext(this.context, this.state); - this.enterRule(localContext, 1316, PostgreSqlParser.RULE_sub_type); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10308; - _la = this.tokenStream.LA(1); - if(!(_la === 30 || _la === 34 || _la === 90)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public all_op(): All_opContext { - let localContext = new All_opContext(this.context, this.state); - this.enterRule(localContext, 1318, PostgreSqlParser.RULE_all_op); - try { - this.state = 10312; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.Operator: - this.enterOuterAlt(localContext, 1); - { - this.state = 10310; - this.match(PostgreSqlParser.Operator); - } - break; - case PostgreSqlParser.STAR: - case PostgreSqlParser.EQUAL: - case PostgreSqlParser.PLUS: - case PostgreSqlParser.MINUS: - case PostgreSqlParser.SLASH: - case PostgreSqlParser.CARET: - case PostgreSqlParser.LT: - case PostgreSqlParser.GT: - case PostgreSqlParser.LESS_EQUALS: - case PostgreSqlParser.GREATER_EQUALS: - case PostgreSqlParser.NOT_EQUALS: - case PostgreSqlParser.PERCENT: - this.enterOuterAlt(localContext, 2); - { - this.state = 10311; - this.mathop(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public mathop(): MathopContext { - let localContext = new MathopContext(this.context, this.state); - this.enterRule(localContext, 1320, PostgreSqlParser.RULE_mathop); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10314; - _la = this.tokenStream.LA(1); - if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 178517504) !== 0))) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public qual_op(): Qual_opContext { - let localContext = new Qual_opContext(this.context, this.state); - this.enterRule(localContext, 1322, PostgreSqlParser.RULE_qual_op); - try { - this.state = 10322; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.Operator: - this.enterOuterAlt(localContext, 1); - { - this.state = 10316; - this.match(PostgreSqlParser.Operator); - } - break; - case PostgreSqlParser.KW_OPERATOR: - this.enterOuterAlt(localContext, 2); - { - this.state = 10317; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 10318; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10319; - this.any_operator(); - this.state = 10320; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public qual_all_op(): Qual_all_opContext { - let localContext = new Qual_all_opContext(this.context, this.state); - this.enterRule(localContext, 1324, PostgreSqlParser.RULE_qual_all_op); - try { - this.state = 10330; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.STAR: - case PostgreSqlParser.EQUAL: - case PostgreSqlParser.PLUS: - case PostgreSqlParser.MINUS: - case PostgreSqlParser.SLASH: - case PostgreSqlParser.CARET: - case PostgreSqlParser.LT: - case PostgreSqlParser.GT: - case PostgreSqlParser.LESS_EQUALS: - case PostgreSqlParser.GREATER_EQUALS: - case PostgreSqlParser.NOT_EQUALS: - case PostgreSqlParser.PERCENT: - case PostgreSqlParser.Operator: - this.enterOuterAlt(localContext, 1); - { - this.state = 10324; - this.all_op(); - } - break; - case PostgreSqlParser.KW_OPERATOR: - this.enterOuterAlt(localContext, 2); - { - this.state = 10325; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 10326; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10327; - this.any_operator(); - this.state = 10328; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public subquery_Op(): Subquery_OpContext { - let localContext = new Subquery_OpContext(this.context, this.state); - this.enterRule(localContext, 1326, PostgreSqlParser.RULE_subquery_Op); - try { - this.state = 10344; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1086, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10332; - this.all_op(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10333; - this.match(PostgreSqlParser.KW_OPERATOR); - this.state = 10334; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10335; - this.any_operator(); - this.state = 10336; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10338; - this.match(PostgreSqlParser.KW_LIKE); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10339; - this.match(PostgreSqlParser.KW_NOT); - this.state = 10340; - this.match(PostgreSqlParser.KW_LIKE); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 10341; - this.match(PostgreSqlParser.KW_ILIKE); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 10342; - this.match(PostgreSqlParser.KW_NOT); - this.state = 10343; - this.match(PostgreSqlParser.KW_ILIKE); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public expr_list(): Expr_listContext { - let localContext = new Expr_listContext(this.context, this.state); - this.enterRule(localContext, 1328, PostgreSqlParser.RULE_expr_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 10346; - this.a_expr(); - this.state = 10351; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1087, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 10347; - this.match(PostgreSqlParser.COMMA); - this.state = 10348; - this.a_expr(); - } - } - } - this.state = 10353; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1087, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public column_expr_list_noparen(): Column_expr_list_noparenContext { - let localContext = new Column_expr_list_noparenContext(this.context, this.state); - this.enterRule(localContext, 1330, PostgreSqlParser.RULE_column_expr_list_noparen); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10354; - this.column_expr_noparen(); - this.state = 10359; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10355; - this.match(PostgreSqlParser.COMMA); - this.state = 10356; - this.column_expr_noparen(); - } - } - this.state = 10361; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public column_expr_list(): Column_expr_listContext { - let localContext = new Column_expr_listContext(this.context, this.state); - this.enterRule(localContext, 1332, PostgreSqlParser.RULE_column_expr_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10362; - this.column_expr(); - this.state = 10367; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10363; - this.match(PostgreSqlParser.COMMA); - this.state = 10364; - this.column_expr(); - } - } - this.state = 10369; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public column_expr(): Column_exprContext { - let localContext = new Column_exprContext(this.context, this.state); - this.enterRule(localContext, 1334, PostgreSqlParser.RULE_column_expr); - try { - this.state = 10375; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1090, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - { - this.state = 10370; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10371; - this.a_expr(); - this.state = 10372; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10374; - this.column_name(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public column_expr_noparen(): Column_expr_noparenContext { - let localContext = new Column_expr_noparenContext(this.context, this.state); - this.enterRule(localContext, 1336, PostgreSqlParser.RULE_column_expr_noparen); - try { - this.state = 10379; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1091, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10377; - this.a_expr(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10378; - this.column_name(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public func_arg_list(): Func_arg_listContext { - let localContext = new Func_arg_listContext(this.context, this.state); - this.enterRule(localContext, 1338, PostgreSqlParser.RULE_func_arg_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 10381; - this.func_arg_expr(); - this.state = 10386; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1092, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 10382; - this.match(PostgreSqlParser.COMMA); - this.state = 10383; - this.func_arg_expr(); - } - } - } - this.state = 10388; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1092, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public func_arg_expr(): Func_arg_exprContext { - let localContext = new Func_arg_exprContext(this.context, this.state); - this.enterRule(localContext, 1340, PostgreSqlParser.RULE_func_arg_expr); - let _la: number; - try { - this.state = 10394; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1093, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10389; - this.a_expr(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10390; - this.param_name(); - this.state = 10391; - _la = this.tokenStream.LA(1); - if(!(_la === 20 || _la === 22)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 10392; - this.a_expr(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public type_list(): Type_listContext { - let localContext = new Type_listContext(this.context, this.state); - this.enterRule(localContext, 1342, PostgreSqlParser.RULE_type_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10396; - this.typename(); - this.state = 10401; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10397; - this.match(PostgreSqlParser.COMMA); - this.state = 10398; - this.typename(); - } - } - this.state = 10403; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public array_expr(): Array_exprContext { - let localContext = new Array_exprContext(this.context, this.state); - this.enterRule(localContext, 1344, PostgreSqlParser.RULE_array_expr); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10404; - this.match(PostgreSqlParser.OPEN_BRACKET); - this.state = 10407; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.OPEN_PAREN: - case PostgreSqlParser.PLUS: - case PostgreSqlParser.MINUS: - case PostgreSqlParser.PARAM: - case PostgreSqlParser.Operator: - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_CASE: - case PostgreSqlParser.KW_CAST: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_CURRENT_CATALOG: - case PostgreSqlParser.KW_CURRENT_DATE: - case PostgreSqlParser.KW_CURRENT_ROLE: - case PostgreSqlParser.KW_CURRENT_TIME: - case PostgreSqlParser.KW_CURRENT_TIMESTAMP: - case PostgreSqlParser.KW_CURRENT_USER: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FALSE: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_LOCALTIME: - case PostgreSqlParser.KW_LOCALTIMESTAMP: - case PostgreSqlParser.KW_NOT: - case PostgreSqlParser.KW_NULL: - case PostgreSqlParser.KW_SESSION_USER: - case PostgreSqlParser.KW_TRUE: - case PostgreSqlParser.KW_UNIQUE: - case PostgreSqlParser.KW_USER: - case PostgreSqlParser.KW_AUTHORIZATION: - case PostgreSqlParser.KW_BINARY: - case PostgreSqlParser.KW_COLLATION: - case PostgreSqlParser.KW_CONCURRENTLY: - case PostgreSqlParser.KW_CROSS: - case PostgreSqlParser.KW_CURRENT_SCHEMA: - case PostgreSqlParser.KW_FREEZE: - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_ILIKE: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_ISNULL: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_LIKE: - case PostgreSqlParser.KW_NATURAL: - case PostgreSqlParser.KW_NOTNULL: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_OVERLAPS: - case PostgreSqlParser.KW_RIGHT: - case PostgreSqlParser.KW_SIMILAR: - case PostgreSqlParser.KW_VERBOSE: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_TABLESAMPLE: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.BinaryStringConstant: - case PostgreSqlParser.HexadecimalStringConstant: - case PostgreSqlParser.Integral: - case PostgreSqlParser.Numeric: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - { - this.state = 10405; - this.expr_list(); - } - break; - case PostgreSqlParser.OPEN_BRACKET: - { - this.state = 10406; - this.array_expr_list(); - } - break; - case PostgreSqlParser.CLOSE_BRACKET: - break; - default: - break; - } - this.state = 10409; - this.match(PostgreSqlParser.CLOSE_BRACKET); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public array_expr_list(): Array_expr_listContext { - let localContext = new Array_expr_listContext(this.context, this.state); - this.enterRule(localContext, 1346, PostgreSqlParser.RULE_array_expr_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10411; - this.array_expr(); - this.state = 10416; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10412; - this.match(PostgreSqlParser.COMMA); - this.state = 10413; - this.array_expr(); - } - } - this.state = 10418; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public extract_list(): Extract_listContext { - let localContext = new Extract_listContext(this.context, this.state); - this.enterRule(localContext, 1348, PostgreSqlParser.RULE_extract_list); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10419; - this.extract_arg(); - this.state = 10420; - this.match(PostgreSqlParser.KW_FROM); - this.state = 10421; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public extract_arg(): Extract_argContext { - let localContext = new Extract_argContext(this.context, this.state); - this.enterRule(localContext, 1350, PostgreSqlParser.RULE_extract_arg); - try { - this.state = 10431; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1097, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10423; - this.identifier(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10424; - this.match(PostgreSqlParser.KW_YEAR); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10425; - this.match(PostgreSqlParser.KW_MONTH); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10426; - this.match(PostgreSqlParser.KW_DAY); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 10427; - this.match(PostgreSqlParser.KW_HOUR); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 10428; - this.match(PostgreSqlParser.KW_MINUTE); - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 10429; - this.match(PostgreSqlParser.KW_SECOND); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 10430; - this.sconst(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public unicode_normal_form(): Unicode_normal_formContext { - let localContext = new Unicode_normal_formContext(this.context, this.state); - this.enterRule(localContext, 1352, PostgreSqlParser.RULE_unicode_normal_form); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10433; - _la = this.tokenStream.LA(1); - if(!(((((_la - 483)) & ~0x1F) === 0 && ((1 << (_la - 483)) & 15) !== 0))) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public overlay_list(): Overlay_listContext { - let localContext = new Overlay_listContext(this.context, this.state); - this.enterRule(localContext, 1354, PostgreSqlParser.RULE_overlay_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10435; - this.a_expr(); - this.state = 10436; - this.match(PostgreSqlParser.KW_PLACING); - this.state = 10437; - this.a_expr(); - this.state = 10438; - this.match(PostgreSqlParser.KW_FROM); - this.state = 10439; - this.a_expr(); - this.state = 10442; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 62) { - { - this.state = 10440; - this.match(PostgreSqlParser.KW_FOR); - this.state = 10441; - this.a_expr(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public position_list(): Position_listContext { - let localContext = new Position_listContext(this.context, this.state); - this.enterRule(localContext, 1356, PostgreSqlParser.RULE_position_list); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10444; - this.b_expr(0); - this.state = 10445; - this.match(PostgreSqlParser.KW_IN); - this.state = 10446; - this.b_expr(0); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public substr_list(): Substr_listContext { - let localContext = new Substr_listContext(this.context, this.state); - this.enterRule(localContext, 1358, PostgreSqlParser.RULE_substr_list); - try { - this.state = 10475; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1099, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10448; - this.a_expr(); - this.state = 10449; - this.match(PostgreSqlParser.KW_FROM); - this.state = 10450; - this.a_expr(); - this.state = 10451; - this.match(PostgreSqlParser.KW_FOR); - this.state = 10452; - this.a_expr(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10454; - this.a_expr(); - this.state = 10455; - this.match(PostgreSqlParser.KW_FOR); - this.state = 10456; - this.a_expr(); - this.state = 10457; - this.match(PostgreSqlParser.KW_FROM); - this.state = 10458; - this.a_expr(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10460; - this.a_expr(); - this.state = 10461; - this.match(PostgreSqlParser.KW_FROM); - this.state = 10462; - this.a_expr(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10464; - this.a_expr(); - this.state = 10465; - this.match(PostgreSqlParser.KW_FOR); - this.state = 10466; - this.a_expr(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 10468; - this.a_expr(); - this.state = 10469; - this.match(PostgreSqlParser.KW_SIMILAR); - this.state = 10470; - this.a_expr(); - this.state = 10471; - this.match(PostgreSqlParser.KW_ESCAPE); - this.state = 10472; - this.a_expr(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 10474; - this.expr_list(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public trim_list(): Trim_listContext { - let localContext = new Trim_listContext(this.context, this.state); - this.enterRule(localContext, 1360, PostgreSqlParser.RULE_trim_list); - try { - this.state = 10484; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1100, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10477; - this.a_expr(); - this.state = 10478; - this.match(PostgreSqlParser.KW_FROM); - this.state = 10479; - this.expr_list(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10481; - this.match(PostgreSqlParser.KW_FROM); - this.state = 10482; - this.expr_list(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10483; - this.expr_list(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public in_expr(): In_exprContext { - let localContext = new In_exprContext(this.context, this.state); - this.enterRule(localContext, 1362, PostgreSqlParser.RULE_in_expr); - try { - this.state = 10491; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1101, this.context) ) { - case 1: - localContext = new In_expr_selectContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10486; - this.select_with_parens(); - } - break; - case 2: - localContext = new In_expr_listContext(localContext); - this.enterOuterAlt(localContext, 2); - { - this.state = 10487; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10488; - this.expr_list(); - this.state = 10489; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public case_expr(): Case_exprContext { - let localContext = new Case_exprContext(this.context, this.state); - this.enterRule(localContext, 1364, PostgreSqlParser.RULE_case_expr); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10493; - this.match(PostgreSqlParser.KW_CASE); - this.state = 10495; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { - { - this.state = 10494; - this.case_arg(); - } - } - - this.state = 10497; - this.when_clause_list(); - this.state = 10499; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 58) { - { - this.state = 10498; - this.case_default(); - } - } - - this.state = 10501; - this.match(PostgreSqlParser.KW_END); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public when_clause_list(): When_clause_listContext { - let localContext = new When_clause_listContext(this.context, this.state); - this.enterRule(localContext, 1366, PostgreSqlParser.RULE_when_clause_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10504; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - do { - { - { - this.state = 10503; - this.when_clause(); - } - } - this.state = 10506; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } while (_la === 102); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public when_clause(): When_clauseContext { - let localContext = new When_clauseContext(this.context, this.state); - this.enterRule(localContext, 1368, PostgreSqlParser.RULE_when_clause); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10508; - this.match(PostgreSqlParser.KW_WHEN); - this.state = 10509; - this.a_expr(); - this.state = 10510; - this.match(PostgreSqlParser.KW_THEN); - this.state = 10511; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public case_default(): Case_defaultContext { - let localContext = new Case_defaultContext(this.context, this.state); - this.enterRule(localContext, 1370, PostgreSqlParser.RULE_case_default); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10513; - this.match(PostgreSqlParser.KW_ELSE); - this.state = 10514; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public case_arg(): Case_argContext { - let localContext = new Case_argContext(this.context, this.state); - this.enterRule(localContext, 1372, PostgreSqlParser.RULE_case_arg); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10516; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public columnref(): ColumnrefContext { - let localContext = new ColumnrefContext(this.context, this.state); - this.enterRule(localContext, 1374, PostgreSqlParser.RULE_columnref); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10518; - this.colid(); - this.state = 10520; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1105, this.context) ) { - case 1: - { - this.state = 10519; - this.indirection(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public indirection_el(): Indirection_elContext { - let localContext = new Indirection_elContext(this.context, this.state); - this.enterRule(localContext, 1376, PostgreSqlParser.RULE_indirection_el); - let _la: number; - try { - this.state = 10539; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.DOT: - this.enterOuterAlt(localContext, 1); - { - this.state = 10522; - this.match(PostgreSqlParser.DOT); - this.state = 10525; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_ALL: - case PostgreSqlParser.KW_ANALYSE: - case PostgreSqlParser.KW_ANALYZE: - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ANY: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_AS: - case PostgreSqlParser.KW_ASC: - case PostgreSqlParser.KW_ASYMMETRIC: - case PostgreSqlParser.KW_BOTH: - case PostgreSqlParser.KW_CASE: - case PostgreSqlParser.KW_CAST: - case PostgreSqlParser.KW_CHECK: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_COLUMN: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_CREATE: - case PostgreSqlParser.KW_CURRENT_CATALOG: - case PostgreSqlParser.KW_CURRENT_DATE: - case PostgreSqlParser.KW_CURRENT_ROLE: - case PostgreSqlParser.KW_CURRENT_TIME: - case PostgreSqlParser.KW_CURRENT_TIMESTAMP: - case PostgreSqlParser.KW_CURRENT_USER: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DEFERRABLE: - case PostgreSqlParser.KW_DESC: - case PostgreSqlParser.KW_DISTINCT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_ELSE: - case PostgreSqlParser.KW_EXCEPT: - case PostgreSqlParser.KW_FALSE: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_FOR: - case PostgreSqlParser.KW_FOREIGN: - case PostgreSqlParser.KW_FROM: - case PostgreSqlParser.KW_GRANT: - case PostgreSqlParser.KW_GROUP: - case PostgreSqlParser.KW_HAVING: - case PostgreSqlParser.KW_IN: - case PostgreSqlParser.KW_INITIALLY: - case PostgreSqlParser.KW_INTERSECT: - case PostgreSqlParser.KW_LATERAL: - case PostgreSqlParser.KW_LEADING: - case PostgreSqlParser.KW_LIMIT: - case PostgreSqlParser.KW_LOCALTIME: - case PostgreSqlParser.KW_LOCALTIMESTAMP: - case PostgreSqlParser.KW_NOT: - case PostgreSqlParser.KW_NULL: - case PostgreSqlParser.KW_OFFSET: - case PostgreSqlParser.KW_ON: - case PostgreSqlParser.KW_ONLY: - case PostgreSqlParser.KW_OR: - case PostgreSqlParser.KW_ORDER: - case PostgreSqlParser.KW_PLACING: - case PostgreSqlParser.KW_PRIMARY: - case PostgreSqlParser.KW_REFERENCES: - case PostgreSqlParser.KW_RETURNING: - case PostgreSqlParser.KW_SELECT: - case PostgreSqlParser.KW_SESSION_USER: - case PostgreSqlParser.KW_SOME: - case PostgreSqlParser.KW_SYMMETRIC: - case PostgreSqlParser.KW_TABLE: - case PostgreSqlParser.KW_THEN: - case PostgreSqlParser.KW_TO: - case PostgreSqlParser.KW_TRAILING: - case PostgreSqlParser.KW_TRUE: - case PostgreSqlParser.KW_UNION: - case PostgreSqlParser.KW_UNIQUE: - case PostgreSqlParser.KW_USER: - case PostgreSqlParser.KW_USING: - case PostgreSqlParser.KW_VARIADIC: - case PostgreSqlParser.KW_WHEN: - case PostgreSqlParser.KW_WHERE: - case PostgreSqlParser.KW_WINDOW: - case PostgreSqlParser.KW_WITH: - case PostgreSqlParser.KW_AUTHORIZATION: - case PostgreSqlParser.KW_BINARY: - case PostgreSqlParser.KW_COLLATION: - case PostgreSqlParser.KW_CONCURRENTLY: - case PostgreSqlParser.KW_CROSS: - case PostgreSqlParser.KW_CURRENT_SCHEMA: - case PostgreSqlParser.KW_FREEZE: - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_ILIKE: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_ISNULL: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_LIKE: - case PostgreSqlParser.KW_NATURAL: - case PostgreSqlParser.KW_NOTNULL: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_OVERLAPS: - case PostgreSqlParser.KW_RIGHT: - case PostgreSqlParser.KW_SIMILAR: - case PostgreSqlParser.KW_VERBOSE: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_END: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_TABLESAMPLE: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - { - this.state = 10523; - this.attr_name(); - } - break; - case PostgreSqlParser.STAR: - { - this.state = 10524; - this.match(PostgreSqlParser.STAR); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case PostgreSqlParser.OPEN_BRACKET: - this.enterOuterAlt(localContext, 2); - { - this.state = 10527; - this.match(PostgreSqlParser.OPEN_BRACKET); - this.state = 10536; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1109, this.context) ) { - case 1: - { - this.state = 10528; - this.a_expr(); - } - break; - case 2: - { - this.state = 10530; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { - { - this.state = 10529; - this.opt_slice_bound(); - } - } - - this.state = 10532; - this.match(PostgreSqlParser.COLON); - this.state = 10534; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { - { - this.state = 10533; - this.opt_slice_bound(); - } - } - - } - break; - } - this.state = 10538; - this.match(PostgreSqlParser.CLOSE_BRACKET); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_slice_bound(): Opt_slice_boundContext { - let localContext = new Opt_slice_boundContext(this.context, this.state); - this.enterRule(localContext, 1378, PostgreSqlParser.RULE_opt_slice_bound); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10541; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public indirection(): IndirectionContext { - let localContext = new IndirectionContext(this.context, this.state); - this.enterRule(localContext, 1380, PostgreSqlParser.RULE_indirection); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 10544; - this.errorHandler.sync(this); - alternative = 1; - do { - switch (alternative) { - case 1: - { - { - this.state = 10543; - this.indirection_el(); - } - } - break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 10546; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1111, this.context); - } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_indirection(): Opt_indirectionContext { - let localContext = new Opt_indirectionContext(this.context, this.state); - this.enterRule(localContext, 1382, PostgreSqlParser.RULE_opt_indirection); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 10551; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1112, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 10548; - this.indirection_el(); - } - } - } - this.state = 10553; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1112, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_target_list(): Opt_target_listContext { - let localContext = new Opt_target_listContext(this.context, this.state); - this.enterRule(localContext, 1384, PostgreSqlParser.RULE_opt_target_list); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10554; - this.target_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public target_list(): Target_listContext { - let localContext = new Target_listContext(this.context, this.state); - this.enterRule(localContext, 1386, PostgreSqlParser.RULE_target_list); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 10556; - this.target_el(); - this.state = 10561; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1113, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 10557; - this.match(PostgreSqlParser.COMMA); - this.state = 10558; - this.target_el(); - } - } - } - this.state = 10563; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1113, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public target_el(): Target_elContext { - let localContext = new Target_elContext(this.context, this.state); - this.enterRule(localContext, 1388, PostgreSqlParser.RULE_target_el); - try { - this.state = 10572; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1115, this.context) ) { - case 1: - localContext = new Target_labelContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10564; - this.column_expr_noparen(); - this.state = 10569; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1114, this.context) ) { - case 1: - { - this.state = 10565; - this.match(PostgreSqlParser.KW_AS); - this.state = 10566; - this.collabel(); - } - break; - case 2: - { - this.state = 10567; - this.identifier(); - } - break; - case 3: - // tslint:disable-next-line:no-empty - { - } - break; - } - } - break; - case 2: - localContext = new Target_starContext(localContext); - this.enterOuterAlt(localContext, 2); - { - this.state = 10571; - this.match(PostgreSqlParser.STAR); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public qualified_name_list(): Qualified_name_listContext { - let localContext = new Qualified_name_listContext(this.context, this.state); - this.enterRule(localContext, 1390, PostgreSqlParser.RULE_qualified_name_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10574; - this.qualified_name(); - this.state = 10579; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10575; - this.match(PostgreSqlParser.COMMA); - this.state = 10576; - this.qualified_name(); - } - } - this.state = 10581; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public table_name_list(): Table_name_listContext { - let localContext = new Table_name_listContext(this.context, this.state); - this.enterRule(localContext, 1392, PostgreSqlParser.RULE_table_name_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10582; - this.table_name(); - this.state = 10587; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10583; - this.match(PostgreSqlParser.COMMA); - this.state = 10584; - this.table_name(); - } - } - this.state = 10589; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public schema_name_list(): Schema_name_listContext { - let localContext = new Schema_name_listContext(this.context, this.state); - this.enterRule(localContext, 1394, PostgreSqlParser.RULE_schema_name_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10590; - this.schema_name(); - this.state = 10595; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10591; - this.match(PostgreSqlParser.COMMA); - this.state = 10592; - this.schema_name(); - } - } - this.state = 10597; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public database_nameList(): Database_nameListContext { - let localContext = new Database_nameListContext(this.context, this.state); - this.enterRule(localContext, 1396, PostgreSqlParser.RULE_database_nameList); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10598; - this.database_name(); - this.state = 10603; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10599; - this.match(PostgreSqlParser.COMMA); - this.state = 10600; - this.database_name(); - } - } - this.state = 10605; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public procedure_name_list(): Procedure_name_listContext { - let localContext = new Procedure_name_listContext(this.context, this.state); - this.enterRule(localContext, 1398, PostgreSqlParser.RULE_procedure_name_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10606; - this.procedure_name(); - this.state = 10611; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10607; - this.match(PostgreSqlParser.COMMA); - this.state = 10608; - this.procedure_name(); - } - } - this.state = 10613; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public tablespace_name_create(): Tablespace_name_createContext { - let localContext = new Tablespace_name_createContext(this.context, this.state); - this.enterRule(localContext, 1400, PostgreSqlParser.RULE_tablespace_name_create); - let _la: number; - try { - localContext = new TablespaceNameCreateContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10614; - this.colid(); - this.state = 10616; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 4 || _la === 11) { - { - this.state = 10615; - this.indirection(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public tablespace_name(): Tablespace_nameContext { - let localContext = new Tablespace_nameContext(this.context, this.state); - this.enterRule(localContext, 1402, PostgreSqlParser.RULE_tablespace_name); - let _la: number; - try { - localContext = new TablespaceNameContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10618; - this.colid(); - this.state = 10620; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 4 || _la === 11) { - { - this.state = 10619; - this.indirection(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public table_name_create(): Table_name_createContext { - let localContext = new Table_name_createContext(this.context, this.state); - this.enterRule(localContext, 1404, PostgreSqlParser.RULE_table_name_create); - try { - localContext = new TableNameCreateContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10622; - this.colid(); - this.state = 10624; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1123, this.context) ) { - case 1: - { - this.state = 10623; - this.indirection(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public table_name(): Table_nameContext { - let localContext = new Table_nameContext(this.context, this.state); - this.enterRule(localContext, 1406, PostgreSqlParser.RULE_table_name); - let _la: number; - try { - localContext = new TableNameContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10626; - this.colid(); - this.state = 10628; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 4 || _la === 11) { - { - this.state = 10627; - this.indirection(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public view_name_create(): View_name_createContext { - let localContext = new View_name_createContext(this.context, this.state); - this.enterRule(localContext, 1408, PostgreSqlParser.RULE_view_name_create); - let _la: number; - try { - localContext = new ViewNameCreateContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10630; - this.colid(); - this.state = 10632; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 4 || _la === 11) { - { - this.state = 10631; - this.indirection(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public view_name(): View_nameContext { - let localContext = new View_nameContext(this.context, this.state); - this.enterRule(localContext, 1410, PostgreSqlParser.RULE_view_name); - try { - localContext = new ViewNameContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10634; - this.colid(); - this.state = 10636; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1126, this.context) ) { - case 1: - { - this.state = 10635; - this.attrs(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public qualified_name(): Qualified_nameContext { - let localContext = new Qualified_nameContext(this.context, this.state); - this.enterRule(localContext, 1412, PostgreSqlParser.RULE_qualified_name); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10638; - this.colid(); - this.state = 10640; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 4 || _la === 11) { - { - this.state = 10639; - this.indirection(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public tablespace_name_list(): Tablespace_name_listContext { - let localContext = new Tablespace_name_listContext(this.context, this.state); - this.enterRule(localContext, 1414, PostgreSqlParser.RULE_tablespace_name_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10642; - this.tablespace_name(); - this.state = 10647; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10643; - this.match(PostgreSqlParser.COMMA); - this.state = 10644; - this.tablespace_name(); - } - } - this.state = 10649; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public name_list(): Name_listContext { - let localContext = new Name_listContext(this.context, this.state); - this.enterRule(localContext, 1416, PostgreSqlParser.RULE_name_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10650; - this.name(); - this.state = 10655; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10651; - this.match(PostgreSqlParser.COMMA); - this.state = 10652; - this.name(); - } - } - this.state = 10657; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public database_name_create(): Database_name_createContext { - let localContext = new Database_name_createContext(this.context, this.state); - this.enterRule(localContext, 1418, PostgreSqlParser.RULE_database_name_create); - let _la: number; - try { - localContext = new DatabaseNameCreateContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10658; - this.colid(); - this.state = 10660; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 11) { - { - this.state = 10659; - this.attrs(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public database_name(): Database_nameContext { - let localContext = new Database_nameContext(this.context, this.state); - this.enterRule(localContext, 1420, PostgreSqlParser.RULE_database_name); - let _la: number; - try { - localContext = new DatabaseNameContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10662; - this.colid(); - this.state = 10664; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 11) { - { - this.state = 10663; - this.attrs(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public schema_name(): Schema_nameContext { - let localContext = new Schema_nameContext(this.context, this.state); - this.enterRule(localContext, 1422, PostgreSqlParser.RULE_schema_name); - let _la: number; - try { - localContext = new SchemaNameContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10666; - this.colid(); - this.state = 10668; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 11) { - { - this.state = 10667; - this.attrs(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public routine_name_create(): Routine_name_createContext { - let localContext = new Routine_name_createContext(this.context, this.state); - this.enterRule(localContext, 1424, PostgreSqlParser.RULE_routine_name_create); - try { - localContext = new RoutineNameCreateContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10670; - this.colid(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public routine_name(): Routine_nameContext { - let localContext = new Routine_nameContext(this.context, this.state); - this.enterRule(localContext, 1426, PostgreSqlParser.RULE_routine_name); - try { - localContext = new RoutineNameContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10672; - this.colid(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public procedure_name(): Procedure_nameContext { - let localContext = new Procedure_nameContext(this.context, this.state); - this.enterRule(localContext, 1428, PostgreSqlParser.RULE_procedure_name); - try { - this.state = 10678; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1133, this.context) ) { - case 1: - localContext = new ProcedureNameContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10674; - this.type_function_name(); - } - break; - case 2: - localContext = new ProcedureNameContext(localContext); - this.enterOuterAlt(localContext, 2); - { - this.state = 10675; - this.colid(); - this.state = 10676; - this.indirection(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public procedure_name_create(): Procedure_name_createContext { - let localContext = new Procedure_name_createContext(this.context, this.state); - this.enterRule(localContext, 1430, PostgreSqlParser.RULE_procedure_name_create); - try { - this.state = 10684; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1134, this.context) ) { - case 1: - localContext = new ProcedureNameCreateContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10680; - this.type_function_name(); - } - break; - case 2: - localContext = new ProcedureNameCreateContext(localContext); - this.enterOuterAlt(localContext, 2); - { - this.state = 10681; - this.colid(); - this.state = 10682; - this.indirection(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public column_name(): Column_nameContext { - let localContext = new Column_nameContext(this.context, this.state); - this.enterRule(localContext, 1432, PostgreSqlParser.RULE_column_name); - try { - let alternative: number; - this.state = 10694; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1136, this.context) ) { - case 1: - localContext = new ColumnNameContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10686; - this.colid(); - this.state = 10690; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1135, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 10687; - this.indirection_el(); - } - } - } - this.state = 10692; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1135, this.context); - } - } - break; - case 2: - localContext = new ColumnNameMatchContext(localContext); - this.enterOuterAlt(localContext, 2); - { - this.state = 10693; - if (!(this.shouldMatchEmpty())) { - throw this.createFailedPredicateException("this.shouldMatchEmpty()"); - } - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public column_name_create(): Column_name_createContext { - let localContext = new Column_name_createContext(this.context, this.state); - this.enterRule(localContext, 1434, PostgreSqlParser.RULE_column_name_create); - try { - localContext = new ColumnNameCreateContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10696; - this.colid(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public name(): NameContext { - let localContext = new NameContext(this.context, this.state); - this.enterRule(localContext, 1436, PostgreSqlParser.RULE_name); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10698; - this.colid(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public attr_name(): Attr_nameContext { - let localContext = new Attr_nameContext(this.context, this.state); - this.enterRule(localContext, 1438, PostgreSqlParser.RULE_attr_name); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10700; - this.collabel(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public file_name(): File_nameContext { - let localContext = new File_nameContext(this.context, this.state); - this.enterRule(localContext, 1440, PostgreSqlParser.RULE_file_name); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10702; - this.sconst(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public function_name_create(): Function_name_createContext { - let localContext = new Function_name_createContext(this.context, this.state); - this.enterRule(localContext, 1442, PostgreSqlParser.RULE_function_name_create); - try { - this.state = 10708; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1137, this.context) ) { - case 1: - localContext = new FunctionNameCreateContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10704; - this.type_function_name(); - } - break; - case 2: - localContext = new FunctionNameCreateContext(localContext); - this.enterOuterAlt(localContext, 2); - { - this.state = 10705; - this.colid(); - this.state = 10706; - this.indirection(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public function_name(): Function_nameContext { - let localContext = new Function_nameContext(this.context, this.state); - this.enterRule(localContext, 1444, PostgreSqlParser.RULE_function_name); - try { - this.state = 10714; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1138, this.context) ) { - case 1: - localContext = new FunctionNameContext(localContext); - this.enterOuterAlt(localContext, 1); - { - this.state = 10710; - this.type_function_name(); - } - break; - case 2: - localContext = new FunctionNameContext(localContext); - this.enterOuterAlt(localContext, 2); - { - this.state = 10711; - this.colid(); - this.state = 10712; - this.indirection(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public usual_name(): Usual_nameContext { - let localContext = new Usual_nameContext(this.context, this.state); - this.enterRule(localContext, 1446, PostgreSqlParser.RULE_usual_name); - try { - this.state = 10720; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1139, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10716; - this.type_usual_name(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10717; - this.colid(); - this.state = 10718; - this.indirection(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public aexprconst(): AexprconstContext { - let localContext = new AexprconstContext(this.context, this.state); - this.enterRule(localContext, 1448, PostgreSqlParser.RULE_aexprconst); - let _la: number; - try { - this.state = 10757; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1144, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10722; - this.iconst(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10723; - this.fconst(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10724; - this.sconst(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10725; - this.bconst(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 10726; - this.xconst(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 10727; - this.function_name(); - this.state = 10737; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.EscapeStringConstant: - { - this.state = 10728; - this.sconst(); - } - break; - case PostgreSqlParser.OPEN_PAREN: - { - this.state = 10729; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10730; - this.func_arg_list(); - this.state = 10732; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 83) { - { - this.state = 10731; - this.opt_sort_clause(); - } - } - - this.state = 10734; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 10735; - this.sconst(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 10739; - this.consttypename(); - this.state = 10740; - this.sconst(); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 10742; - this.constinterval(); - this.state = 10752; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.EscapeStringConstant: - { - this.state = 10743; - this.sconst(); - this.state = 10745; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1142, this.context) ) { - case 1: - { - this.state = 10744; - this.opt_interval(); - } - break; - } - } - break; - case PostgreSqlParser.OPEN_PAREN: - { - this.state = 10747; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10748; - this.iconst(); - this.state = 10749; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 10750; - this.sconst(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 10754; - this.match(PostgreSqlParser.KW_TRUE); - } - break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 10755; - this.match(PostgreSqlParser.KW_FALSE); - } - break; - case 11: - this.enterOuterAlt(localContext, 11); - { - this.state = 10756; - this.match(PostgreSqlParser.KW_NULL); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public xconst(): XconstContext { - let localContext = new XconstContext(this.context, this.state); - this.enterRule(localContext, 1450, PostgreSqlParser.RULE_xconst); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10759; - this.match(PostgreSqlParser.HexadecimalStringConstant); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public bconst(): BconstContext { - let localContext = new BconstContext(this.context, this.state); - this.enterRule(localContext, 1452, PostgreSqlParser.RULE_bconst); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10761; - this.match(PostgreSqlParser.BinaryStringConstant); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public fconst(): FconstContext { - let localContext = new FconstContext(this.context, this.state); - this.enterRule(localContext, 1454, PostgreSqlParser.RULE_fconst); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10763; - this.match(PostgreSqlParser.Numeric); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public iconst(): IconstContext { - let localContext = new IconstContext(this.context, this.state); - this.enterRule(localContext, 1456, PostgreSqlParser.RULE_iconst); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10765; - this.match(PostgreSqlParser.Integral); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public sconst(): SconstContext { - let localContext = new SconstContext(this.context, this.state); - this.enterRule(localContext, 1458, PostgreSqlParser.RULE_sconst); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10767; - this.anysconst(); - this.state = 10769; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1145, this.context) ) { - case 1: - { - this.state = 10768; - this.opt_uescape(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public anysconst(): AnysconstContext { - let localContext = new AnysconstContext(this.context, this.state); - this.enterRule(localContext, 1460, PostgreSqlParser.RULE_anysconst); - let _la: number; - try { - this.state = 10782; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.StringConstant: - this.enterOuterAlt(localContext, 1); - { - this.state = 10771; - this.match(PostgreSqlParser.StringConstant); - } - break; - case PostgreSqlParser.UnicodeEscapeStringConstant: - this.enterOuterAlt(localContext, 2); - { - this.state = 10772; - this.match(PostgreSqlParser.UnicodeEscapeStringConstant); - } - break; - case PostgreSqlParser.BeginDollarStringConstant: - this.enterOuterAlt(localContext, 3); - { - this.state = 10773; - this.match(PostgreSqlParser.BeginDollarStringConstant); - this.state = 10777; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 588) { - { - { - this.state = 10774; - this.match(PostgreSqlParser.DollarText); - } - } - this.state = 10779; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - this.state = 10780; - this.match(PostgreSqlParser.EndDollarStringConstant); - } - break; - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 4); - { - this.state = 10781; - this.match(PostgreSqlParser.EscapeStringConstant); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_uescape(): Opt_uescapeContext { - let localContext = new Opt_uescapeContext(this.context, this.state); - this.enterRule(localContext, 1462, PostgreSqlParser.RULE_opt_uescape); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10784; - this.match(PostgreSqlParser.KW_UESCAPE); - this.state = 10785; - this.anysconst(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public signediconst(): SignediconstContext { - let localContext = new SignediconstContext(this.context, this.state); - this.enterRule(localContext, 1464, PostgreSqlParser.RULE_signediconst); - try { - this.state = 10792; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.Integral: - this.enterOuterAlt(localContext, 1); - { - this.state = 10787; - this.iconst(); - } - break; - case PostgreSqlParser.PLUS: - this.enterOuterAlt(localContext, 2); - { - this.state = 10788; - this.match(PostgreSqlParser.PLUS); - this.state = 10789; - this.iconst(); - } - break; - case PostgreSqlParser.MINUS: - this.enterOuterAlt(localContext, 3); - { - this.state = 10790; - this.match(PostgreSqlParser.MINUS); - this.state = 10791; - this.iconst(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public groupname(): GroupnameContext { - let localContext = new GroupnameContext(this.context, this.state); - this.enterRule(localContext, 1466, PostgreSqlParser.RULE_groupname); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10794; - this.rolespec(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public roleid(): RoleidContext { - let localContext = new RoleidContext(this.context, this.state); - this.enterRule(localContext, 1468, PostgreSqlParser.RULE_roleid); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10796; - this.rolespec(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public rolespec(): RolespecContext { - let localContext = new RolespecContext(this.context, this.state); - this.enterRule(localContext, 1470, PostgreSqlParser.RULE_rolespec); - try { - this.state = 10803; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_AUTHORIZATION: - case PostgreSqlParser.KW_BINARY: - case PostgreSqlParser.KW_COLLATION: - case PostgreSqlParser.KW_CONCURRENTLY: - case PostgreSqlParser.KW_CROSS: - case PostgreSqlParser.KW_CURRENT_SCHEMA: - case PostgreSqlParser.KW_FREEZE: - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_ILIKE: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_ISNULL: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_LIKE: - case PostgreSqlParser.KW_NATURAL: - case PostgreSqlParser.KW_NOTNULL: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_OVERLAPS: - case PostgreSqlParser.KW_RIGHT: - case PostgreSqlParser.KW_SIMILAR: - case PostgreSqlParser.KW_VERBOSE: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_TABLESAMPLE: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); - { - this.state = 10798; - this.nonreservedword(); - } - break; - case PostgreSqlParser.KW_CURRENT_USER: - this.enterOuterAlt(localContext, 2); - { - this.state = 10799; - this.match(PostgreSqlParser.KW_CURRENT_USER); - } - break; - case PostgreSqlParser.KW_CURRENT_ROLE: - this.enterOuterAlt(localContext, 3); - { - this.state = 10800; - this.match(PostgreSqlParser.KW_CURRENT_ROLE); - } - break; - case PostgreSqlParser.KW_SESSION_USER: - this.enterOuterAlt(localContext, 4); - { - this.state = 10801; - this.match(PostgreSqlParser.KW_SESSION_USER); - } - break; - case PostgreSqlParser.KW_PUBLIC: - this.enterOuterAlt(localContext, 5); - { - this.state = 10802; - this.match(PostgreSqlParser.KW_PUBLIC); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public role_list(): Role_listContext { - let localContext = new Role_listContext(this.context, this.state); - this.enterRule(localContext, 1472, PostgreSqlParser.RULE_role_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10805; - this.rolespec(); - this.state = 10810; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 10806; - this.match(PostgreSqlParser.COMMA); - this.state = 10807; - this.rolespec(); - } - } - this.state = 10812; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public colid(): ColidContext { - let localContext = new ColidContext(this.context, this.state); - this.enterRule(localContext, 1474, PostgreSqlParser.RULE_colid); - try { - this.state = 10817; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1151, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10813; - this.identifier(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10814; - this.unreserved_keyword(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10815; - this.col_name_keyword(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10816; - this.plsql_unreserved_keyword(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public index_method_choices(): Index_method_choicesContext { - let localContext = new Index_method_choicesContext(this.context, this.state); - this.enterRule(localContext, 1476, PostgreSqlParser.RULE_index_method_choices); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10819; - this.identifier(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public exclude_element(): Exclude_elementContext { - let localContext = new Exclude_elementContext(this.context, this.state); - this.enterRule(localContext, 1478, PostgreSqlParser.RULE_exclude_element); - let _la: number; - try { - this.state = 10833; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_WITH: - this.enterOuterAlt(localContext, 1); - { - this.state = 10821; - this.opt_definition(); - } - break; - case PostgreSqlParser.OPEN_PAREN: - this.enterOuterAlt(localContext, 2); - { - { - this.state = 10822; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 10823; - this.a_expr(); - this.state = 10824; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - this.state = 10826; - this.identifier(); - this.state = 10828; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 37 || _la === 55) { - { - this.state = 10827; - this.opt_asc_desc(); - } - } - - this.state = 10831; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 273) { - { - this.state = 10830; - this.opt_nulls_order(); - } - } - - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public index_paramenters(): Index_paramentersContext { - let localContext = new Index_paramentersContext(this.context, this.state); - this.enterRule(localContext, 1480, PostgreSqlParser.RULE_index_paramenters); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10837; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 105) { - { - this.state = 10835; - this.match(PostgreSqlParser.KW_WITH); - this.state = 10836; - this.reloptions(); - } - } - - this.state = 10840; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 100) { - { - this.state = 10839; - this.optconstablespace(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public type_function_name(): Type_function_nameContext { - let localContext = new Type_function_nameContext(this.context, this.state); - this.enterRule(localContext, 1482, PostgreSqlParser.RULE_type_function_name); - try { - this.state = 10846; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1157, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10842; - this.identifier(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10843; - this.unreserved_keyword(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10844; - this.plsql_unreserved_keyword(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10845; - this.type_func_name_keyword(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public type_usual_name(): Type_usual_nameContext { - let localContext = new Type_usual_nameContext(this.context, this.state); - this.enterRule(localContext, 1484, PostgreSqlParser.RULE_type_usual_name); - try { - this.state = 10852; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1158, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10848; - this.identifier(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10849; - this.unreserved_keyword(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10850; - this.plsql_unreserved_keyword(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10851; - this.type_func_name_keyword(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public nonreservedword_column(): Nonreservedword_columnContext { - let localContext = new Nonreservedword_columnContext(this.context, this.state); - this.enterRule(localContext, 1486, PostgreSqlParser.RULE_nonreservedword_column); - try { - this.state = 10856; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1159, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10854; - this.column_name(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10855; - this.type_func_name_keyword(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public nonreservedword(): NonreservedwordContext { - let localContext = new NonreservedwordContext(this.context, this.state); - this.enterRule(localContext, 1488, PostgreSqlParser.RULE_nonreservedword); - try { - this.state = 10862; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1160, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10858; - this.identifier(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10859; - this.unreserved_keyword(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10860; - this.col_name_keyword(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10861; - this.type_func_name_keyword(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public collabel(): CollabelContext { - let localContext = new CollabelContext(this.context, this.state); - this.enterRule(localContext, 1490, PostgreSqlParser.RULE_collabel); - try { - this.state = 10870; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1161, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10864; - this.identifier(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10865; - this.plsql_unreserved_keyword(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10866; - this.unreserved_keyword(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10867; - this.col_name_keyword(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 10868; - this.type_func_name_keyword(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 10869; - this.reserved_keyword(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public identifier(): IdentifierContext { - let localContext = new IdentifierContext(this.context, this.state); - this.enterRule(localContext, 1492, PostgreSqlParser.RULE_identifier); - try { - this.state = 10882; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.Identifier: - this.enterOuterAlt(localContext, 1); - { - this.state = 10872; - this.match(PostgreSqlParser.Identifier); - this.state = 10874; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1162, this.context) ) { - case 1: - { - this.state = 10873; - this.opt_uescape(); - } - break; - } - } - break; - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 2); - { - this.state = 10876; - this.sconst(); - } - break; - case PostgreSqlParser.QuotedIdentifier: - this.enterOuterAlt(localContext, 3); - { - this.state = 10877; - this.match(PostgreSqlParser.QuotedIdentifier); - } - break; - case PostgreSqlParser.UnicodeQuotedIdentifier: - this.enterOuterAlt(localContext, 4); - { - this.state = 10878; - this.match(PostgreSqlParser.UnicodeQuotedIdentifier); - } - break; - case PostgreSqlParser.PLSQLVARIABLENAME: - this.enterOuterAlt(localContext, 5); - { - this.state = 10879; - this.plsqlvariablename(); - } - break; - case PostgreSqlParser.PLSQLIDENTIFIER: - this.enterOuterAlt(localContext, 6); - { - this.state = 10880; - this.plsqlidentifier(); - } - break; - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - this.enterOuterAlt(localContext, 7); - { - this.state = 10881; - this.plsql_unreserved_keyword(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public plsqlidentifier(): PlsqlidentifierContext { - let localContext = new PlsqlidentifierContext(this.context, this.state); - this.enterRule(localContext, 1494, PostgreSqlParser.RULE_plsqlidentifier); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10884; - this.match(PostgreSqlParser.PLSQLIDENTIFIER); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public unreserved_keyword(): Unreserved_keywordContext { - let localContext = new Unreserved_keywordContext(this.context, this.state); - this.enterRule(localContext, 1496, PostgreSqlParser.RULE_unreserved_keyword); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10886; - _la = this.tokenStream.LA(1); - if(!(((((_la - 124)) & ~0x1F) === 0 && ((1 << (_la - 124)) & 4294967265) !== 0) || ((((_la - 156)) & ~0x1F) === 0 && ((1 << (_la - 156)) & 4294967295) !== 0) || ((((_la - 188)) & ~0x1F) === 0 && ((1 << (_la - 188)) & 4294967295) !== 0) || ((((_la - 220)) & ~0x1F) === 0 && ((1 << (_la - 220)) & 4294705663) !== 0) || ((((_la - 252)) & ~0x1F) === 0 && ((1 << (_la - 252)) & 4294967295) !== 0) || ((((_la - 284)) & ~0x1F) === 0 && ((1 << (_la - 284)) & 4294967295) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & 4294967295) !== 0) || ((((_la - 348)) & ~0x1F) === 0 && ((1 << (_la - 348)) & 4294967295) !== 0) || ((((_la - 380)) & ~0x1F) === 0 && ((1 << (_la - 380)) & 127) !== 0) || ((((_la - 433)) & ~0x1F) === 0 && ((1 << (_la - 433)) & 4291821567) !== 0) || ((((_la - 465)) & ~0x1F) === 0 && ((1 << (_la - 465)) & 16770399) !== 0) || _la === 547 || _la === 548)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public col_name_keyword(): Col_name_keywordContext { - let localContext = new Col_name_keywordContext(this.context, this.state); - this.enterRule(localContext, 1498, PostgreSqlParser.RULE_col_name_keyword); - try { - this.state = 10939; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1164, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10888; - this.match(PostgreSqlParser.KW_BETWEEN); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10889; - this.match(PostgreSqlParser.KW_BIGINT); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10890; - this.bit(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10891; - this.match(PostgreSqlParser.KW_BOOLEAN); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 10892; - this.match(PostgreSqlParser.KW_CHAR); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 10893; - this.character(); - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 10894; - this.match(PostgreSqlParser.KW_COALESCE); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 10895; - this.match(PostgreSqlParser.KW_DEC); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 10896; - this.match(PostgreSqlParser.KW_DECIMAL); - } - break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 10897; - this.match(PostgreSqlParser.KW_EXISTS); - } - break; - case 11: - this.enterOuterAlt(localContext, 11); - { - this.state = 10898; - this.match(PostgreSqlParser.KW_EXTRACT); - } - break; - case 12: - this.enterOuterAlt(localContext, 12); - { - this.state = 10899; - this.match(PostgreSqlParser.KW_FLOAT); - } - break; - case 13: - this.enterOuterAlt(localContext, 13); - { - this.state = 10900; - this.match(PostgreSqlParser.KW_GREATEST); - } - break; - case 14: - this.enterOuterAlt(localContext, 14); - { - this.state = 10901; - this.match(PostgreSqlParser.KW_GROUPING); - } - break; - case 15: - this.enterOuterAlt(localContext, 15); - { - this.state = 10902; - this.match(PostgreSqlParser.KW_INOUT); - } - break; - case 16: - this.enterOuterAlt(localContext, 16); - { - this.state = 10903; - this.match(PostgreSqlParser.KW_INT); - } - break; - case 17: - this.enterOuterAlt(localContext, 17); - { - this.state = 10904; - this.match(PostgreSqlParser.KW_INTEGER); - } - break; - case 18: - this.enterOuterAlt(localContext, 18); - { - this.state = 10905; - this.match(PostgreSqlParser.KW_INTERVAL); - } - break; - case 19: - this.enterOuterAlt(localContext, 19); - { - this.state = 10906; - this.match(PostgreSqlParser.KW_LEAST); - } - break; - case 20: - this.enterOuterAlt(localContext, 20); - { - this.state = 10907; - this.match(PostgreSqlParser.KW_NATIONAL); - } - break; - case 21: - this.enterOuterAlt(localContext, 21); - { - this.state = 10908; - this.match(PostgreSqlParser.KW_NCHAR); - } - break; - case 22: - this.enterOuterAlt(localContext, 22); - { - this.state = 10909; - this.match(PostgreSqlParser.KW_NONE); - } - break; - case 23: - this.enterOuterAlt(localContext, 23); - { - this.state = 10910; - this.match(PostgreSqlParser.KW_NORMALIZE); - } - break; - case 24: - this.enterOuterAlt(localContext, 24); - { - this.state = 10911; - this.match(PostgreSqlParser.KW_NULLIF); - } - break; - case 25: - this.enterOuterAlt(localContext, 25); - { - this.state = 10912; - this.numeric(); - } - break; - case 26: - this.enterOuterAlt(localContext, 26); - { - this.state = 10913; - this.match(PostgreSqlParser.KW_OUT); - } - break; - case 27: - this.enterOuterAlt(localContext, 27); - { - this.state = 10914; - this.match(PostgreSqlParser.KW_OVERLAY); - } - break; - case 28: - this.enterOuterAlt(localContext, 28); - { - this.state = 10915; - this.match(PostgreSqlParser.KW_POSITION); - } - break; - case 29: - this.enterOuterAlt(localContext, 29); - { - this.state = 10916; - this.match(PostgreSqlParser.KW_PRECISION); - } - break; - case 30: - this.enterOuterAlt(localContext, 30); - { - this.state = 10917; - this.match(PostgreSqlParser.KW_REAL); - } - break; - case 31: - this.enterOuterAlt(localContext, 31); - { - this.state = 10918; - this.match(PostgreSqlParser.KW_ROW); - } - break; - case 32: - this.enterOuterAlt(localContext, 32); - { - this.state = 10919; - this.match(PostgreSqlParser.KW_SETOF); - } - break; - case 33: - this.enterOuterAlt(localContext, 33); - { - this.state = 10920; - this.match(PostgreSqlParser.KW_SMALLINT); - } - break; - case 34: - this.enterOuterAlt(localContext, 34); - { - this.state = 10921; - this.match(PostgreSqlParser.KW_SUBSTRING); - } - break; - case 35: - this.enterOuterAlt(localContext, 35); - { - this.state = 10922; - this.match(PostgreSqlParser.KW_TIME); - } - break; - case 36: - this.enterOuterAlt(localContext, 36); - { - this.state = 10923; - this.match(PostgreSqlParser.KW_TIMESTAMP); - } - break; - case 37: - this.enterOuterAlt(localContext, 37); - { - this.state = 10924; - this.match(PostgreSqlParser.KW_TREAT); - } - break; - case 38: - this.enterOuterAlt(localContext, 38); - { - this.state = 10925; - this.match(PostgreSqlParser.KW_TRIM); - } - break; - case 39: - this.enterOuterAlt(localContext, 39); - { - this.state = 10926; - this.match(PostgreSqlParser.KW_VALUES); - } - break; - case 40: - this.enterOuterAlt(localContext, 40); - { - this.state = 10927; - this.match(PostgreSqlParser.KW_VARCHAR); - } - break; - case 41: - this.enterOuterAlt(localContext, 41); - { - this.state = 10928; - this.match(PostgreSqlParser.KW_XMLATTRIBUTES); - } - break; - case 42: - this.enterOuterAlt(localContext, 42); - { - this.state = 10929; - this.match(PostgreSqlParser.KW_XMLCONCAT); - } - break; - case 43: - this.enterOuterAlt(localContext, 43); - { - this.state = 10930; - this.match(PostgreSqlParser.KW_XMLELEMENT); - } - break; - case 44: - this.enterOuterAlt(localContext, 44); - { - this.state = 10931; - this.match(PostgreSqlParser.KW_XMLEXISTS); - } - break; - case 45: - this.enterOuterAlt(localContext, 45); - { - this.state = 10932; - this.match(PostgreSqlParser.KW_XMLFOREST); - } - break; - case 46: - this.enterOuterAlt(localContext, 46); - { - this.state = 10933; - this.match(PostgreSqlParser.KW_XMLNAMESPACES); - } - break; - case 47: - this.enterOuterAlt(localContext, 47); - { - this.state = 10934; - this.match(PostgreSqlParser.KW_XMLPARSE); - } - break; - case 48: - this.enterOuterAlt(localContext, 48); - { - this.state = 10935; - this.match(PostgreSqlParser.KW_XMLPI); - } - break; - case 49: - this.enterOuterAlt(localContext, 49); - { - this.state = 10936; - this.match(PostgreSqlParser.KW_XMLROOT); - } - break; - case 50: - this.enterOuterAlt(localContext, 50); - { - this.state = 10937; - this.match(PostgreSqlParser.KW_XMLSERIALIZE); - } - break; - case 51: - this.enterOuterAlt(localContext, 51); - { - this.state = 10938; - this.match(PostgreSqlParser.KW_XMLTABLE); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public type_func_name_keyword(): Type_func_name_keywordContext { - let localContext = new Type_func_name_keywordContext(this.context, this.state); - this.enterRule(localContext, 1500, PostgreSqlParser.RULE_type_func_name_keyword); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10941; - _la = this.tokenStream.LA(1); - if(!(((((_la - 106)) & ~0x1F) === 0 && ((1 << (_la - 106)) & 8126463) !== 0) || _la === 472)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public reserved_keyword(): Reserved_keywordContext { - let localContext = new Reserved_keywordContext(this.context, this.state); - this.enterRule(localContext, 1502, PostgreSqlParser.RULE_reserved_keyword); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10943; - _la = this.tokenStream.LA(1); - if(!(((((_la - 30)) & ~0x1F) === 0 && ((1 << (_la - 30)) & 4286578687) !== 0) || ((((_la - 62)) & ~0x1F) === 0 && ((1 << (_la - 62)) & 4294966783) !== 0) || ((((_la - 94)) & ~0x1F) === 0 && ((1 << (_la - 94)) & 4095) !== 0) || _la === 454)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public pl_function(): Pl_functionContext { - let localContext = new Pl_functionContext(this.context, this.state); - this.enterRule(localContext, 1504, PostgreSqlParser.RULE_pl_function); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10945; - this.comp_options(); - this.state = 10946; - this.pl_block(); - this.state = 10947; - this.opt_semi(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public comp_options(): Comp_optionsContext { - let localContext = new Comp_optionsContext(this.context, this.state); - this.enterRule(localContext, 1506, PostgreSqlParser.RULE_comp_options); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10952; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 29) { - { - { - this.state = 10949; - this.comp_option(); - } - } - this.state = 10954; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public comp_option(): Comp_optionContext { - let localContext = new Comp_optionContext(this.context, this.state); - this.enterRule(localContext, 1508, PostgreSqlParser.RULE_comp_option); - try { - this.state = 10975; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1166, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10955; - this.sharp(); - this.state = 10956; - this.match(PostgreSqlParser.KW_OPTION); - this.state = 10957; - this.match(PostgreSqlParser.KW_DUMP); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10959; - this.sharp(); - this.state = 10960; - this.match(PostgreSqlParser.KW_PRINT_STRICT_PARAMS); - this.state = 10961; - this.option_value(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10963; - this.sharp(); - this.state = 10964; - this.match(PostgreSqlParser.KW_VARIABLE_CONFLICT); - this.state = 10965; - this.match(PostgreSqlParser.KW_ERROR); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10967; - this.sharp(); - this.state = 10968; - this.match(PostgreSqlParser.KW_VARIABLE_CONFLICT); - this.state = 10969; - this.match(PostgreSqlParser.KW_USE_VARIABLE); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 10971; - this.sharp(); - this.state = 10972; - this.match(PostgreSqlParser.KW_VARIABLE_CONFLICT); - this.state = 10973; - this.match(PostgreSqlParser.KW_USE_COLUMN); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public sharp(): SharpContext { - let localContext = new SharpContext(this.context, this.state); - this.enterRule(localContext, 1510, PostgreSqlParser.RULE_sharp); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10977; - this.match(PostgreSqlParser.Operator); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public option_value(): Option_valueContext { - let localContext = new Option_valueContext(this.context, this.state); - this.enterRule(localContext, 1512, PostgreSqlParser.RULE_option_value); - try { - this.state = 10983; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1167, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 10979; - this.sconst(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 10980; - this.reserved_keyword(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 10981; - this.plsql_unreserved_keyword(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 10982; - this.unreserved_keyword(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_semi(): Opt_semiContext { - let localContext = new Opt_semiContext(this.context, this.state); - this.enterRule(localContext, 1514, PostgreSqlParser.RULE_opt_semi); - try { - this.state = 10987; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.EOF: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.SEMI: - this.enterOuterAlt(localContext, 2); - { - this.state = 10986; - this.match(PostgreSqlParser.SEMI); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public pl_block(): Pl_blockContext { - let localContext = new Pl_blockContext(this.context, this.state); - this.enterRule(localContext, 1516, PostgreSqlParser.RULE_pl_block); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10989; - this.decl_sect(); - this.state = 10990; - this.match(PostgreSqlParser.KW_BEGIN); - this.state = 10991; - this.proc_sect(); - this.state = 10992; - this.exception_sect(); - this.state = 10993; - this.match(PostgreSqlParser.KW_END); - this.state = 10994; - this.opt_label(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_sect(): Decl_sectContext { - let localContext = new Decl_sectContext(this.context, this.state); - this.enterRule(localContext, 1518, PostgreSqlParser.RULE_decl_sect); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 10996; - this.opt_block_label(); - this.state = 11001; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 178) { - { - this.state = 10997; - this.decl_start(); - this.state = 10999; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1169, this.context) ) { - case 1: - { - this.state = 10998; - this.decl_stmts(); - } - break; - } - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_start(): Decl_startContext { - let localContext = new Decl_startContext(this.context, this.state); - this.enterRule(localContext, 1520, PostgreSqlParser.RULE_decl_start); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11003; - this.match(PostgreSqlParser.KW_DECLARE); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_stmts(): Decl_stmtsContext { - let localContext = new Decl_stmtsContext(this.context, this.state); - this.enterRule(localContext, 1522, PostgreSqlParser.RULE_decl_stmts); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 11006; - this.errorHandler.sync(this); - alternative = 1; - do { - switch (alternative) { - case 1: - { - { - this.state = 11005; - this.decl_stmt(); - } - } - break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 11008; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1171, this.context); - } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public label_decl(): Label_declContext { - let localContext = new Label_declContext(this.context, this.state); - this.enterRule(localContext, 1524, PostgreSqlParser.RULE_label_decl); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11010; - this.match(PostgreSqlParser.LESS_LESS); - this.state = 11011; - this.any_identifier(); - this.state = 11012; - this.match(PostgreSqlParser.GREATER_GREATER); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_stmt(): Decl_stmtContext { - let localContext = new Decl_stmtContext(this.context, this.state); - this.enterRule(localContext, 1526, PostgreSqlParser.RULE_decl_stmt); - try { - this.state = 11017; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1172, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 11014; - this.decl_statement(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11015; - this.match(PostgreSqlParser.KW_DECLARE); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 11016; - this.label_decl(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_statement(): Decl_statementContext { - let localContext = new Decl_statementContext(this.context, this.state); - this.enterRule(localContext, 1528, PostgreSqlParser.RULE_decl_statement); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11019; - this.decl_varname(); - this.state = 11035; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1173, this.context) ) { - case 1: - { - this.state = 11020; - this.match(PostgreSqlParser.KW_ALIAS); - this.state = 11021; - this.match(PostgreSqlParser.KW_FOR); - this.state = 11022; - this.decl_aliasitem(); - } - break; - case 2: - { - this.state = 11023; - this.decl_const(); - this.state = 11024; - this.decl_datatype(); - this.state = 11025; - this.decl_collate(); - this.state = 11026; - this.decl_notnull(); - this.state = 11027; - this.decl_defval(); - } - break; - case 3: - { - this.state = 11029; - this.opt_scrollable(); - this.state = 11030; - this.match(PostgreSqlParser.KW_CURSOR); - this.state = 11031; - this.decl_cursor_args(); - this.state = 11032; - this.decl_is_for(); - this.state = 11033; - this.decl_cursor_query(); - } - break; - } - this.state = 11037; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_scrollable(): Opt_scrollableContext { - let localContext = new Opt_scrollableContext(this.context, this.state); - this.enterRule(localContext, 1530, PostgreSqlParser.RULE_opt_scrollable); - try { - this.state = 11043; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_CURSOR: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_NO: - this.enterOuterAlt(localContext, 2); - { - this.state = 11040; - this.match(PostgreSqlParser.KW_NO); - this.state = 11041; - this.match(PostgreSqlParser.KW_SCROLL); - } - break; - case PostgreSqlParser.KW_SCROLL: - this.enterOuterAlt(localContext, 3); - { - this.state = 11042; - this.match(PostgreSqlParser.KW_SCROLL); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_cursor_query(): Decl_cursor_queryContext { - let localContext = new Decl_cursor_queryContext(this.context, this.state); - this.enterRule(localContext, 1532, PostgreSqlParser.RULE_decl_cursor_query); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11045; - this.selectstmt(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_cursor_args(): Decl_cursor_argsContext { - let localContext = new Decl_cursor_argsContext(this.context, this.state); - this.enterRule(localContext, 1534, PostgreSqlParser.RULE_decl_cursor_args); - try { - this.state = 11052; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_FOR: - case PostgreSqlParser.KW_IS: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.OPEN_PAREN: - this.enterOuterAlt(localContext, 2); - { - this.state = 11048; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 11049; - this.decl_cursor_arglist(); - this.state = 11050; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_cursor_arglist(): Decl_cursor_arglistContext { - let localContext = new Decl_cursor_arglistContext(this.context, this.state); - this.enterRule(localContext, 1536, PostgreSqlParser.RULE_decl_cursor_arglist); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11054; - this.decl_cursor_arg(); - this.state = 11059; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 11055; - this.match(PostgreSqlParser.COMMA); - this.state = 11056; - this.decl_cursor_arg(); - } - } - this.state = 11061; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_cursor_arg(): Decl_cursor_argContext { - let localContext = new Decl_cursor_argContext(this.context, this.state); - this.enterRule(localContext, 1538, PostgreSqlParser.RULE_decl_cursor_arg); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11062; - this.decl_varname(); - this.state = 11063; - this.decl_datatype(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_is_for(): Decl_is_forContext { - let localContext = new Decl_is_forContext(this.context, this.state); - this.enterRule(localContext, 1540, PostgreSqlParser.RULE_decl_is_for); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11065; - _la = this.tokenStream.LA(1); - if(!(_la === 62 || _la === 116)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_aliasitem(): Decl_aliasitemContext { - let localContext = new Decl_aliasitemContext(this.context, this.state); - this.enterRule(localContext, 1542, PostgreSqlParser.RULE_decl_aliasitem); - try { - this.state = 11069; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.PARAM: - this.enterOuterAlt(localContext, 1); - { - this.state = 11067; - this.match(PostgreSqlParser.PARAM); - } - break; - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 2); - { - this.state = 11068; - this.colid(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_varname(): Decl_varnameContext { - let localContext = new Decl_varnameContext(this.context, this.state); - this.enterRule(localContext, 1544, PostgreSqlParser.RULE_decl_varname); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11071; - this.any_identifier(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_const(): Decl_constContext { - let localContext = new Decl_constContext(this.context, this.state); - this.enterRule(localContext, 1546, PostgreSqlParser.RULE_decl_const); - try { - this.state = 11075; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1178, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11074; - this.match(PostgreSqlParser.KW_CONSTANT); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_datatype(): Decl_datatypeContext { - let localContext = new Decl_datatypeContext(this.context, this.state); - this.enterRule(localContext, 1548, PostgreSqlParser.RULE_decl_datatype); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11077; - this.typename(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_collate(): Decl_collateContext { - let localContext = new Decl_collateContext(this.context, this.state); - this.enterRule(localContext, 1550, PostgreSqlParser.RULE_decl_collate); - try { - this.state = 11082; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.SEMI: - case PostgreSqlParser.EQUAL: - case PostgreSqlParser.COLON_EQUALS: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_NOT: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_COLLATE: - this.enterOuterAlt(localContext, 2); - { - this.state = 11080; - this.match(PostgreSqlParser.KW_COLLATE); - this.state = 11081; - this.any_name(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_notnull(): Decl_notnullContext { - let localContext = new Decl_notnullContext(this.context, this.state); - this.enterRule(localContext, 1552, PostgreSqlParser.RULE_decl_notnull); - try { - this.state = 11087; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.SEMI: - case PostgreSqlParser.EQUAL: - case PostgreSqlParser.COLON_EQUALS: - case PostgreSqlParser.KW_DEFAULT: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_NOT: - this.enterOuterAlt(localContext, 2); - { - this.state = 11085; - this.match(PostgreSqlParser.KW_NOT); - this.state = 11086; - this.match(PostgreSqlParser.KW_NULL); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_defval(): Decl_defvalContext { - let localContext = new Decl_defvalContext(this.context, this.state); - this.enterRule(localContext, 1554, PostgreSqlParser.RULE_decl_defval); - try { - this.state = 11093; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.SEMI: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.EQUAL: - case PostgreSqlParser.COLON_EQUALS: - case PostgreSqlParser.KW_DEFAULT: - this.enterOuterAlt(localContext, 2); - { - this.state = 11090; - this.decl_defkey(); - this.state = 11091; - this.sql_expression(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public decl_defkey(): Decl_defkeyContext { - let localContext = new Decl_defkeyContext(this.context, this.state); - this.enterRule(localContext, 1556, PostgreSqlParser.RULE_decl_defkey); - try { - this.state = 11097; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.EQUAL: - case PostgreSqlParser.COLON_EQUALS: - this.enterOuterAlt(localContext, 1); - { - this.state = 11095; - this.assign_operator(); - } - break; - case PostgreSqlParser.KW_DEFAULT: - this.enterOuterAlt(localContext, 2); - { - this.state = 11096; - this.match(PostgreSqlParser.KW_DEFAULT); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public assign_operator(): Assign_operatorContext { - let localContext = new Assign_operatorContext(this.context, this.state); - this.enterRule(localContext, 1558, PostgreSqlParser.RULE_assign_operator); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11099; - _la = this.tokenStream.LA(1); - if(!(_la === 10 || _la === 20)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public proc_sect(): Proc_sectContext { - let localContext = new Proc_sectContext(this.context, this.state); - this.enterRule(localContext, 1560, PostgreSqlParser.RULE_proc_sect); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 11104; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1183, this.context); - while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { - if (alternative === 1) { - { - { - this.state = 11101; - this.proc_stmt(); - } - } - } - this.state = 11106; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1183, this.context); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public proc_stmt(): Proc_stmtContext { - let localContext = new Proc_stmtContext(this.context, this.state); - this.enterRule(localContext, 1562, PostgreSqlParser.RULE_proc_stmt); - try { - this.state = 11134; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1184, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 11107; - this.pl_block(); - this.state = 11108; - this.match(PostgreSqlParser.SEMI); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11110; - this.stmt_return(); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 11111; - this.stmt_raise(); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 11112; - this.stmt_assign(); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 11113; - this.stmt_if(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 11114; - this.stmt_case(); - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 11115; - this.stmt_loop(); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 11116; - this.stmt_while(); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 11117; - this.stmt_for(); - } - break; - case 10: - this.enterOuterAlt(localContext, 10); - { - this.state = 11118; - this.stmt_foreach_a(); - } - break; - case 11: - this.enterOuterAlt(localContext, 11); - { - this.state = 11119; - this.stmt_exit(); - } - break; - case 12: - this.enterOuterAlt(localContext, 12); - { - this.state = 11120; - this.stmt_assert(); - } - break; - case 13: - this.enterOuterAlt(localContext, 13); - { - this.state = 11121; - this.stmt_execsql(); - } - break; - case 14: - this.enterOuterAlt(localContext, 14); - { - this.state = 11122; - this.stmt_dynexecute(); - } - break; - case 15: - this.enterOuterAlt(localContext, 15); - { - this.state = 11123; - this.stmt_perform(); - } - break; - case 16: - this.enterOuterAlt(localContext, 16); - { - this.state = 11124; - this.stmt_call(); - } - break; - case 17: - this.enterOuterAlt(localContext, 17); - { - this.state = 11125; - this.stmt_getdiag(); - } - break; - case 18: - this.enterOuterAlt(localContext, 18); - { - this.state = 11126; - this.stmt_open(); - } - break; - case 19: - this.enterOuterAlt(localContext, 19); - { - this.state = 11127; - this.stmt_fetch(); - } - break; - case 20: - this.enterOuterAlt(localContext, 20); - { - this.state = 11128; - this.stmt_move(); - } - break; - case 21: - this.enterOuterAlt(localContext, 21); - { - this.state = 11129; - this.stmt_close(); - } - break; - case 22: - this.enterOuterAlt(localContext, 22); - { - this.state = 11130; - this.stmt_null(); - } - break; - case 23: - this.enterOuterAlt(localContext, 23); - { - this.state = 11131; - this.stmt_commit(); - } - break; - case 24: - this.enterOuterAlt(localContext, 24); - { - this.state = 11132; - this.stmt_rollback(); - } - break; - case 25: - this.enterOuterAlt(localContext, 25); - { - this.state = 11133; - this.stmt_set(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_perform(): Stmt_performContext { - let localContext = new Stmt_performContext(this.context, this.state); - this.enterRule(localContext, 1564, PostgreSqlParser.RULE_stmt_perform); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11136; - this.match(PostgreSqlParser.KW_PERFORM); - this.state = 11137; - this.expr_until_semi(); - this.state = 11138; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_call(): Stmt_callContext { - let localContext = new Stmt_callContext(this.context, this.state); - this.enterRule(localContext, 1566, PostgreSqlParser.RULE_stmt_call); - try { - this.state = 11156; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_CALL: - this.enterOuterAlt(localContext, 1); - { - this.state = 11140; - this.match(PostgreSqlParser.KW_CALL); - this.state = 11141; - this.any_identifier(); - this.state = 11147; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1185, this.context) ) { - case 1: - { - this.state = 11142; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 11143; - this.opt_expr_list(); - this.state = 11144; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 11145; - this.match(PostgreSqlParser.SEMI); - } - break; - } - } - break; - case PostgreSqlParser.KW_DO: - this.enterOuterAlt(localContext, 2); - { - this.state = 11149; - this.match(PostgreSqlParser.KW_DO); - this.state = 11150; - this.any_identifier(); - this.state = 11151; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 11152; - this.opt_expr_list(); - this.state = 11153; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 11154; - this.match(PostgreSqlParser.SEMI); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_expr_list(): Opt_expr_listContext { - let localContext = new Opt_expr_listContext(this.context, this.state); - this.enterRule(localContext, 1568, PostgreSqlParser.RULE_opt_expr_list); - try { - this.state = 11160; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.CLOSE_PAREN: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.OPEN_PAREN: - case PostgreSqlParser.PLUS: - case PostgreSqlParser.MINUS: - case PostgreSqlParser.PARAM: - case PostgreSqlParser.Operator: - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_CASE: - case PostgreSqlParser.KW_CAST: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_CURRENT_CATALOG: - case PostgreSqlParser.KW_CURRENT_DATE: - case PostgreSqlParser.KW_CURRENT_ROLE: - case PostgreSqlParser.KW_CURRENT_TIME: - case PostgreSqlParser.KW_CURRENT_TIMESTAMP: - case PostgreSqlParser.KW_CURRENT_USER: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FALSE: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_LOCALTIME: - case PostgreSqlParser.KW_LOCALTIMESTAMP: - case PostgreSqlParser.KW_NOT: - case PostgreSqlParser.KW_NULL: - case PostgreSqlParser.KW_SESSION_USER: - case PostgreSqlParser.KW_TRUE: - case PostgreSqlParser.KW_UNIQUE: - case PostgreSqlParser.KW_USER: - case PostgreSqlParser.KW_AUTHORIZATION: - case PostgreSqlParser.KW_BINARY: - case PostgreSqlParser.KW_COLLATION: - case PostgreSqlParser.KW_CONCURRENTLY: - case PostgreSqlParser.KW_CROSS: - case PostgreSqlParser.KW_CURRENT_SCHEMA: - case PostgreSqlParser.KW_FREEZE: - case PostgreSqlParser.KW_FULL: - case PostgreSqlParser.KW_ILIKE: - case PostgreSqlParser.KW_INNER: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_ISNULL: - case PostgreSqlParser.KW_JOIN: - case PostgreSqlParser.KW_LEFT: - case PostgreSqlParser.KW_LIKE: - case PostgreSqlParser.KW_NATURAL: - case PostgreSqlParser.KW_NOTNULL: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_OVERLAPS: - case PostgreSqlParser.KW_RIGHT: - case PostgreSqlParser.KW_SIMILAR: - case PostgreSqlParser.KW_VERBOSE: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_TABLESAMPLE: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.BinaryStringConstant: - case PostgreSqlParser.HexadecimalStringConstant: - case PostgreSqlParser.Integral: - case PostgreSqlParser.Numeric: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 2); - { - this.state = 11159; - this.expr_list(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_assign(): Stmt_assignContext { - let localContext = new Stmt_assignContext(this.context, this.state); - this.enterRule(localContext, 1570, PostgreSqlParser.RULE_stmt_assign); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11162; - this.assign_var(); - this.state = 11163; - this.assign_operator(); - this.state = 11164; - this.sql_expression(); - this.state = 11165; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_getdiag(): Stmt_getdiagContext { - let localContext = new Stmt_getdiagContext(this.context, this.state); - this.enterRule(localContext, 1572, PostgreSqlParser.RULE_stmt_getdiag); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11167; - this.match(PostgreSqlParser.KW_GET); - this.state = 11168; - this.getdiag_area_opt(); - this.state = 11169; - this.match(PostgreSqlParser.KW_DIAGNOSTICS); - this.state = 11170; - this.getdiag_list(); - this.state = 11171; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public getdiag_area_opt(): Getdiag_area_optContext { - let localContext = new Getdiag_area_optContext(this.context, this.state); - this.enterRule(localContext, 1574, PostgreSqlParser.RULE_getdiag_area_opt); - try { - this.state = 11176; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_DIAGNOSTICS: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_CURRENT: - this.enterOuterAlt(localContext, 2); - { - this.state = 11174; - this.match(PostgreSqlParser.KW_CURRENT); - } - break; - case PostgreSqlParser.KW_STACKED: - this.enterOuterAlt(localContext, 3); - { - this.state = 11175; - this.match(PostgreSqlParser.KW_STACKED); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public getdiag_list(): Getdiag_listContext { - let localContext = new Getdiag_listContext(this.context, this.state); - this.enterRule(localContext, 1576, PostgreSqlParser.RULE_getdiag_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11178; - this.getdiag_list_item(); - this.state = 11183; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 11179; - this.match(PostgreSqlParser.COMMA); - this.state = 11180; - this.getdiag_list_item(); - } - } - this.state = 11185; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public getdiag_list_item(): Getdiag_list_itemContext { - let localContext = new Getdiag_list_itemContext(this.context, this.state); - this.enterRule(localContext, 1578, PostgreSqlParser.RULE_getdiag_list_item); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11186; - this.getdiag_target(); - this.state = 11187; - this.assign_operator(); - this.state = 11188; - this.getdiag_item(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public getdiag_item(): Getdiag_itemContext { - let localContext = new Getdiag_itemContext(this.context, this.state); - this.enterRule(localContext, 1580, PostgreSqlParser.RULE_getdiag_item); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11190; - this.colid(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public getdiag_target(): Getdiag_targetContext { - let localContext = new Getdiag_targetContext(this.context, this.state); - this.enterRule(localContext, 1582, PostgreSqlParser.RULE_getdiag_target); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11192; - this.assign_var(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public assign_var(): Assign_varContext { - let localContext = new Assign_varContext(this.context, this.state); - this.enterRule(localContext, 1584, PostgreSqlParser.RULE_assign_var); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11196; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - { - this.state = 11194; - this.any_name(); - } - break; - case PostgreSqlParser.PARAM: - { - this.state = 11195; - this.match(PostgreSqlParser.PARAM); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 11204; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 4) { - { - { - this.state = 11198; - this.match(PostgreSqlParser.OPEN_BRACKET); - this.state = 11199; - this.expr_until_rightbracket(); - this.state = 11200; - this.match(PostgreSqlParser.CLOSE_BRACKET); - } - } - this.state = 11206; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_if(): Stmt_ifContext { - let localContext = new Stmt_ifContext(this.context, this.state); - this.enterRule(localContext, 1586, PostgreSqlParser.RULE_stmt_if); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11207; - this.match(PostgreSqlParser.KW_IF); - this.state = 11208; - this.expr_until_then(); - this.state = 11209; - this.match(PostgreSqlParser.KW_THEN); - this.state = 11210; - this.proc_sect(); - this.state = 11211; - this.stmt_elsifs(); - this.state = 11212; - this.stmt_else(); - this.state = 11213; - this.match(PostgreSqlParser.KW_END); - this.state = 11214; - this.match(PostgreSqlParser.KW_IF); - this.state = 11215; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_elsifs(): Stmt_elsifsContext { - let localContext = new Stmt_elsifsContext(this.context, this.state); - this.enterRule(localContext, 1588, PostgreSqlParser.RULE_stmt_elsifs); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11224; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 502) { - { - { - this.state = 11217; - this.match(PostgreSqlParser.KW_ELSIF); - this.state = 11218; - this.a_expr(); - this.state = 11219; - this.match(PostgreSqlParser.KW_THEN); - this.state = 11220; - this.proc_sect(); - } - } - this.state = 11226; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_else(): Stmt_elseContext { - let localContext = new Stmt_elseContext(this.context, this.state); - this.enterRule(localContext, 1590, PostgreSqlParser.RULE_stmt_else); - try { - this.state = 11230; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_END: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_ELSE: - this.enterOuterAlt(localContext, 2); - { - this.state = 11228; - this.match(PostgreSqlParser.KW_ELSE); - this.state = 11229; - this.proc_sect(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_case(): Stmt_caseContext { - let localContext = new Stmt_caseContext(this.context, this.state); - this.enterRule(localContext, 1592, PostgreSqlParser.RULE_stmt_case); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11232; - this.match(PostgreSqlParser.KW_CASE); - this.state = 11233; - this.opt_expr_until_when(); - this.state = 11234; - this.case_when_list(); - this.state = 11235; - this.opt_case_else(); - this.state = 11236; - this.match(PostgreSqlParser.KW_END); - this.state = 11237; - this.match(PostgreSqlParser.KW_CASE); - this.state = 11238; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_expr_until_when(): Opt_expr_until_whenContext { - let localContext = new Opt_expr_until_whenContext(this.context, this.state); - this.enterRule(localContext, 1594, PostgreSqlParser.RULE_opt_expr_until_when); - try { - this.state = 11242; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1194, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11241; - this.sql_expression(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public case_when_list(): Case_when_listContext { - let localContext = new Case_when_listContext(this.context, this.state); - this.enterRule(localContext, 1596, PostgreSqlParser.RULE_case_when_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11245; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - do { - { - { - this.state = 11244; - this.case_when(); - } - } - this.state = 11247; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } while (_la === 102); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public case_when(): Case_whenContext { - let localContext = new Case_whenContext(this.context, this.state); - this.enterRule(localContext, 1598, PostgreSqlParser.RULE_case_when); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11249; - this.match(PostgreSqlParser.KW_WHEN); - this.state = 11250; - this.expr_list(); - this.state = 11251; - this.match(PostgreSqlParser.KW_THEN); - this.state = 11252; - this.proc_sect(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_case_else(): Opt_case_elseContext { - let localContext = new Opt_case_elseContext(this.context, this.state); - this.enterRule(localContext, 1600, PostgreSqlParser.RULE_opt_case_else); - try { - this.state = 11257; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_END: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_ELSE: - this.enterOuterAlt(localContext, 2); - { - this.state = 11255; - this.match(PostgreSqlParser.KW_ELSE); - this.state = 11256; - this.proc_sect(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_loop(): Stmt_loopContext { - let localContext = new Stmt_loopContext(this.context, this.state); - this.enterRule(localContext, 1602, PostgreSqlParser.RULE_stmt_loop); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11259; - this.opt_loop_label(); - this.state = 11260; - this.loop_body(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_while(): Stmt_whileContext { - let localContext = new Stmt_whileContext(this.context, this.state); - this.enterRule(localContext, 1604, PostgreSqlParser.RULE_stmt_while); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11262; - this.opt_loop_label(); - this.state = 11263; - this.match(PostgreSqlParser.KW_WHILE); - this.state = 11264; - this.expr_until_loop(); - this.state = 11265; - this.loop_body(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_for(): Stmt_forContext { - let localContext = new Stmt_forContext(this.context, this.state); - this.enterRule(localContext, 1606, PostgreSqlParser.RULE_stmt_for); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11267; - this.opt_loop_label(); - this.state = 11268; - this.match(PostgreSqlParser.KW_FOR); - this.state = 11269; - this.for_control(); - this.state = 11270; - this.loop_body(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public for_control(): For_controlContext { - let localContext = new For_controlContext(this.context, this.state); - this.enterRule(localContext, 1608, PostgreSqlParser.RULE_for_control); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11272; - this.for_variable(); - this.state = 11273; - this.match(PostgreSqlParser.KW_IN); - this.state = 11289; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1197, this.context) ) { - case 1: - { - this.state = 11274; - this.cursor_name(); - this.state = 11275; - this.opt_cursor_parameters(); - } - break; - case 2: - { - this.state = 11277; - this.selectstmt(); - } - break; - case 3: - { - this.state = 11278; - this.explainstmt(); - } - break; - case 4: - { - this.state = 11279; - this.match(PostgreSqlParser.KW_EXECUTE); - this.state = 11280; - this.a_expr(); - this.state = 11281; - this.opt_for_using_expression(); - } - break; - case 5: - { - this.state = 11283; - this.opt_reverse(); - this.state = 11284; - this.a_expr(); - this.state = 11285; - this.match(PostgreSqlParser.DOT_DOT); - this.state = 11286; - this.a_expr(); - this.state = 11287; - this.opt_by_expression(); - } - break; - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_for_using_expression(): Opt_for_using_expressionContext { - let localContext = new Opt_for_using_expressionContext(this.context, this.state); - this.enterRule(localContext, 1610, PostgreSqlParser.RULE_opt_for_using_expression); - try { - this.state = 11294; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.SEMI: - case PostgreSqlParser.KW_LOOP: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_USING: - this.enterOuterAlt(localContext, 2); - { - this.state = 11292; - this.match(PostgreSqlParser.KW_USING); - this.state = 11293; - this.expr_list(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_cursor_parameters(): Opt_cursor_parametersContext { - let localContext = new Opt_cursor_parametersContext(this.context, this.state); - this.enterRule(localContext, 1612, PostgreSqlParser.RULE_opt_cursor_parameters); - let _la: number; - try { - this.state = 11308; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_LOOP: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.OPEN_PAREN: - this.enterOuterAlt(localContext, 2); - { - this.state = 11297; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 11298; - this.a_expr(); - this.state = 11303; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 11299; - this.match(PostgreSqlParser.COMMA); - this.state = 11300; - this.a_expr(); - } - } - this.state = 11305; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - this.state = 11306; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_reverse(): Opt_reverseContext { - let localContext = new Opt_reverseContext(this.context, this.state); - this.enterRule(localContext, 1614, PostgreSqlParser.RULE_opt_reverse); - try { - this.state = 11312; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1201, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11311; - this.match(PostgreSqlParser.KW_REVERSE); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_by_expression(): Opt_by_expressionContext { - let localContext = new Opt_by_expressionContext(this.context, this.state); - this.enterRule(localContext, 1616, PostgreSqlParser.RULE_opt_by_expression); - try { - this.state = 11317; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_LOOP: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_BY: - this.enterOuterAlt(localContext, 2); - { - this.state = 11315; - this.match(PostgreSqlParser.KW_BY); - this.state = 11316; - this.a_expr(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public for_variable(): For_variableContext { - let localContext = new For_variableContext(this.context, this.state); - this.enterRule(localContext, 1618, PostgreSqlParser.RULE_for_variable); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11319; - this.any_name_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_foreach_a(): Stmt_foreach_aContext { - let localContext = new Stmt_foreach_aContext(this.context, this.state); - this.enterRule(localContext, 1620, PostgreSqlParser.RULE_stmt_foreach_a); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11321; - this.opt_loop_label(); - this.state = 11322; - this.match(PostgreSqlParser.KW_FOREACH); - this.state = 11323; - this.for_variable(); - this.state = 11324; - this.foreach_slice(); - this.state = 11325; - this.match(PostgreSqlParser.KW_IN); - this.state = 11326; - this.match(PostgreSqlParser.KW_ARRAY); - this.state = 11327; - this.a_expr(); - this.state = 11328; - this.loop_body(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public foreach_slice(): Foreach_sliceContext { - let localContext = new Foreach_sliceContext(this.context, this.state); - this.enterRule(localContext, 1622, PostgreSqlParser.RULE_foreach_slice); - try { - this.state = 11333; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_IN: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_SLICE: - this.enterOuterAlt(localContext, 2); - { - this.state = 11331; - this.match(PostgreSqlParser.KW_SLICE); - this.state = 11332; - this.iconst(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_exit(): Stmt_exitContext { - let localContext = new Stmt_exitContext(this.context, this.state); - this.enterRule(localContext, 1624, PostgreSqlParser.RULE_stmt_exit); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11335; - this.exit_type(); - this.state = 11336; - this.opt_label(); - this.state = 11338; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 102) { - { - this.state = 11337; - this.opt_exitcond(); - } - } - - this.state = 11340; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public exit_type(): Exit_typeContext { - let localContext = new Exit_typeContext(this.context, this.state); - this.enterRule(localContext, 1626, PostgreSqlParser.RULE_exit_type); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11342; - _la = this.tokenStream.LA(1); - if(!(_la === 167 || _la === 507)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_return(): Stmt_returnContext { - let localContext = new Stmt_returnContext(this.context, this.state); - this.enterRule(localContext, 1628, PostgreSqlParser.RULE_stmt_return); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11344; - this.match(PostgreSqlParser.KW_RETURN); - this.state = 11356; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1206, this.context) ) { - case 1: - { - this.state = 11345; - this.match(PostgreSqlParser.KW_NEXT); - this.state = 11346; - this.sql_expression(); - } - break; - case 2: - { - this.state = 11347; - this.match(PostgreSqlParser.KW_QUERY); - this.state = 11353; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_EXECUTE: - { - this.state = 11348; - this.match(PostgreSqlParser.KW_EXECUTE); - this.state = 11349; - this.a_expr(); - this.state = 11350; - this.opt_for_using_expression(); - } - break; - case PostgreSqlParser.OPEN_PAREN: - case PostgreSqlParser.KW_SELECT: - case PostgreSqlParser.KW_TABLE: - case PostgreSqlParser.KW_WITH: - case PostgreSqlParser.KW_VALUES: - { - this.state = 11352; - this.selectstmt(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 3: - { - this.state = 11355; - this.opt_return_result(); - } - break; - } - this.state = 11358; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_return_result(): Opt_return_resultContext { - let localContext = new Opt_return_resultContext(this.context, this.state); - this.enterRule(localContext, 1630, PostgreSqlParser.RULE_opt_return_result); - try { - this.state = 11362; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1207, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11361; - this.sql_expression(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_raise(): Stmt_raiseContext { - let localContext = new Stmt_raiseContext(this.context, this.state); - this.enterRule(localContext, 1632, PostgreSqlParser.RULE_stmt_raise); - let _la: number; - try { - this.state = 11398; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1212, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 11364; - this.match(PostgreSqlParser.KW_RAISE); - this.state = 11366; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 512)) & ~0x1F) === 0 && ((1 << (_la - 512)) & 63) !== 0)) { - { - this.state = 11365; - this.opt_stmt_raise_level(); - } - } - - this.state = 11368; - this.sconst(); - this.state = 11369; - this.opt_raise_list(); - this.state = 11370; - this.opt_raise_using(); - this.state = 11371; - this.match(PostgreSqlParser.SEMI); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11373; - this.match(PostgreSqlParser.KW_RAISE); - this.state = 11375; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1209, this.context) ) { - case 1: - { - this.state = 11374; - this.opt_stmt_raise_level(); - } - break; - } - this.state = 11377; - this.identifier(); - this.state = 11378; - this.opt_raise_using(); - this.state = 11379; - this.match(PostgreSqlParser.SEMI); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 11381; - this.match(PostgreSqlParser.KW_RAISE); - this.state = 11383; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 512)) & ~0x1F) === 0 && ((1 << (_la - 512)) & 63) !== 0)) { - { - this.state = 11382; - this.opt_stmt_raise_level(); - } - } - - this.state = 11385; - this.match(PostgreSqlParser.KW_SQLSTATE); - this.state = 11386; - this.sconst(); - this.state = 11387; - this.opt_raise_using(); - this.state = 11388; - this.match(PostgreSqlParser.SEMI); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 11390; - this.match(PostgreSqlParser.KW_RAISE); - this.state = 11392; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 512)) & ~0x1F) === 0 && ((1 << (_la - 512)) & 63) !== 0)) { - { - this.state = 11391; - this.opt_stmt_raise_level(); - } - } - - this.state = 11394; - this.opt_raise_using(); - this.state = 11395; - this.match(PostgreSqlParser.SEMI); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 11397; - this.match(PostgreSqlParser.KW_RAISE); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_stmt_raise_level(): Opt_stmt_raise_levelContext { - let localContext = new Opt_stmt_raise_levelContext(this.context, this.state); - this.enterRule(localContext, 1634, PostgreSqlParser.RULE_opt_stmt_raise_level); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11400; - _la = this.tokenStream.LA(1); - if(!(((((_la - 512)) & ~0x1F) === 0 && ((1 << (_la - 512)) & 63) !== 0))) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_raise_list(): Opt_raise_listContext { - let localContext = new Opt_raise_listContext(this.context, this.state); - this.enterRule(localContext, 1636, PostgreSqlParser.RULE_opt_raise_list); - let _la: number; - try { - this.state = 11409; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.SEMI: - case PostgreSqlParser.KW_USING: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.COMMA: - this.enterOuterAlt(localContext, 2); - { - this.state = 11405; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - do { - { - { - this.state = 11403; - this.match(PostgreSqlParser.COMMA); - this.state = 11404; - this.a_expr(); - } - } - this.state = 11407; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } while (_la === 6); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_raise_using(): Opt_raise_usingContext { - let localContext = new Opt_raise_usingContext(this.context, this.state); - this.enterRule(localContext, 1638, PostgreSqlParser.RULE_opt_raise_using); - try { - this.state = 11414; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.SEMI: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_USING: - this.enterOuterAlt(localContext, 2); - { - this.state = 11412; - this.match(PostgreSqlParser.KW_USING); - this.state = 11413; - this.opt_raise_using_elem_list(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_raise_using_elem(): Opt_raise_using_elemContext { - let localContext = new Opt_raise_using_elemContext(this.context, this.state); - this.enterRule(localContext, 1640, PostgreSqlParser.RULE_opt_raise_using_elem); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11416; - this.identifier(); - this.state = 11417; - this.match(PostgreSqlParser.EQUAL); - this.state = 11418; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_raise_using_elem_list(): Opt_raise_using_elem_listContext { - let localContext = new Opt_raise_using_elem_listContext(this.context, this.state); - this.enterRule(localContext, 1642, PostgreSqlParser.RULE_opt_raise_using_elem_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11420; - this.opt_raise_using_elem(); - this.state = 11425; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 11421; - this.match(PostgreSqlParser.COMMA); - this.state = 11422; - this.opt_raise_using_elem(); - } - } - this.state = 11427; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_assert(): Stmt_assertContext { - let localContext = new Stmt_assertContext(this.context, this.state); - this.enterRule(localContext, 1644, PostgreSqlParser.RULE_stmt_assert); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11428; - this.match(PostgreSqlParser.KW_ASSERT); - this.state = 11429; - this.sql_expression(); - this.state = 11430; - this.opt_stmt_assert_message(); - this.state = 11431; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_stmt_assert_message(): Opt_stmt_assert_messageContext { - let localContext = new Opt_stmt_assert_messageContext(this.context, this.state); - this.enterRule(localContext, 1646, PostgreSqlParser.RULE_opt_stmt_assert_message); - try { - this.state = 11436; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.SEMI: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.COMMA: - this.enterOuterAlt(localContext, 2); - { - this.state = 11434; - this.match(PostgreSqlParser.COMMA); - this.state = 11435; - this.sql_expression(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public loop_body(): Loop_bodyContext { - let localContext = new Loop_bodyContext(this.context, this.state); - this.enterRule(localContext, 1648, PostgreSqlParser.RULE_loop_body); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11438; - this.match(PostgreSqlParser.KW_LOOP); - this.state = 11439; - this.proc_sect(); - this.state = 11440; - this.match(PostgreSqlParser.KW_END); - this.state = 11441; - this.match(PostgreSqlParser.KW_LOOP); - this.state = 11442; - this.opt_label(); - this.state = 11443; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_execsql(): Stmt_execsqlContext { - let localContext = new Stmt_execsqlContext(this.context, this.state); - this.enterRule(localContext, 1650, PostgreSqlParser.RULE_stmt_execsql); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11445; - this.make_execsql_stmt(); - this.state = 11446; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_dynexecute(): Stmt_dynexecuteContext { - let localContext = new Stmt_dynexecuteContext(this.context, this.state); - this.enterRule(localContext, 1652, PostgreSqlParser.RULE_stmt_dynexecute); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11448; - this.match(PostgreSqlParser.KW_EXECUTE); - this.state = 11449; - this.a_expr(); - this.state = 11457; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1218, this.context) ) { - case 1: - { - this.state = 11450; - this.opt_execute_into(); - this.state = 11451; - this.opt_execute_using(); - } - break; - case 2: - { - this.state = 11453; - this.opt_execute_using(); - this.state = 11454; - this.opt_execute_into(); - } - break; - case 3: - // tslint:disable-next-line:no-empty - { - } - break; - } - this.state = 11459; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_execute_using(): Opt_execute_usingContext { - let localContext = new Opt_execute_usingContext(this.context, this.state); - this.enterRule(localContext, 1654, PostgreSqlParser.RULE_opt_execute_using); - try { - this.state = 11464; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.SEMI: - case PostgreSqlParser.KW_INTO: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_USING: - this.enterOuterAlt(localContext, 2); - { - this.state = 11462; - this.match(PostgreSqlParser.KW_USING); - this.state = 11463; - this.opt_execute_using_list(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_execute_using_list(): Opt_execute_using_listContext { - let localContext = new Opt_execute_using_listContext(this.context, this.state); - this.enterRule(localContext, 1656, PostgreSqlParser.RULE_opt_execute_using_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11466; - this.a_expr(); - this.state = 11471; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 11467; - this.match(PostgreSqlParser.COMMA); - this.state = 11468; - this.a_expr(); - } - } - this.state = 11473; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_execute_into(): Opt_execute_intoContext { - let localContext = new Opt_execute_intoContext(this.context, this.state); - this.enterRule(localContext, 1658, PostgreSqlParser.RULE_opt_execute_into); - try { - this.state = 11480; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.SEMI: - case PostgreSqlParser.KW_USING: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_INTO: - this.enterOuterAlt(localContext, 2); - { - this.state = 11475; - this.match(PostgreSqlParser.KW_INTO); - this.state = 11477; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1221, this.context) ) { - case 1: - { - this.state = 11476; - this.match(PostgreSqlParser.KW_STRICT); - } - break; - } - this.state = 11479; - this.into_target(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_open(): Stmt_openContext { - let localContext = new Stmt_openContext(this.context, this.state); - this.enterRule(localContext, 1660, PostgreSqlParser.RULE_stmt_open); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11482; - this.match(PostgreSqlParser.KW_OPEN); - this.state = 11500; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1225, this.context) ) { - case 1: - { - this.state = 11483; - this.cursor_variable(); - this.state = 11484; - this.opt_scroll_option(); - this.state = 11485; - this.match(PostgreSqlParser.KW_FOR); - this.state = 11491; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.OPEN_PAREN: - case PostgreSqlParser.KW_SELECT: - case PostgreSqlParser.KW_TABLE: - case PostgreSqlParser.KW_WITH: - case PostgreSqlParser.KW_VALUES: - { - this.state = 11486; - this.selectstmt(); - } - break; - case PostgreSqlParser.KW_EXECUTE: - { - this.state = 11487; - this.match(PostgreSqlParser.KW_EXECUTE); - this.state = 11488; - this.sql_expression(); - this.state = 11489; - this.opt_open_using(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 2: - { - this.state = 11493; - this.colid(); - this.state = 11498; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2) { - { - this.state = 11494; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 11495; - this.opt_open_bound_list(); - this.state = 11496; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - - } - break; - } - this.state = 11502; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_open_bound_list_item(): Opt_open_bound_list_itemContext { - let localContext = new Opt_open_bound_list_itemContext(this.context, this.state); - this.enterRule(localContext, 1662, PostgreSqlParser.RULE_opt_open_bound_list_item); - try { - this.state = 11509; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1226, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 11504; - this.colid(); - this.state = 11505; - this.match(PostgreSqlParser.COLON_EQUALS); - this.state = 11506; - this.a_expr(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11508; - this.a_expr(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_open_bound_list(): Opt_open_bound_listContext { - let localContext = new Opt_open_bound_listContext(this.context, this.state); - this.enterRule(localContext, 1664, PostgreSqlParser.RULE_opt_open_bound_list); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11511; - this.opt_open_bound_list_item(); - this.state = 11516; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 11512; - this.match(PostgreSqlParser.COMMA); - this.state = 11513; - this.opt_open_bound_list_item(); - } - } - this.state = 11518; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_open_using(): Opt_open_usingContext { - let localContext = new Opt_open_usingContext(this.context, this.state); - this.enterRule(localContext, 1666, PostgreSqlParser.RULE_opt_open_using); - try { - this.state = 11522; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.SEMI: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_USING: - this.enterOuterAlt(localContext, 2); - { - this.state = 11520; - this.match(PostgreSqlParser.KW_USING); - this.state = 11521; - this.expr_list(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_scroll_option(): Opt_scroll_optionContext { - let localContext = new Opt_scroll_optionContext(this.context, this.state); - this.enterRule(localContext, 1668, PostgreSqlParser.RULE_opt_scroll_option); - try { - this.state = 11528; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_FOR: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_SCROLL: - this.enterOuterAlt(localContext, 2); - { - this.state = 11525; - this.opt_scroll_option_no(); - this.state = 11526; - this.match(PostgreSqlParser.KW_SCROLL); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_scroll_option_no(): Opt_scroll_option_noContext { - let localContext = new Opt_scroll_option_noContext(this.context, this.state); - this.enterRule(localContext, 1670, PostgreSqlParser.RULE_opt_scroll_option_no); - try { - this.state = 11532; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_SCROLL: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_NO: - this.enterOuterAlt(localContext, 2); - { - this.state = 11531; - this.match(PostgreSqlParser.KW_NO); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_fetch(): Stmt_fetchContext { - let localContext = new Stmt_fetchContext(this.context, this.state); - this.enterRule(localContext, 1672, PostgreSqlParser.RULE_stmt_fetch); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11534; - this.match(PostgreSqlParser.KW_FETCH); - this.state = 11536; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1231, this.context) ) { - case 1: - { - this.state = 11535; - localContext._direction = this.opt_fetch_direction(); - } - break; - } - this.state = 11538; - this.opt_cursor_from(); - this.state = 11539; - this.cursor_variable(); - this.state = 11540; - this.match(PostgreSqlParser.KW_INTO); - this.state = 11541; - this.into_target(); - this.state = 11542; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public into_target(): Into_targetContext { - let localContext = new Into_targetContext(this.context, this.state); - this.enterRule(localContext, 1674, PostgreSqlParser.RULE_into_target); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11544; - this.expr_list(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_cursor_from(): Opt_cursor_fromContext { - let localContext = new Opt_cursor_fromContext(this.context, this.state); - this.enterRule(localContext, 1676, PostgreSqlParser.RULE_opt_cursor_from); - try { - this.state = 11549; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.PARAM: - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_FROM: - this.enterOuterAlt(localContext, 2); - { - this.state = 11547; - this.match(PostgreSqlParser.KW_FROM); - } - break; - case PostgreSqlParser.KW_IN: - this.enterOuterAlt(localContext, 3); - { - this.state = 11548; - this.match(PostgreSqlParser.KW_IN); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_fetch_direction(): Opt_fetch_directionContext { - let localContext = new Opt_fetch_directionContext(this.context, this.state); - this.enterRule(localContext, 1678, PostgreSqlParser.RULE_opt_fetch_direction); - let _la: number; - try { - this.state = 11566; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1234, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 11551; - this.match(PostgreSqlParser.KW_NEXT); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11552; - this.match(PostgreSqlParser.KW_PRIOR); - } - break; - case 3: - this.enterOuterAlt(localContext, 3); - { - this.state = 11553; - this.match(PostgreSqlParser.KW_FIRST); - } - break; - case 4: - this.enterOuterAlt(localContext, 4); - { - this.state = 11554; - this.match(PostgreSqlParser.KW_LAST); - } - break; - case 5: - this.enterOuterAlt(localContext, 5); - { - this.state = 11555; - this.match(PostgreSqlParser.KW_ABSOLUTE); - this.state = 11556; - this.a_expr(); - } - break; - case 6: - this.enterOuterAlt(localContext, 6); - { - this.state = 11557; - this.match(PostgreSqlParser.KW_RELATIVE); - this.state = 11558; - this.a_expr(); - } - break; - case 7: - this.enterOuterAlt(localContext, 7); - { - this.state = 11559; - this.a_expr(); - } - break; - case 8: - this.enterOuterAlt(localContext, 8); - { - this.state = 11560; - this.match(PostgreSqlParser.KW_ALL); - } - break; - case 9: - this.enterOuterAlt(localContext, 9); - { - this.state = 11561; - _la = this.tokenStream.LA(1); - if(!(_la === 144 || _la === 210)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 11564; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1233, this.context) ) { - case 1: - { - this.state = 11562; - this.a_expr(); - } - break; - case 2: - { - this.state = 11563; - this.match(PostgreSqlParser.KW_ALL); - } - break; - } - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_move(): Stmt_moveContext { - let localContext = new Stmt_moveContext(this.context, this.state); - this.enterRule(localContext, 1680, PostgreSqlParser.RULE_stmt_move); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11568; - this.match(PostgreSqlParser.KW_MOVE); - this.state = 11570; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1235, this.context) ) { - case 1: - { - this.state = 11569; - this.opt_fetch_direction(); - } - break; - } - this.state = 11572; - this.cursor_variable(); - this.state = 11573; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public mergestmt(): MergestmtContext { - let localContext = new MergestmtContext(this.context, this.state); - this.enterRule(localContext, 1682, PostgreSqlParser.RULE_mergestmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11576; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 105) { - { - this.state = 11575; - this.with_clause(); - } - } - - this.state = 11578; - this.match(PostgreSqlParser.KW_MERGE); - this.state = 11579; - this.match(PostgreSqlParser.KW_INTO); - this.state = 11581; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 81) { - { - this.state = 11580; - this.match(PostgreSqlParser.KW_ONLY); - } - } - - this.state = 11583; - this.table_name(); - this.state = 11585; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 9) { - { - this.state = 11584; - this.match(PostgreSqlParser.STAR); - } - } - - this.state = 11591; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266381) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { - { - this.state = 11588; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 36) { - { - this.state = 11587; - this.match(PostgreSqlParser.KW_AS); - } - } - - this.state = 11590; - this.colid(); - } - } - - this.state = 11593; - this.match(PostgreSqlParser.KW_USING); - this.state = 11594; - this.data_source(); - this.state = 11595; - this.match(PostgreSqlParser.KW_ON); - this.state = 11596; - this.join_condition(); - this.state = 11598; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - do { - { - { - this.state = 11597; - this.merge_when_clause(); - } - } - this.state = 11600; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } while (_la === 102); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public data_source(): Data_sourceContext { - let localContext = new Data_sourceContext(this.context, this.state); - this.enterRule(localContext, 1684, PostgreSqlParser.RULE_data_source); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11613; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1245, this.context) ) { - case 1: - { - this.state = 11603; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 81) { - { - this.state = 11602; - this.match(PostgreSqlParser.KW_ONLY); - } - } - - this.state = 11605; - this.table_name(); - this.state = 11607; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 9) { - { - this.state = 11606; - this.match(PostgreSqlParser.STAR); - } - } - - } - break; - case 2: - { - this.state = 11611; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1244, this.context) ) { - case 1: - { - this.state = 11609; - this.select_no_parens(); - } - break; - case 2: - { - this.state = 11610; - this.values_clause(); - } - break; - } - } - break; - } - this.state = 11619; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266381) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { - { - this.state = 11616; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 36) { - { - this.state = 11615; - this.match(PostgreSqlParser.KW_AS); - } - } - - this.state = 11618; - this.colid(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public join_condition(): Join_conditionContext { - let localContext = new Join_conditionContext(this.context, this.state); - this.enterRule(localContext, 1686, PostgreSqlParser.RULE_join_condition); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11621; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public merge_when_clause(): Merge_when_clauseContext { - let localContext = new Merge_when_clauseContext(this.context, this.state); - this.enterRule(localContext, 1688, PostgreSqlParser.RULE_merge_when_clause); - let _la: number; - try { - this.state = 11649; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1252, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 11623; - this.match(PostgreSqlParser.KW_WHEN); - this.state = 11624; - this.match(PostgreSqlParser.KW_MATCHED); - this.state = 11627; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 33) { - { - this.state = 11625; - this.match(PostgreSqlParser.KW_AND); - this.state = 11626; - this.a_expr(); - } - } - - this.state = 11629; - this.match(PostgreSqlParser.KW_THEN); - this.state = 11634; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_UPDATE: - { - this.state = 11630; - this.merge_update(); - } - break; - case PostgreSqlParser.KW_DELETE: - { - this.state = 11631; - this.match(PostgreSqlParser.KW_DELETE); - } - break; - case PostgreSqlParser.KW_DO: - { - this.state = 11632; - this.match(PostgreSqlParser.KW_DO); - this.state = 11633; - this.match(PostgreSqlParser.KW_NOTHING); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11636; - this.match(PostgreSqlParser.KW_WHEN); - this.state = 11637; - this.match(PostgreSqlParser.KW_NOT); - this.state = 11638; - this.match(PostgreSqlParser.KW_MATCHED); - this.state = 11641; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 33) { - { - this.state = 11639; - this.match(PostgreSqlParser.KW_AND); - this.state = 11640; - this.a_expr(); - } - } - - this.state = 11643; - this.match(PostgreSqlParser.KW_THEN); - this.state = 11647; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_INSERT: - { - this.state = 11644; - this.merge_insert(); - } - break; - case PostgreSqlParser.KW_DO: - { - this.state = 11645; - this.match(PostgreSqlParser.KW_DO); - this.state = 11646; - this.match(PostgreSqlParser.KW_NOTHING); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public merge_insert(): Merge_insertContext { - let localContext = new Merge_insertContext(this.context, this.state); - this.enterRule(localContext, 1690, PostgreSqlParser.RULE_merge_insert); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11651; - this.match(PostgreSqlParser.KW_INSERT); - this.state = 11656; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 2) { - { - this.state = 11652; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 11653; - this.column_list(); - this.state = 11654; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - - this.state = 11661; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 463) { - { - this.state = 11658; - this.match(PostgreSqlParser.KW_OVERRIDING); - this.state = 11659; - _la = this.tokenStream.LA(1); - if(!(_la === 99 || _la === 349)) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - this.state = 11660; - this.match(PostgreSqlParser.KW_VALUE); - } - } - - this.state = 11663; - this.default_values_or_values(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public merge_update(): Merge_updateContext { - let localContext = new Merge_updateContext(this.context, this.state); - this.enterRule(localContext, 1692, PostgreSqlParser.RULE_merge_update); - try { - let alternative: number; - this.enterOuterAlt(localContext, 1); - { - this.state = 11665; - this.match(PostgreSqlParser.KW_UPDATE); - this.state = 11666; - this.match(PostgreSqlParser.KW_SET); - this.state = 11679; - this.errorHandler.sync(this); - alternative = 1; - do { - switch (alternative) { - case 1: - { - this.state = 11679; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1255, this.context) ) { - case 1: - { - this.state = 11667; - this.column_name(); - this.state = 11668; - this.match(PostgreSqlParser.EQUAL); - this.state = 11669; - this.exprofdefault(); - } - break; - case 2: - { - this.state = 11671; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 11672; - this.column_list(); - this.state = 11673; - this.match(PostgreSqlParser.CLOSE_PAREN); - this.state = 11674; - this.match(PostgreSqlParser.EQUAL); - this.state = 11675; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 11676; - this.exprofdefaultlist(); - this.state = 11677; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - break; - } - } - break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 11681; - this.errorHandler.sync(this); - alternative = this.interpreter.adaptivePredict(this.tokenStream, 1256, this.context); - } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public default_values_or_values(): Default_values_or_valuesContext { - let localContext = new Default_values_or_valuesContext(this.context, this.state); - this.enterRule(localContext, 1694, PostgreSqlParser.RULE_default_values_or_values); - try { - this.state = 11687; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_VALUES: - this.enterOuterAlt(localContext, 1); - { - this.state = 11683; - this.match(PostgreSqlParser.KW_VALUES); - this.state = 11684; - this.exprofdefaultlist(); - } - break; - case PostgreSqlParser.KW_DEFAULT: - this.enterOuterAlt(localContext, 2); - { - this.state = 11685; - this.match(PostgreSqlParser.KW_DEFAULT); - this.state = 11686; - this.match(PostgreSqlParser.KW_VALUES); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public exprofdefaultlist(): ExprofdefaultlistContext { - let localContext = new ExprofdefaultlistContext(this.context, this.state); - this.enterRule(localContext, 1696, PostgreSqlParser.RULE_exprofdefaultlist); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11689; - this.match(PostgreSqlParser.OPEN_PAREN); - this.state = 11690; - this.exprofdefault(); - this.state = 11695; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 6) { - { - { - this.state = 11691; - this.match(PostgreSqlParser.COMMA); - this.state = 11692; - this.exprofdefault(); - } - } - this.state = 11697; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - this.state = 11698; - this.match(PostgreSqlParser.CLOSE_PAREN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public exprofdefault(): ExprofdefaultContext { - let localContext = new ExprofdefaultContext(this.context, this.state); - this.enterRule(localContext, 1698, PostgreSqlParser.RULE_exprofdefault); - try { - this.state = 11702; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1259, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 11700; - this.sortby(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11701; - this.match(PostgreSqlParser.KW_DEFAULT); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_close(): Stmt_closeContext { - let localContext = new Stmt_closeContext(this.context, this.state); - this.enterRule(localContext, 1700, PostgreSqlParser.RULE_stmt_close); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11704; - this.match(PostgreSqlParser.KW_CLOSE); - this.state = 11705; - this.cursor_variable(); - this.state = 11706; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_null(): Stmt_nullContext { - let localContext = new Stmt_nullContext(this.context, this.state); - this.enterRule(localContext, 1702, PostgreSqlParser.RULE_stmt_null); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11708; - this.match(PostgreSqlParser.KW_NULL); - this.state = 11709; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_commit(): Stmt_commitContext { - let localContext = new Stmt_commitContext(this.context, this.state); - this.enterRule(localContext, 1704, PostgreSqlParser.RULE_stmt_commit); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11711; - this.match(PostgreSqlParser.KW_COMMIT); - this.state = 11713; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 33) { - { - this.state = 11712; - this.plsql_opt_transaction_chain(); - } - } - - this.state = 11715; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_rollback(): Stmt_rollbackContext { - let localContext = new Stmt_rollbackContext(this.context, this.state); - this.enterRule(localContext, 1706, PostgreSqlParser.RULE_stmt_rollback); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11717; - this.match(PostgreSqlParser.KW_ROLLBACK); - this.state = 11719; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 33) { - { - this.state = 11718; - this.plsql_opt_transaction_chain(); - } - } - - this.state = 11721; - this.match(PostgreSqlParser.SEMI); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public plsql_opt_transaction_chain(): Plsql_opt_transaction_chainContext { - let localContext = new Plsql_opt_transaction_chainContext(this.context, this.state); - this.enterRule(localContext, 1708, PostgreSqlParser.RULE_plsql_opt_transaction_chain); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11723; - this.match(PostgreSqlParser.KW_AND); - this.state = 11725; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 269) { - { - this.state = 11724; - this.match(PostgreSqlParser.KW_NO); - } - } - - this.state = 11727; - this.match(PostgreSqlParser.KW_CHAIN); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public stmt_set(): Stmt_setContext { - let localContext = new Stmt_setContext(this.context, this.state); - this.enterRule(localContext, 1710, PostgreSqlParser.RULE_stmt_set); - try { - this.state = 11741; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_SET: - this.enterOuterAlt(localContext, 1); - { - this.state = 11729; - this.match(PostgreSqlParser.KW_SET); - this.state = 11730; - this.any_name(); - this.state = 11731; - this.match(PostgreSqlParser.KW_TO); - this.state = 11732; - this.match(PostgreSqlParser.KW_DEFAULT); - this.state = 11733; - this.match(PostgreSqlParser.SEMI); - } - break; - case PostgreSqlParser.KW_RESET: - this.enterOuterAlt(localContext, 2); - { - this.state = 11735; - this.match(PostgreSqlParser.KW_RESET); - this.state = 11738; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - { - this.state = 11736; - this.any_name(); - } - break; - case PostgreSqlParser.KW_ALL: - { - this.state = 11737; - this.match(PostgreSqlParser.KW_ALL); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - this.state = 11740; - this.match(PostgreSqlParser.SEMI); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public cursor_variable(): Cursor_variableContext { - let localContext = new Cursor_variableContext(this.context, this.state); - this.enterRule(localContext, 1712, PostgreSqlParser.RULE_cursor_variable); - try { - this.state = 11745; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 1); - { - this.state = 11743; - this.colid(); - } - break; - case PostgreSqlParser.PARAM: - this.enterOuterAlt(localContext, 2); - { - this.state = 11744; - this.match(PostgreSqlParser.PARAM); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public exception_sect(): Exception_sectContext { - let localContext = new Exception_sectContext(this.context, this.state); - this.enterRule(localContext, 1714, PostgreSqlParser.RULE_exception_sect); - try { - this.state = 11750; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_END: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_EXCEPTION: - this.enterOuterAlt(localContext, 2); - { - this.state = 11748; - this.match(PostgreSqlParser.KW_EXCEPTION); - this.state = 11749; - this.proc_exceptions(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public proc_exceptions(): Proc_exceptionsContext { - let localContext = new Proc_exceptionsContext(this.context, this.state); - this.enterRule(localContext, 1716, PostgreSqlParser.RULE_proc_exceptions); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11753; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - do { - { - { - this.state = 11752; - this.proc_exception(); - } - } - this.state = 11755; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } while (_la === 102); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public proc_exception(): Proc_exceptionContext { - let localContext = new Proc_exceptionContext(this.context, this.state); - this.enterRule(localContext, 1718, PostgreSqlParser.RULE_proc_exception); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11757; - this.match(PostgreSqlParser.KW_WHEN); - this.state = 11758; - this.proc_conditions(); - this.state = 11759; - this.match(PostgreSqlParser.KW_THEN); - this.state = 11760; - this.proc_sect(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public proc_conditions(): Proc_conditionsContext { - let localContext = new Proc_conditionsContext(this.context, this.state); - this.enterRule(localContext, 1720, PostgreSqlParser.RULE_proc_conditions); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11762; - this.proc_condition(); - this.state = 11767; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - while (_la === 82) { - { - { - this.state = 11763; - this.match(PostgreSqlParser.KW_OR); - this.state = 11764; - this.proc_condition(); - } - } - this.state = 11769; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public proc_condition(): Proc_conditionContext { - let localContext = new Proc_conditionContext(this.context, this.state); - this.enterRule(localContext, 1722, PostgreSqlParser.RULE_proc_condition); - try { - this.state = 11773; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1269, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 11770; - this.any_identifier(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11771; - this.match(PostgreSqlParser.KW_SQLSTATE); - this.state = 11772; - this.sconst(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_block_label(): Opt_block_labelContext { - let localContext = new Opt_block_labelContext(this.context, this.state); - this.enterRule(localContext, 1724, PostgreSqlParser.RULE_opt_block_label); - try { - this.state = 11777; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_DECLARE: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.LESS_LESS: - this.enterOuterAlt(localContext, 2); - { - this.state = 11776; - this.label_decl(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_loop_label(): Opt_loop_labelContext { - let localContext = new Opt_loop_labelContext(this.context, this.state); - this.enterRule(localContext, 1726, PostgreSqlParser.RULE_opt_loop_label); - try { - this.state = 11781; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.KW_FOR: - case PostgreSqlParser.KW_WHILE: - case PostgreSqlParser.KW_FOREACH: - case PostgreSqlParser.KW_LOOP: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.LESS_LESS: - this.enterOuterAlt(localContext, 2); - { - this.state = 11780; - this.label_decl(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_label(): Opt_labelContext { - let localContext = new Opt_labelContext(this.context, this.state); - this.enterRule(localContext, 1728, PostgreSqlParser.RULE_opt_label); - try { - this.state = 11785; - this.errorHandler.sync(this); - switch (this.tokenStream.LA(1)) { - case PostgreSqlParser.EOF: - case PostgreSqlParser.SEMI: - case PostgreSqlParser.KW_WHEN: - this.enterOuterAlt(localContext, 1); - // tslint:disable-next-line:no-empty - { - } - break; - case PostgreSqlParser.KW_AND: - case PostgreSqlParser.KW_ARRAY: - case PostgreSqlParser.KW_COLLATE: - case PostgreSqlParser.KW_CONSTRAINT: - case PostgreSqlParser.KW_DEFAULT: - case PostgreSqlParser.KW_DO: - case PostgreSqlParser.KW_FETCH: - case PostgreSqlParser.KW_IS: - case PostgreSqlParser.KW_OUTER: - case PostgreSqlParser.KW_OVER: - case PostgreSqlParser.KW_ABORT: - case PostgreSqlParser.KW_ABSOLUTE: - case PostgreSqlParser.KW_ACCESS: - case PostgreSqlParser.KW_ACTION: - case PostgreSqlParser.KW_ADD: - case PostgreSqlParser.KW_ADMIN: - case PostgreSqlParser.KW_AFTER: - case PostgreSqlParser.KW_AGGREGATE: - case PostgreSqlParser.KW_ALSO: - case PostgreSqlParser.KW_ALTER: - case PostgreSqlParser.KW_ALWAYS: - case PostgreSqlParser.KW_ASSERTION: - case PostgreSqlParser.KW_ASSIGNMENT: - case PostgreSqlParser.KW_AT: - case PostgreSqlParser.KW_ATTRIBUTE: - case PostgreSqlParser.KW_BACKWARD: - case PostgreSqlParser.KW_BEFORE: - case PostgreSqlParser.KW_BEGIN: - case PostgreSqlParser.KW_BY: - case PostgreSqlParser.KW_CACHE: - case PostgreSqlParser.KW_CALLED: - case PostgreSqlParser.KW_CASCADE: - case PostgreSqlParser.KW_CASCADED: - case PostgreSqlParser.KW_CATALOG: - case PostgreSqlParser.KW_CHAIN: - case PostgreSqlParser.KW_CHARACTERISTICS: - case PostgreSqlParser.KW_CHECKPOINT: - case PostgreSqlParser.KW_CLASS: - case PostgreSqlParser.KW_CLOSE: - case PostgreSqlParser.KW_CLUSTER: - case PostgreSqlParser.KW_COMMENT: - case PostgreSqlParser.KW_COMMENTS: - case PostgreSqlParser.KW_COMMIT: - case PostgreSqlParser.KW_COMMITTED: - case PostgreSqlParser.KW_CONFIGURATION: - case PostgreSqlParser.KW_CONNECTION: - case PostgreSqlParser.KW_CONSTRAINTS: - case PostgreSqlParser.KW_CONTENT: - case PostgreSqlParser.KW_CONTINUE: - case PostgreSqlParser.KW_CONVERSION: - case PostgreSqlParser.KW_COPY: - case PostgreSqlParser.KW_COST: - case PostgreSqlParser.KW_CSV: - case PostgreSqlParser.KW_CURSOR: - case PostgreSqlParser.KW_CYCLE: - case PostgreSqlParser.KW_DATA: - case PostgreSqlParser.KW_DATABASE: - case PostgreSqlParser.KW_DAY: - case PostgreSqlParser.KW_DEALLOCATE: - case PostgreSqlParser.KW_DECLARE: - case PostgreSqlParser.KW_DEFAULTS: - case PostgreSqlParser.KW_DEFERRED: - case PostgreSqlParser.KW_DEFINER: - case PostgreSqlParser.KW_DELETE: - case PostgreSqlParser.KW_DELIMITER: - case PostgreSqlParser.KW_DELIMITERS: - case PostgreSqlParser.KW_DICTIONARY: - case PostgreSqlParser.KW_DISABLE: - case PostgreSqlParser.KW_DISCARD: - case PostgreSqlParser.KW_DOCUMENT: - case PostgreSqlParser.KW_DOMAIN: - case PostgreSqlParser.KW_DOUBLE: - case PostgreSqlParser.KW_DROP: - case PostgreSqlParser.KW_EACH: - case PostgreSqlParser.KW_ENABLE: - case PostgreSqlParser.KW_ENCODING: - case PostgreSqlParser.KW_ENCRYPTED: - case PostgreSqlParser.KW_ENUM: - case PostgreSqlParser.KW_ESCAPE: - case PostgreSqlParser.KW_EVENT: - case PostgreSqlParser.KW_EXCLUDE: - case PostgreSqlParser.KW_EXCLUDING: - case PostgreSqlParser.KW_EXCLUSIVE: - case PostgreSqlParser.KW_EXECUTE: - case PostgreSqlParser.KW_EXPLAIN: - case PostgreSqlParser.KW_EXTENSION: - case PostgreSqlParser.KW_EXTERNAL: - case PostgreSqlParser.KW_FAMILY: - case PostgreSqlParser.KW_FIRST: - case PostgreSqlParser.KW_FOLLOWING: - case PostgreSqlParser.KW_FORCE: - case PostgreSqlParser.KW_FORWARD: - case PostgreSqlParser.KW_FUNCTION: - case PostgreSqlParser.KW_FUNCTIONS: - case PostgreSqlParser.KW_GLOBAL: - case PostgreSqlParser.KW_GRANTED: - case PostgreSqlParser.KW_HANDLER: - case PostgreSqlParser.KW_HEADER: - case PostgreSqlParser.KW_HOLD: - case PostgreSqlParser.KW_HOUR: - case PostgreSqlParser.KW_IDENTITY: - case PostgreSqlParser.KW_IF: - case PostgreSqlParser.KW_IMMEDIATE: - case PostgreSqlParser.KW_IMMUTABLE: - case PostgreSqlParser.KW_IMPLICIT: - case PostgreSqlParser.KW_INCLUDING: - case PostgreSqlParser.KW_INCREMENT: - case PostgreSqlParser.KW_INDEX: - case PostgreSqlParser.KW_INDEXES: - case PostgreSqlParser.KW_INHERIT: - case PostgreSqlParser.KW_INHERITS: - case PostgreSqlParser.KW_INLINE: - case PostgreSqlParser.KW_INSENSITIVE: - case PostgreSqlParser.KW_INSERT: - case PostgreSqlParser.KW_INSTEAD: - case PostgreSqlParser.KW_INVOKER: - case PostgreSqlParser.KW_ISOLATION: - case PostgreSqlParser.KW_KEY: - case PostgreSqlParser.KW_LABEL: - case PostgreSqlParser.KW_LANGUAGE: - case PostgreSqlParser.KW_LARGE: - case PostgreSqlParser.KW_LAST: - case PostgreSqlParser.KW_LEAKPROOF: - case PostgreSqlParser.KW_LEVEL: - case PostgreSqlParser.KW_LISTEN: - case PostgreSqlParser.KW_LOAD: - case PostgreSqlParser.KW_LOCAL: - case PostgreSqlParser.KW_LOCATION: - case PostgreSqlParser.KW_LOCK: - case PostgreSqlParser.KW_MAPPING: - case PostgreSqlParser.KW_MATCH: - case PostgreSqlParser.KW_MATERIALIZED: - case PostgreSqlParser.KW_MAXVALUE: - case PostgreSqlParser.KW_MINUTE: - case PostgreSqlParser.KW_MINVALUE: - case PostgreSqlParser.KW_MODE: - case PostgreSqlParser.KW_MONTH: - case PostgreSqlParser.KW_MOVE: - case PostgreSqlParser.KW_NAME: - case PostgreSqlParser.KW_NAMES: - case PostgreSqlParser.KW_NEXT: - case PostgreSqlParser.KW_NO: - case PostgreSqlParser.KW_NOTHING: - case PostgreSqlParser.KW_NOTIFY: - case PostgreSqlParser.KW_NOWAIT: - case PostgreSqlParser.KW_NULLS: - case PostgreSqlParser.KW_OBJECT: - case PostgreSqlParser.KW_OF: - case PostgreSqlParser.KW_OFF: - case PostgreSqlParser.KW_OIDS: - case PostgreSqlParser.KW_OPERATOR: - case PostgreSqlParser.KW_OPTION: - case PostgreSqlParser.KW_OPTIONS: - case PostgreSqlParser.KW_OWNED: - case PostgreSqlParser.KW_OWNER: - case PostgreSqlParser.KW_PARSER: - case PostgreSqlParser.KW_PARTIAL: - case PostgreSqlParser.KW_PARTITION: - case PostgreSqlParser.KW_PASSING: - case PostgreSqlParser.KW_PASSWORD: - case PostgreSqlParser.KW_PLANS: - case PostgreSqlParser.KW_PRECEDING: - case PostgreSqlParser.KW_PREPARE: - case PostgreSqlParser.KW_PREPARED: - case PostgreSqlParser.KW_PRESERVE: - case PostgreSqlParser.KW_PRIOR: - case PostgreSqlParser.KW_PRIVILEGES: - case PostgreSqlParser.KW_PROCEDURAL: - case PostgreSqlParser.KW_PROCEDURE: - case PostgreSqlParser.KW_PROGRAM: - case PostgreSqlParser.KW_QUOTE: - case PostgreSqlParser.KW_RANGE: - case PostgreSqlParser.KW_READ: - case PostgreSqlParser.KW_REASSIGN: - case PostgreSqlParser.KW_RECHECK: - case PostgreSqlParser.KW_RECURSIVE: - case PostgreSqlParser.KW_REF: - case PostgreSqlParser.KW_REFRESH: - case PostgreSqlParser.KW_REINDEX: - case PostgreSqlParser.KW_RELATIVE: - case PostgreSqlParser.KW_RELEASE: - case PostgreSqlParser.KW_RENAME: - case PostgreSqlParser.KW_REPEATABLE: - case PostgreSqlParser.KW_REPLACE: - case PostgreSqlParser.KW_REPLICA: - case PostgreSqlParser.KW_RESET: - case PostgreSqlParser.KW_RESTART: - case PostgreSqlParser.KW_RESTRICT: - case PostgreSqlParser.KW_RETURNS: - case PostgreSqlParser.KW_REVOKE: - case PostgreSqlParser.KW_ROLE: - case PostgreSqlParser.KW_ROLLBACK: - case PostgreSqlParser.KW_ROWS: - case PostgreSqlParser.KW_RULE: - case PostgreSqlParser.KW_SAVEPOINT: - case PostgreSqlParser.KW_SCHEMA: - case PostgreSqlParser.KW_SCROLL: - case PostgreSqlParser.KW_SEARCH: - case PostgreSqlParser.KW_SECOND: - case PostgreSqlParser.KW_SECURITY: - case PostgreSqlParser.KW_SEQUENCE: - case PostgreSqlParser.KW_SEQUENCES: - case PostgreSqlParser.KW_SERIALIZABLE: - case PostgreSqlParser.KW_SERVER: - case PostgreSqlParser.KW_SESSION: - case PostgreSqlParser.KW_SET: - case PostgreSqlParser.KW_SHARE: - case PostgreSqlParser.KW_SHOW: - case PostgreSqlParser.KW_SIMPLE: - case PostgreSqlParser.KW_SNAPSHOT: - case PostgreSqlParser.KW_STABLE: - case PostgreSqlParser.KW_STANDALONE: - case PostgreSqlParser.KW_START: - case PostgreSqlParser.KW_STATEMENT: - case PostgreSqlParser.KW_STATISTICS: - case PostgreSqlParser.KW_STDIN: - case PostgreSqlParser.KW_STDOUT: - case PostgreSqlParser.KW_STORAGE: - case PostgreSqlParser.KW_STRICT: - case PostgreSqlParser.KW_STRIP: - case PostgreSqlParser.KW_SYSID: - case PostgreSqlParser.KW_SYSTEM: - case PostgreSqlParser.KW_TABLES: - case PostgreSqlParser.KW_TABLESPACE: - case PostgreSqlParser.KW_TEMP: - case PostgreSqlParser.KW_TEMPLATE: - case PostgreSqlParser.KW_TEMPORARY: - case PostgreSqlParser.KW_TEXT: - case PostgreSqlParser.KW_TRANSACTION: - case PostgreSqlParser.KW_TRIGGER: - case PostgreSqlParser.KW_TRUNCATE: - case PostgreSqlParser.KW_TRUSTED: - case PostgreSqlParser.KW_TYPE: - case PostgreSqlParser.KW_TYPES: - case PostgreSqlParser.KW_UNBOUNDED: - case PostgreSqlParser.KW_UNCOMMITTED: - case PostgreSqlParser.KW_UNENCRYPTED: - case PostgreSqlParser.KW_UNKNOWN: - case PostgreSqlParser.KW_UNLISTEN: - case PostgreSqlParser.KW_UNLOGGED: - case PostgreSqlParser.KW_UNTIL: - case PostgreSqlParser.KW_UPDATE: - case PostgreSqlParser.KW_VACUUM: - case PostgreSqlParser.KW_VALID: - case PostgreSqlParser.KW_VALIDATE: - case PostgreSqlParser.KW_VALIDATOR: - case PostgreSqlParser.KW_VARYING: - case PostgreSqlParser.KW_VERSION: - case PostgreSqlParser.KW_VIEW: - case PostgreSqlParser.KW_VOLATILE: - case PostgreSqlParser.KW_WHITESPACE: - case PostgreSqlParser.KW_WITHOUT: - case PostgreSqlParser.KW_WORK: - case PostgreSqlParser.KW_WRAPPER: - case PostgreSqlParser.KW_WRITE: - case PostgreSqlParser.KW_XML: - case PostgreSqlParser.KW_YEAR: - case PostgreSqlParser.KW_YES: - case PostgreSqlParser.KW_ZONE: - case PostgreSqlParser.KW_BETWEEN: - case PostgreSqlParser.KW_BIGINT: - case PostgreSqlParser.KW_BIT: - case PostgreSqlParser.KW_BOOLEAN: - case PostgreSqlParser.KW_CHAR: - case PostgreSqlParser.KW_CHARACTER: - case PostgreSqlParser.KW_COALESCE: - case PostgreSqlParser.KW_DEC: - case PostgreSqlParser.KW_DECIMAL: - case PostgreSqlParser.KW_EXISTS: - case PostgreSqlParser.KW_EXTRACT: - case PostgreSqlParser.KW_FLOAT: - case PostgreSqlParser.KW_GREATEST: - case PostgreSqlParser.KW_INOUT: - case PostgreSqlParser.KW_INT: - case PostgreSqlParser.KW_INTEGER: - case PostgreSqlParser.KW_INTERVAL: - case PostgreSqlParser.KW_LEAST: - case PostgreSqlParser.KW_NATIONAL: - case PostgreSqlParser.KW_NCHAR: - case PostgreSqlParser.KW_NONE: - case PostgreSqlParser.KW_NULLIF: - case PostgreSqlParser.KW_NUMERIC: - case PostgreSqlParser.KW_OVERLAY: - case PostgreSqlParser.KW_POSITION: - case PostgreSqlParser.KW_PRECISION: - case PostgreSqlParser.KW_REAL: - case PostgreSqlParser.KW_ROW: - case PostgreSqlParser.KW_SETOF: - case PostgreSqlParser.KW_SMALLINT: - case PostgreSqlParser.KW_SUBSTRING: - case PostgreSqlParser.KW_TIME: - case PostgreSqlParser.KW_TIMESTAMP: - case PostgreSqlParser.KW_TREAT: - case PostgreSqlParser.KW_TRIM: - case PostgreSqlParser.KW_VALUES: - case PostgreSqlParser.KW_VARCHAR: - case PostgreSqlParser.KW_XMLATTRIBUTES: - case PostgreSqlParser.KW_XMLCONCAT: - case PostgreSqlParser.KW_XMLELEMENT: - case PostgreSqlParser.KW_XMLEXISTS: - case PostgreSqlParser.KW_XMLFOREST: - case PostgreSqlParser.KW_XMLPARSE: - case PostgreSqlParser.KW_XMLPI: - case PostgreSqlParser.KW_XMLROOT: - case PostgreSqlParser.KW_XMLSERIALIZE: - case PostgreSqlParser.KW_CALL: - case PostgreSqlParser.KW_CURRENT: - case PostgreSqlParser.KW_ATTACH: - case PostgreSqlParser.KW_DETACH: - case PostgreSqlParser.KW_EXPRESSION: - case PostgreSqlParser.KW_GENERATED: - case PostgreSqlParser.KW_LOGGED: - case PostgreSqlParser.KW_STORED: - case PostgreSqlParser.KW_INCLUDE: - case PostgreSqlParser.KW_ROUTINE: - case PostgreSqlParser.KW_TRANSFORM: - case PostgreSqlParser.KW_IMPORT: - case PostgreSqlParser.KW_POLICY: - case PostgreSqlParser.KW_METHOD: - case PostgreSqlParser.KW_REFERENCING: - case PostgreSqlParser.KW_NEW: - case PostgreSqlParser.KW_OLD: - case PostgreSqlParser.KW_VALUE: - case PostgreSqlParser.KW_SUBSCRIPTION: - case PostgreSqlParser.KW_PUBLICATION: - case PostgreSqlParser.KW_OUT: - case PostgreSqlParser.KW_ROUTINES: - case PostgreSqlParser.KW_SCHEMAS: - case PostgreSqlParser.KW_PROCEDURES: - case PostgreSqlParser.KW_INPUT: - case PostgreSqlParser.KW_SUPPORT: - case PostgreSqlParser.KW_PARALLEL: - case PostgreSqlParser.KW_SQL: - case PostgreSqlParser.KW_DEPENDS: - case PostgreSqlParser.KW_OVERRIDING: - case PostgreSqlParser.KW_CONFLICT: - case PostgreSqlParser.KW_SKIP: - case PostgreSqlParser.KW_LOCKED: - case PostgreSqlParser.KW_TIES: - case PostgreSqlParser.KW_ROLLUP: - case PostgreSqlParser.KW_CUBE: - case PostgreSqlParser.KW_GROUPING: - case PostgreSqlParser.KW_SETS: - case PostgreSqlParser.KW_ORDINALITY: - case PostgreSqlParser.KW_XMLTABLE: - case PostgreSqlParser.KW_COLUMNS: - case PostgreSqlParser.KW_XMLNAMESPACES: - case PostgreSqlParser.KW_ROWTYPE: - case PostgreSqlParser.KW_NORMALIZED: - case PostgreSqlParser.KW_WITHIN: - case PostgreSqlParser.KW_FILTER: - case PostgreSqlParser.KW_GROUPS: - case PostgreSqlParser.KW_OTHERS: - case PostgreSqlParser.KW_NFC: - case PostgreSqlParser.KW_NFD: - case PostgreSqlParser.KW_NFKC: - case PostgreSqlParser.KW_NFKD: - case PostgreSqlParser.KW_UESCAPE: - case PostgreSqlParser.KW_VIEWS: - case PostgreSqlParser.KW_NORMALIZE: - case PostgreSqlParser.KW_DUMP: - case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: - case PostgreSqlParser.KW_VARIABLE_CONFLICT: - case PostgreSqlParser.KW_ERROR: - case PostgreSqlParser.KW_USE_VARIABLE: - case PostgreSqlParser.KW_USE_COLUMN: - case PostgreSqlParser.KW_ALIAS: - case PostgreSqlParser.KW_CONSTANT: - case PostgreSqlParser.KW_PERFORM: - case PostgreSqlParser.KW_GET: - case PostgreSqlParser.KW_DIAGNOSTICS: - case PostgreSqlParser.KW_STACKED: - case PostgreSqlParser.KW_ELSIF: - case PostgreSqlParser.KW_REVERSE: - case PostgreSqlParser.KW_SLICE: - case PostgreSqlParser.KW_EXIT: - case PostgreSqlParser.KW_RETURN: - case PostgreSqlParser.KW_QUERY: - case PostgreSqlParser.KW_RAISE: - case PostgreSqlParser.KW_SQLSTATE: - case PostgreSqlParser.KW_DEBUG: - case PostgreSqlParser.KW_LOG: - case PostgreSqlParser.KW_INFO: - case PostgreSqlParser.KW_NOTICE: - case PostgreSqlParser.KW_WARNING: - case PostgreSqlParser.KW_EXCEPTION: - case PostgreSqlParser.KW_ASSERT: - case PostgreSqlParser.KW_OPEN: - case PostgreSqlParser.KW_SKIP_LOCKED: - case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: - case PostgreSqlParser.Identifier: - case PostgreSqlParser.QuotedIdentifier: - case PostgreSqlParser.UnicodeQuotedIdentifier: - case PostgreSqlParser.StringConstant: - case PostgreSqlParser.UnicodeEscapeStringConstant: - case PostgreSqlParser.BeginDollarStringConstant: - case PostgreSqlParser.PLSQLVARIABLENAME: - case PostgreSqlParser.PLSQLIDENTIFIER: - case PostgreSqlParser.EscapeStringConstant: - this.enterOuterAlt(localContext, 2); - { - this.state = 11784; - this.any_identifier(); - } - break; - default: - throw new antlr.NoViableAltException(this); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_exitcond(): Opt_exitcondContext { - let localContext = new Opt_exitcondContext(this.context, this.state); - this.enterRule(localContext, 1730, PostgreSqlParser.RULE_opt_exitcond); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11787; - this.match(PostgreSqlParser.KW_WHEN); - this.state = 11788; - this.expr_until_semi(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public any_identifier(): Any_identifierContext { - let localContext = new Any_identifierContext(this.context, this.state); - this.enterRule(localContext, 1732, PostgreSqlParser.RULE_any_identifier); - try { - this.state = 11792; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1273, this.context) ) { - case 1: - this.enterOuterAlt(localContext, 1); - { - this.state = 11790; - this.colid(); - } - break; - case 2: - this.enterOuterAlt(localContext, 2); - { - this.state = 11791; - this.plsql_unreserved_keyword(); - } - break; - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public plsql_unreserved_keyword(): Plsql_unreserved_keywordContext { - let localContext = new Plsql_unreserved_keywordContext(this.context, this.state); - this.enterRule(localContext, 1734, PostgreSqlParser.RULE_plsql_unreserved_keyword); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11794; - _la = this.tokenStream.LA(1); - if(!(((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 268451969) !== 0) || ((((_la - 153)) & ~0x1F) === 0 && ((1 << (_la - 153)) & 540945) !== 0) || _la === 207 || _la === 210 || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & 419430657) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & 268451841) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & 1051713) !== 0) || _la === 360 || _la === 433 || _la === 434 || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & 3959414785) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & 3071) !== 0))) { - this.errorHandler.recoverInline(this); - } - else { - this.errorHandler.reportMatch(this); - this.consume(); - } - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public sql_expression(): Sql_expressionContext { - let localContext = new Sql_expressionContext(this.context, this.state); - this.enterRule(localContext, 1736, PostgreSqlParser.RULE_sql_expression); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11797; - this.errorHandler.sync(this); - switch (this.interpreter.adaptivePredict(this.tokenStream, 1274, this.context) ) { - case 1: - { - this.state = 11796; - this.opt_target_list(); - } - break; - } - this.state = 11800; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 71) { - { - this.state = 11799; - this.into_clause(); - } - } - - this.state = 11803; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 64) { - { - this.state = 11802; - this.from_clause(); - } - } - - this.state = 11806; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 103) { - { - this.state = 11805; - this.where_clause(); - } - } - - this.state = 11809; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 66) { - { - this.state = 11808; - this.group_clause(); - } - } - - this.state = 11812; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 67) { - { - this.state = 11811; - this.having_clause(); - } - } - - this.state = 11815; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 104) { - { - this.state = 11814; - this.window_clause(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public expr_until_then(): Expr_until_thenContext { - let localContext = new Expr_until_thenContext(this.context, this.state); - this.enterRule(localContext, 1738, PostgreSqlParser.RULE_expr_until_then); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11817; - this.sql_expression(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public expr_until_semi(): Expr_until_semiContext { - let localContext = new Expr_until_semiContext(this.context, this.state); - this.enterRule(localContext, 1740, PostgreSqlParser.RULE_expr_until_semi); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11819; - this.sql_expression(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public expr_until_rightbracket(): Expr_until_rightbracketContext { - let localContext = new Expr_until_rightbracketContext(this.context, this.state); - this.enterRule(localContext, 1742, PostgreSqlParser.RULE_expr_until_rightbracket); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11821; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public expr_until_loop(): Expr_until_loopContext { - let localContext = new Expr_until_loopContext(this.context, this.state); - this.enterRule(localContext, 1744, PostgreSqlParser.RULE_expr_until_loop); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11823; - this.a_expr(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public make_execsql_stmt(): Make_execsql_stmtContext { - let localContext = new Make_execsql_stmtContext(this.context, this.state); - this.enterRule(localContext, 1746, PostgreSqlParser.RULE_make_execsql_stmt); - let _la: number; - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11825; - this.stmt(); - this.state = 11827; - this.errorHandler.sync(this); - _la = this.tokenStream.LA(1); - if (_la === 71) { - { - this.state = 11826; - this.opt_returning_clause_into(); - } - } - - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - public opt_returning_clause_into(): Opt_returning_clause_intoContext { - let localContext = new Opt_returning_clause_intoContext(this.context, this.state); - this.enterRule(localContext, 1748, PostgreSqlParser.RULE_opt_returning_clause_into); - try { - this.enterOuterAlt(localContext, 1); - { - this.state = 11829; - this.match(PostgreSqlParser.KW_INTO); - this.state = 11830; - this.opt_strict(); - this.state = 11831; - this.into_target(); - } - } - catch (re) { - if (re instanceof antlr.RecognitionException) { - localContext.exception = re; - this.errorHandler.reportError(this, re); - this.errorHandler.recover(this, re); - } else { - throw re; - } - } - finally { - this.exitRule(); - } - return localContext; - } - - public override sempred(localContext: antlr.RuleContext | null, ruleIndex: number, predIndex: number): boolean { - switch (ruleIndex) { - case 626: - return this.b_expr_sempred(localContext as B_exprContext, predIndex); - case 716: - return this.column_name_sempred(localContext as Column_nameContext, predIndex); - } - return true; - } - private b_expr_sempred(localContext: B_exprContext | null, predIndex: number): boolean { - switch (predIndex) { - case 0: - return this.precpred(this.context, 8); - case 1: - return this.precpred(this.context, 7); - case 2: - return this.precpred(this.context, 6); - case 3: - return this.precpred(this.context, 5); - case 4: - return this.precpred(this.context, 4); - case 5: - return this.precpred(this.context, 10); - case 6: - return this.precpred(this.context, 2); - case 7: - return this.precpred(this.context, 1); - } - return true; - } - private column_name_sempred(localContext: Column_nameContext | null, predIndex: number): boolean { - switch (predIndex) { - case 8: - return this.shouldMatchEmpty(); - } - return true; - } - - public static readonly _serializedATN: number[] = [ - 4,1,590,11834,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2, - 6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13, - 7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19, - 2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26, - 7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32, - 2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39, - 7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45, - 2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52, - 7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58, - 2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65, - 7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71, - 2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78, - 7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84, - 2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91, - 7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97, - 2,98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7, - 103,2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108, - 2,109,7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114, - 7,114,2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119, - 2,120,7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125, - 7,125,2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130, - 2,131,7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136, - 7,136,2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141, - 2,142,7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147, - 7,147,2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152, - 2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158, - 7,158,2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163, - 2,164,7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169, - 7,169,2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174, - 2,175,7,175,2,176,7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180, - 7,180,2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,2,185,7,185, - 2,186,7,186,2,187,7,187,2,188,7,188,2,189,7,189,2,190,7,190,2,191, - 7,191,2,192,7,192,2,193,7,193,2,194,7,194,2,195,7,195,2,196,7,196, - 2,197,7,197,2,198,7,198,2,199,7,199,2,200,7,200,2,201,7,201,2,202, - 7,202,2,203,7,203,2,204,7,204,2,205,7,205,2,206,7,206,2,207,7,207, - 2,208,7,208,2,209,7,209,2,210,7,210,2,211,7,211,2,212,7,212,2,213, - 7,213,2,214,7,214,2,215,7,215,2,216,7,216,2,217,7,217,2,218,7,218, - 2,219,7,219,2,220,7,220,2,221,7,221,2,222,7,222,2,223,7,223,2,224, - 7,224,2,225,7,225,2,226,7,226,2,227,7,227,2,228,7,228,2,229,7,229, - 2,230,7,230,2,231,7,231,2,232,7,232,2,233,7,233,2,234,7,234,2,235, - 7,235,2,236,7,236,2,237,7,237,2,238,7,238,2,239,7,239,2,240,7,240, - 2,241,7,241,2,242,7,242,2,243,7,243,2,244,7,244,2,245,7,245,2,246, - 7,246,2,247,7,247,2,248,7,248,2,249,7,249,2,250,7,250,2,251,7,251, - 2,252,7,252,2,253,7,253,2,254,7,254,2,255,7,255,2,256,7,256,2,257, - 7,257,2,258,7,258,2,259,7,259,2,260,7,260,2,261,7,261,2,262,7,262, - 2,263,7,263,2,264,7,264,2,265,7,265,2,266,7,266,2,267,7,267,2,268, - 7,268,2,269,7,269,2,270,7,270,2,271,7,271,2,272,7,272,2,273,7,273, - 2,274,7,274,2,275,7,275,2,276,7,276,2,277,7,277,2,278,7,278,2,279, - 7,279,2,280,7,280,2,281,7,281,2,282,7,282,2,283,7,283,2,284,7,284, - 2,285,7,285,2,286,7,286,2,287,7,287,2,288,7,288,2,289,7,289,2,290, - 7,290,2,291,7,291,2,292,7,292,2,293,7,293,2,294,7,294,2,295,7,295, - 2,296,7,296,2,297,7,297,2,298,7,298,2,299,7,299,2,300,7,300,2,301, - 7,301,2,302,7,302,2,303,7,303,2,304,7,304,2,305,7,305,2,306,7,306, - 2,307,7,307,2,308,7,308,2,309,7,309,2,310,7,310,2,311,7,311,2,312, - 7,312,2,313,7,313,2,314,7,314,2,315,7,315,2,316,7,316,2,317,7,317, - 2,318,7,318,2,319,7,319,2,320,7,320,2,321,7,321,2,322,7,322,2,323, - 7,323,2,324,7,324,2,325,7,325,2,326,7,326,2,327,7,327,2,328,7,328, - 2,329,7,329,2,330,7,330,2,331,7,331,2,332,7,332,2,333,7,333,2,334, - 7,334,2,335,7,335,2,336,7,336,2,337,7,337,2,338,7,338,2,339,7,339, - 2,340,7,340,2,341,7,341,2,342,7,342,2,343,7,343,2,344,7,344,2,345, - 7,345,2,346,7,346,2,347,7,347,2,348,7,348,2,349,7,349,2,350,7,350, - 2,351,7,351,2,352,7,352,2,353,7,353,2,354,7,354,2,355,7,355,2,356, - 7,356,2,357,7,357,2,358,7,358,2,359,7,359,2,360,7,360,2,361,7,361, - 2,362,7,362,2,363,7,363,2,364,7,364,2,365,7,365,2,366,7,366,2,367, - 7,367,2,368,7,368,2,369,7,369,2,370,7,370,2,371,7,371,2,372,7,372, - 2,373,7,373,2,374,7,374,2,375,7,375,2,376,7,376,2,377,7,377,2,378, - 7,378,2,379,7,379,2,380,7,380,2,381,7,381,2,382,7,382,2,383,7,383, - 2,384,7,384,2,385,7,385,2,386,7,386,2,387,7,387,2,388,7,388,2,389, - 7,389,2,390,7,390,2,391,7,391,2,392,7,392,2,393,7,393,2,394,7,394, - 2,395,7,395,2,396,7,396,2,397,7,397,2,398,7,398,2,399,7,399,2,400, - 7,400,2,401,7,401,2,402,7,402,2,403,7,403,2,404,7,404,2,405,7,405, - 2,406,7,406,2,407,7,407,2,408,7,408,2,409,7,409,2,410,7,410,2,411, - 7,411,2,412,7,412,2,413,7,413,2,414,7,414,2,415,7,415,2,416,7,416, - 2,417,7,417,2,418,7,418,2,419,7,419,2,420,7,420,2,421,7,421,2,422, - 7,422,2,423,7,423,2,424,7,424,2,425,7,425,2,426,7,426,2,427,7,427, - 2,428,7,428,2,429,7,429,2,430,7,430,2,431,7,431,2,432,7,432,2,433, - 7,433,2,434,7,434,2,435,7,435,2,436,7,436,2,437,7,437,2,438,7,438, - 2,439,7,439,2,440,7,440,2,441,7,441,2,442,7,442,2,443,7,443,2,444, - 7,444,2,445,7,445,2,446,7,446,2,447,7,447,2,448,7,448,2,449,7,449, - 2,450,7,450,2,451,7,451,2,452,7,452,2,453,7,453,2,454,7,454,2,455, - 7,455,2,456,7,456,2,457,7,457,2,458,7,458,2,459,7,459,2,460,7,460, - 2,461,7,461,2,462,7,462,2,463,7,463,2,464,7,464,2,465,7,465,2,466, - 7,466,2,467,7,467,2,468,7,468,2,469,7,469,2,470,7,470,2,471,7,471, - 2,472,7,472,2,473,7,473,2,474,7,474,2,475,7,475,2,476,7,476,2,477, - 7,477,2,478,7,478,2,479,7,479,2,480,7,480,2,481,7,481,2,482,7,482, - 2,483,7,483,2,484,7,484,2,485,7,485,2,486,7,486,2,487,7,487,2,488, - 7,488,2,489,7,489,2,490,7,490,2,491,7,491,2,492,7,492,2,493,7,493, - 2,494,7,494,2,495,7,495,2,496,7,496,2,497,7,497,2,498,7,498,2,499, - 7,499,2,500,7,500,2,501,7,501,2,502,7,502,2,503,7,503,2,504,7,504, - 2,505,7,505,2,506,7,506,2,507,7,507,2,508,7,508,2,509,7,509,2,510, - 7,510,2,511,7,511,2,512,7,512,2,513,7,513,2,514,7,514,2,515,7,515, - 2,516,7,516,2,517,7,517,2,518,7,518,2,519,7,519,2,520,7,520,2,521, - 7,521,2,522,7,522,2,523,7,523,2,524,7,524,2,525,7,525,2,526,7,526, - 2,527,7,527,2,528,7,528,2,529,7,529,2,530,7,530,2,531,7,531,2,532, - 7,532,2,533,7,533,2,534,7,534,2,535,7,535,2,536,7,536,2,537,7,537, - 2,538,7,538,2,539,7,539,2,540,7,540,2,541,7,541,2,542,7,542,2,543, - 7,543,2,544,7,544,2,545,7,545,2,546,7,546,2,547,7,547,2,548,7,548, - 2,549,7,549,2,550,7,550,2,551,7,551,2,552,7,552,2,553,7,553,2,554, - 7,554,2,555,7,555,2,556,7,556,2,557,7,557,2,558,7,558,2,559,7,559, - 2,560,7,560,2,561,7,561,2,562,7,562,2,563,7,563,2,564,7,564,2,565, - 7,565,2,566,7,566,2,567,7,567,2,568,7,568,2,569,7,569,2,570,7,570, - 2,571,7,571,2,572,7,572,2,573,7,573,2,574,7,574,2,575,7,575,2,576, - 7,576,2,577,7,577,2,578,7,578,2,579,7,579,2,580,7,580,2,581,7,581, - 2,582,7,582,2,583,7,583,2,584,7,584,2,585,7,585,2,586,7,586,2,587, - 7,587,2,588,7,588,2,589,7,589,2,590,7,590,2,591,7,591,2,592,7,592, - 2,593,7,593,2,594,7,594,2,595,7,595,2,596,7,596,2,597,7,597,2,598, - 7,598,2,599,7,599,2,600,7,600,2,601,7,601,2,602,7,602,2,603,7,603, - 2,604,7,604,2,605,7,605,2,606,7,606,2,607,7,607,2,608,7,608,2,609, - 7,609,2,610,7,610,2,611,7,611,2,612,7,612,2,613,7,613,2,614,7,614, - 2,615,7,615,2,616,7,616,2,617,7,617,2,618,7,618,2,619,7,619,2,620, - 7,620,2,621,7,621,2,622,7,622,2,623,7,623,2,624,7,624,2,625,7,625, - 2,626,7,626,2,627,7,627,2,628,7,628,2,629,7,629,2,630,7,630,2,631, - 7,631,2,632,7,632,2,633,7,633,2,634,7,634,2,635,7,635,2,636,7,636, - 2,637,7,637,2,638,7,638,2,639,7,639,2,640,7,640,2,641,7,641,2,642, - 7,642,2,643,7,643,2,644,7,644,2,645,7,645,2,646,7,646,2,647,7,647, - 2,648,7,648,2,649,7,649,2,650,7,650,2,651,7,651,2,652,7,652,2,653, - 7,653,2,654,7,654,2,655,7,655,2,656,7,656,2,657,7,657,2,658,7,658, - 2,659,7,659,2,660,7,660,2,661,7,661,2,662,7,662,2,663,7,663,2,664, - 7,664,2,665,7,665,2,666,7,666,2,667,7,667,2,668,7,668,2,669,7,669, - 2,670,7,670,2,671,7,671,2,672,7,672,2,673,7,673,2,674,7,674,2,675, - 7,675,2,676,7,676,2,677,7,677,2,678,7,678,2,679,7,679,2,680,7,680, - 2,681,7,681,2,682,7,682,2,683,7,683,2,684,7,684,2,685,7,685,2,686, - 7,686,2,687,7,687,2,688,7,688,2,689,7,689,2,690,7,690,2,691,7,691, - 2,692,7,692,2,693,7,693,2,694,7,694,2,695,7,695,2,696,7,696,2,697, - 7,697,2,698,7,698,2,699,7,699,2,700,7,700,2,701,7,701,2,702,7,702, - 2,703,7,703,2,704,7,704,2,705,7,705,2,706,7,706,2,707,7,707,2,708, - 7,708,2,709,7,709,2,710,7,710,2,711,7,711,2,712,7,712,2,713,7,713, - 2,714,7,714,2,715,7,715,2,716,7,716,2,717,7,717,2,718,7,718,2,719, - 7,719,2,720,7,720,2,721,7,721,2,722,7,722,2,723,7,723,2,724,7,724, - 2,725,7,725,2,726,7,726,2,727,7,727,2,728,7,728,2,729,7,729,2,730, - 7,730,2,731,7,731,2,732,7,732,2,733,7,733,2,734,7,734,2,735,7,735, - 2,736,7,736,2,737,7,737,2,738,7,738,2,739,7,739,2,740,7,740,2,741, - 7,741,2,742,7,742,2,743,7,743,2,744,7,744,2,745,7,745,2,746,7,746, - 2,747,7,747,2,748,7,748,2,749,7,749,2,750,7,750,2,751,7,751,2,752, - 7,752,2,753,7,753,2,754,7,754,2,755,7,755,2,756,7,756,2,757,7,757, - 2,758,7,758,2,759,7,759,2,760,7,760,2,761,7,761,2,762,7,762,2,763, - 7,763,2,764,7,764,2,765,7,765,2,766,7,766,2,767,7,767,2,768,7,768, - 2,769,7,769,2,770,7,770,2,771,7,771,2,772,7,772,2,773,7,773,2,774, - 7,774,2,775,7,775,2,776,7,776,2,777,7,777,2,778,7,778,2,779,7,779, - 2,780,7,780,2,781,7,781,2,782,7,782,2,783,7,783,2,784,7,784,2,785, - 7,785,2,786,7,786,2,787,7,787,2,788,7,788,2,789,7,789,2,790,7,790, - 2,791,7,791,2,792,7,792,2,793,7,793,2,794,7,794,2,795,7,795,2,796, - 7,796,2,797,7,797,2,798,7,798,2,799,7,799,2,800,7,800,2,801,7,801, - 2,802,7,802,2,803,7,803,2,804,7,804,2,805,7,805,2,806,7,806,2,807, - 7,807,2,808,7,808,2,809,7,809,2,810,7,810,2,811,7,811,2,812,7,812, - 2,813,7,813,2,814,7,814,2,815,7,815,2,816,7,816,2,817,7,817,2,818, - 7,818,2,819,7,819,2,820,7,820,2,821,7,821,2,822,7,822,2,823,7,823, - 2,824,7,824,2,825,7,825,2,826,7,826,2,827,7,827,2,828,7,828,2,829, - 7,829,2,830,7,830,2,831,7,831,2,832,7,832,2,833,7,833,2,834,7,834, - 2,835,7,835,2,836,7,836,2,837,7,837,2,838,7,838,2,839,7,839,2,840, - 7,840,2,841,7,841,2,842,7,842,2,843,7,843,2,844,7,844,2,845,7,845, - 2,846,7,846,2,847,7,847,2,848,7,848,2,849,7,849,2,850,7,850,2,851, - 7,851,2,852,7,852,2,853,7,853,2,854,7,854,2,855,7,855,2,856,7,856, - 2,857,7,857,2,858,7,858,2,859,7,859,2,860,7,860,2,861,7,861,2,862, - 7,862,2,863,7,863,2,864,7,864,2,865,7,865,2,866,7,866,2,867,7,867, - 2,868,7,868,2,869,7,869,2,870,7,870,2,871,7,871,2,872,7,872,2,873, - 7,873,2,874,7,874,1,0,5,0,1752,8,0,10,0,12,0,1755,9,0,1,0,1,0,1, - 1,1,1,1,2,1,2,3,2,1763,8,2,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1, - 3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1, - 3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1, - 3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1, - 3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1, - 3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1, - 3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1, - 3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,1882,8,3,1,4,1, - 4,3,4,1886,8,4,1,5,1,5,1,5,1,6,1,6,1,6,1,6,3,6,1895,8,6,1,6,1,6, - 1,7,1,7,1,8,5,8,1902,8,8,10,8,12,8,1905,9,8,1,9,5,9,1908,8,9,10, - 9,12,9,1911,9,9,1,10,1,10,1,10,3,10,1916,8,10,1,10,1,10,1,10,1,10, - 1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10, - 1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10, - 3,10,1948,8,10,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11, - 3,11,1960,8,11,1,12,1,12,1,12,1,12,3,12,1966,8,12,1,12,1,12,1,13, - 1,13,1,13,1,13,3,13,1974,8,13,1,13,1,13,1,14,1,14,1,14,1,14,3,14, - 1982,8,14,1,15,1,15,1,15,1,15,3,15,1988,8,15,1,15,1,15,1,15,1,16, - 1,16,1,16,1,16,3,16,1997,8,16,1,16,1,16,1,17,1,17,3,17,2003,8,17, - 1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,3,17,2015,8,17, - 1,17,1,17,1,17,1,17,3,17,2021,8,17,1,18,1,18,5,18,2025,8,18,10,18, - 12,18,2028,9,18,1,19,1,19,1,19,1,19,3,19,2034,8,19,1,19,1,19,3,19, - 2038,8,19,1,19,1,19,1,19,3,19,2043,8,19,1,19,1,19,3,19,2047,8,19, - 1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,2060, - 8,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,2071,8,19, - 1,20,1,20,1,20,1,20,3,20,2077,8,20,1,20,1,20,1,21,1,21,1,21,1,21, - 1,21,1,21,1,21,1,22,1,22,1,23,1,23,1,23,3,23,2093,8,23,1,23,3,23, - 2096,8,23,1,23,1,23,1,23,3,23,2101,8,23,1,23,1,23,1,24,1,24,3,24, - 2107,8,24,1,25,5,25,2110,8,25,10,25,12,25,2113,9,25,1,26,1,26,1, - 26,1,26,1,26,1,26,3,26,2121,8,26,1,27,1,27,3,27,2125,8,27,1,27,1, - 27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,3,28,2137,8,28,1,29,1, - 29,3,29,2141,8,29,1,29,3,29,2144,8,29,1,29,1,29,3,29,2148,8,29,1, - 30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,3,30,2159,8,30,1,30,1, - 30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1, - 30,1,30,3,30,2177,8,30,1,31,1,31,1,31,5,31,2182,8,31,10,31,12,31, - 2185,9,31,1,32,1,32,1,32,5,32,2190,8,32,10,32,12,32,2193,9,32,1, - 33,1,33,3,33,2197,8,33,1,34,1,34,1,34,1,34,1,34,3,34,2204,8,34,1, - 35,1,35,1,35,1,35,3,35,2210,8,35,1,36,1,36,1,36,1,36,3,36,2216,8, - 36,1,37,1,37,1,37,1,37,1,37,3,37,2223,8,37,1,37,1,37,1,37,1,37,1, - 37,1,37,1,37,1,37,1,37,3,37,2234,8,37,1,38,1,38,3,38,2238,8,38,1, - 39,1,39,3,39,2242,8,39,1,40,1,40,3,40,2246,8,40,1,41,1,41,1,41,1, - 42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,3,42,2259,8,42,1,43,1,43,3, - 43,2263,8,43,1,44,1,44,1,44,3,44,2268,8,44,1,45,1,45,1,45,3,45,2273, - 8,45,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,3,46,2285, - 8,46,1,47,1,47,1,47,1,47,1,47,1,48,1,48,3,48,2294,8,48,1,49,1,49, - 1,50,1,50,1,51,1,51,1,51,1,52,1,52,1,52,3,52,2306,8,52,1,52,1,52, - 1,52,3,52,2311,8,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, - 3,52,2322,8,52,1,52,1,52,1,52,1,52,3,52,2328,8,52,1,52,1,52,1,52, - 3,52,2333,8,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,2343, - 8,52,1,52,1,52,1,52,3,52,2348,8,52,1,52,1,52,1,52,1,52,1,52,3,52, - 2355,8,52,1,52,1,52,1,52,3,52,2360,8,52,1,52,1,52,1,52,3,52,2365, - 8,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,2376,8,52, - 1,52,1,52,1,52,1,52,3,52,2382,8,52,1,52,1,52,1,52,3,52,2387,8,52, - 1,52,1,52,1,52,1,52,1,52,1,52,3,52,2395,8,52,1,52,1,52,1,52,1,52, - 1,52,1,52,1,52,3,52,2404,8,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, - 1,52,1,52,1,52,1,52,1,52,1,52,3,52,2419,8,52,1,52,1,52,1,52,1,52, - 3,52,2425,8,52,1,52,1,52,1,52,1,52,3,52,2431,8,52,1,52,1,52,1,52, - 3,52,2436,8,52,1,53,1,53,1,53,5,53,2441,8,53,10,53,12,53,2444,9, - 53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,3,54,2455,8,54,1, - 55,1,55,1,55,1,55,5,55,2461,8,55,10,55,12,55,2464,9,55,1,55,1,55, - 1,56,1,56,1,56,3,56,2471,8,56,1,57,1,57,1,57,1,57,1,57,1,57,1,57, - 1,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,3,58,2489,8,58,1,59, - 1,59,1,59,1,59,1,60,1,60,1,60,3,60,2498,8,60,1,60,1,60,1,60,1,60, - 1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60,2512,8,60,1,60,1,60, - 3,60,2516,8,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60, - 1,60,1,60,1,60,3,60,2531,8,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60, - 2539,8,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60,2549,8,60, - 1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60, - 1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60, - 1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60, - 2589,8,60,1,60,3,60,2592,8,60,1,60,1,60,3,60,2596,8,60,1,60,1,60, - 3,60,2600,8,60,1,60,3,60,2603,8,60,1,60,1,60,1,60,3,60,2608,8,60, - 1,60,1,60,1,60,1,60,1,60,3,60,2615,8,60,1,60,1,60,1,60,1,60,1,60, - 1,60,1,60,3,60,2624,8,60,1,60,1,60,1,60,1,60,3,60,2630,8,60,1,60, - 1,60,3,60,2634,8,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60,2643, - 8,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60,2651,8,60,1,60,1,60,1,60, - 1,60,1,60,1,60,1,60,3,60,2660,8,60,1,60,1,60,1,60,1,60,1,60,1,60, - 1,60,3,60,2669,8,60,1,60,1,60,3,60,2673,8,60,1,60,1,60,1,60,1,60, - 1,60,3,60,2680,8,60,1,60,1,60,1,60,1,60,3,60,2686,8,60,1,60,1,60, - 3,60,2690,8,60,1,60,1,60,3,60,2694,8,60,1,60,1,60,1,60,3,60,2699, - 8,60,1,60,3,60,2702,8,60,1,60,1,60,3,60,2706,8,60,1,60,1,60,1,60, - 1,60,3,60,2712,8,60,1,61,1,61,1,61,1,61,1,61,3,61,2719,8,61,1,62, - 1,62,1,63,1,63,1,63,1,64,1,64,1,64,1,65,1,65,1,65,1,65,1,65,1,65, - 3,65,2735,8,65,1,66,1,66,1,66,1,66,1,67,1,67,1,67,1,68,1,68,1,68, - 5,68,2747,8,68,10,68,12,68,2750,9,68,1,69,1,69,1,69,1,69,1,69,1, - 69,1,69,3,69,2759,8,69,3,69,2761,8,69,1,70,4,70,2764,8,70,11,70, - 12,70,2765,1,71,1,71,3,71,2770,8,71,1,71,3,71,2773,8,71,1,71,1,71, - 1,71,1,71,3,71,2779,8,71,3,71,2781,8,71,1,72,1,72,1,72,1,72,1,72, - 1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72, - 1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,3,72,2809,8,72,1,73,1,73, - 1,73,1,74,1,74,1,74,5,74,2817,8,74,10,74,12,74,2820,9,74,1,75,1, - 75,1,75,1,75,1,75,1,76,1,76,1,76,5,76,2830,8,76,10,76,12,76,2833, - 9,76,1,77,1,77,1,77,1,77,3,77,2839,8,77,1,77,1,77,1,77,3,77,2844, - 8,77,1,77,1,77,3,77,2848,8,77,1,77,1,77,1,77,1,77,3,77,2854,8,77, - 1,77,1,77,1,77,3,77,2859,8,77,1,77,3,77,2862,8,77,3,77,2864,8,77, - 1,78,1,78,1,78,3,78,2869,8,78,1,79,1,79,3,79,2873,8,79,1,79,1,79, - 3,79,2877,8,79,1,79,1,79,3,79,2881,8,79,1,79,1,79,3,79,2885,8,79, - 1,79,3,79,2888,8,79,1,79,1,79,3,79,2892,8,79,1,79,1,79,1,79,1,79, - 1,79,1,79,3,79,2900,8,79,1,79,1,79,3,79,2904,8,79,1,79,1,79,3,79, - 2908,8,79,1,80,1,80,1,81,1,81,1,82,1,82,1,82,3,82,2917,8,82,1,83, - 1,83,1,83,1,83,1,83,3,83,2924,8,83,1,84,5,84,2927,8,84,10,84,12, - 84,2930,9,84,1,85,1,85,1,85,1,85,3,85,2936,8,85,1,85,1,85,1,85,3, - 85,2941,8,85,1,85,1,85,1,85,1,85,1,85,3,85,2948,8,85,1,85,1,85,1, - 85,3,85,2953,8,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1, - 85,1,85,1,85,1,85,1,85,1,85,1,85,3,85,2971,8,85,1,86,1,86,1,87,3, - 87,2976,8,87,1,87,1,87,1,87,1,88,1,88,1,89,1,89,1,89,5,89,2986,8, - 89,10,89,12,89,2989,9,89,1,90,1,90,3,90,2993,8,90,1,91,1,91,1,91, - 1,91,1,91,1,91,1,91,3,91,3002,8,91,1,92,1,92,1,92,5,92,3007,8,92, - 10,92,12,92,3010,9,92,1,93,1,93,1,94,1,94,3,94,3016,8,94,1,94,1, - 94,3,94,3020,8,94,1,94,1,94,1,94,3,94,3025,8,94,1,94,1,94,3,94,3029, - 8,94,1,94,3,94,3032,8,94,1,94,3,94,3035,8,94,1,94,3,94,3038,8,94, - 1,94,3,94,3041,8,94,1,94,3,94,3044,8,94,1,94,1,94,1,94,3,94,3049, - 8,94,1,94,3,94,3052,8,94,1,94,3,94,3055,8,94,1,94,3,94,3058,8,94, - 1,94,3,94,3061,8,94,1,94,3,94,3064,8,94,1,94,1,94,1,94,1,94,3,94, - 3070,8,94,1,94,1,94,3,94,3074,8,94,1,94,3,94,3077,8,94,1,94,3,94, - 3080,8,94,1,94,3,94,3083,8,94,1,94,3,94,3086,8,94,3,94,3088,8,94, - 1,95,1,95,1,95,1,95,1,95,1,95,1,95,3,95,3097,8,95,1,96,1,96,1,97, - 1,97,1,98,1,98,1,98,1,98,1,99,1,99,1,99,5,99,3110,8,99,10,99,12, - 99,3113,9,99,1,100,1,100,1,100,5,100,3118,8,100,10,100,12,100,3121, - 9,100,1,101,1,101,1,101,3,101,3126,8,101,1,102,1,102,3,102,3130, - 8,102,1,103,1,103,1,103,3,103,3135,8,103,1,103,3,103,3138,8,103, - 1,103,3,103,3141,8,103,1,103,1,103,3,103,3145,8,103,1,103,1,103, - 3,103,3149,8,103,1,103,1,103,1,104,1,104,1,104,1,105,1,105,1,105, - 1,105,1,105,1,105,1,105,3,105,3163,8,105,1,106,1,106,1,106,3,106, - 3168,8,106,1,106,1,106,1,107,5,107,3173,8,107,10,107,12,107,3176, - 9,107,1,108,1,108,3,108,3180,8,108,1,108,1,108,3,108,3184,8,108, - 1,108,3,108,3187,8,108,1,108,1,108,3,108,3191,8,108,1,108,3,108, - 3194,8,108,3,108,3196,8,108,1,109,1,109,1,109,1,109,1,109,3,109, - 3203,8,109,1,109,3,109,3206,8,109,1,109,1,109,3,109,3210,8,109,1, - 109,1,109,1,109,1,109,3,109,3216,8,109,1,109,3,109,3219,8,109,1, - 109,1,109,1,109,1,109,1,109,3,109,3226,8,109,1,109,1,109,1,109,1, - 109,1,109,1,109,1,109,3,109,3235,8,109,1,109,1,109,1,109,1,109,1, - 109,3,109,3242,8,109,1,109,1,109,1,109,3,109,3247,8,109,1,109,3, - 109,3250,8,109,1,109,3,109,3253,8,109,1,109,3,109,3256,8,109,1,110, - 1,110,3,110,3260,8,110,1,110,1,110,1,111,1,111,1,111,3,111,3267, - 8,111,1,112,1,112,1,112,3,112,3272,8,112,1,113,1,113,1,113,1,114, - 1,114,1,114,1,114,1,115,1,115,5,115,3283,8,115,10,115,12,115,3286, - 9,115,1,116,1,116,1,117,1,117,1,117,1,117,1,117,3,117,3295,8,117, - 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 3,118,3308,8,118,1,118,3,118,3311,8,118,1,118,3,118,3314,8,118,1, - 118,1,118,1,118,1,118,1,118,3,118,3321,8,118,1,118,1,118,1,118,1, - 118,1,118,1,118,3,118,3329,8,118,1,118,3,118,3332,8,118,1,118,3, - 118,3335,8,118,1,118,1,118,1,118,1,118,1,118,3,118,3342,8,118,1, - 118,1,118,3,118,3346,8,118,1,118,1,118,1,118,1,118,3,118,3352,8, - 118,1,118,3,118,3355,8,118,1,118,3,118,3358,8,118,1,118,3,118,3361, - 8,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, - 3,118,3373,8,118,1,118,3,118,3376,8,118,1,118,3,118,3379,8,118,1, - 118,1,118,3,118,3383,8,118,1,119,1,119,1,119,1,120,1,120,1,120,1, - 120,1,121,1,121,1,121,1,121,1,122,1,122,1,122,5,122,3399,8,122,10, - 122,12,122,3402,9,122,1,123,1,123,1,123,5,123,3407,8,123,10,123, - 12,123,3410,9,123,1,124,1,124,1,124,1,124,1,124,1,125,1,125,1,125, - 1,126,1,126,1,126,5,126,3423,8,126,10,126,12,126,3426,9,126,1,127, - 1,127,1,127,1,127,1,127,1,127,1,127,1,127,3,127,3436,8,127,1,128, - 1,128,1,128,1,128,1,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129, - 1,129,3,129,3451,8,129,1,130,1,130,1,130,1,130,1,131,1,131,1,131, - 1,131,1,132,1,132,1,132,1,132,1,132,1,132,1,132,3,132,3468,8,132, - 3,132,3470,8,132,1,133,1,133,1,133,1,133,1,133,1,134,1,134,1,135, - 1,135,1,135,1,135,1,135,1,135,1,135,1,136,1,136,1,136,5,136,3489, - 8,136,10,136,12,136,3492,9,136,1,137,1,137,3,137,3496,8,137,1,137, - 3,137,3499,8,137,1,137,1,137,3,137,3503,8,137,1,137,3,137,3506,8, - 137,1,137,1,137,1,137,1,137,3,137,3512,8,137,1,137,3,137,3515,8, - 137,3,137,3517,8,137,1,138,1,138,1,138,1,139,1,139,1,139,1,139,1, - 139,1,139,3,139,3528,8,139,1,140,1,140,1,140,1,140,1,140,1,140,1, - 140,3,140,3537,8,140,1,141,1,141,1,141,1,142,3,142,3543,8,142,1, - 142,3,142,3546,8,142,1,142,3,142,3549,8,142,1,143,1,143,1,143,1, - 143,1,143,1,144,1,144,1,144,1,144,1,145,1,145,1,145,3,145,3563,8, - 145,1,145,3,145,3566,8,145,1,145,3,145,3569,8,145,1,145,1,145,1, - 145,3,145,3574,8,145,1,145,1,145,1,145,1,146,1,146,1,146,3,146,3582, - 8,146,1,146,1,146,1,146,1,146,1,146,1,147,1,147,3,147,3591,8,147, - 1,147,1,147,3,147,3595,8,147,1,147,1,147,1,147,1,147,3,147,3601, - 8,147,1,148,1,148,3,148,3605,8,148,1,148,3,148,3608,8,148,1,148, - 3,148,3611,8,148,1,148,3,148,3614,8,148,1,148,3,148,3617,8,148,1, - 149,1,149,1,149,1,149,3,149,3623,8,149,1,150,1,150,3,150,3627,8, - 150,1,150,1,150,1,150,3,150,3632,8,150,1,150,1,150,1,150,1,150,3, - 150,3638,8,150,1,151,1,151,3,151,3642,8,151,1,151,3,151,3645,8,151, - 1,151,3,151,3648,8,151,1,151,3,151,3651,8,151,1,152,1,152,1,153, - 1,153,1,153,1,153,3,153,3659,8,153,1,153,1,153,3,153,3663,8,153, - 1,154,1,154,3,154,3667,8,154,1,154,1,154,3,154,3671,8,154,1,154, - 1,154,3,154,3675,8,154,1,155,1,155,1,155,3,155,3680,8,155,1,155, - 1,155,1,155,1,156,1,156,1,157,1,157,1,157,1,157,1,158,4,158,3692, - 8,158,11,158,12,158,3693,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 3,159,3703,8,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159, - 1,159,1,159,1,159,1,159,1,159,1,159,1,159,3,159,3720,8,159,1,159, - 1,159,1,159,3,159,3725,8,159,1,159,3,159,3728,8,159,3,159,3730,8, - 159,1,160,1,160,1,161,1,161,1,161,1,161,1,161,1,161,3,161,3740,8, - 161,1,162,1,162,1,162,5,162,3745,8,162,10,162,12,162,3748,9,162, - 1,163,1,163,3,163,3752,8,163,1,163,3,163,3755,8,163,1,163,3,163, - 3758,8,163,1,163,1,163,1,163,1,163,1,163,3,163,3765,8,163,1,163, - 3,163,3768,8,163,3,163,3770,8,163,1,164,1,164,1,165,1,165,3,165, - 3776,8,165,1,166,1,166,1,166,1,167,1,167,1,167,1,167,3,167,3785, - 8,167,1,168,1,168,1,169,1,169,1,170,1,170,1,170,1,170,3,170,3795, - 8,170,1,170,1,170,1,170,3,170,3800,8,170,1,171,1,171,1,171,1,172, - 1,172,1,172,3,172,3808,8,172,1,172,1,172,3,172,3812,8,172,1,172, - 1,172,1,173,5,173,3817,8,173,10,173,12,173,3820,9,173,1,174,1,174, - 1,174,1,174,1,174,1,174,1,174,3,174,3829,8,174,1,175,1,175,1,175, - 1,175,1,175,1,175,1,176,5,176,3838,8,176,10,176,12,176,3841,9,176, - 1,177,1,177,1,177,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, - 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, - 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, - 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, - 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, - 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, - 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, - 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, - 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178, - 1,178,1,178,1,178,1,178,1,178,1,178,3,178,3948,8,178,1,179,1,179, - 1,179,1,179,1,179,1,179,3,179,3956,8,179,1,179,3,179,3959,8,179, - 1,180,1,180,1,180,1,180,1,180,1,180,1,180,1,180,3,180,3969,8,180, - 1,181,4,181,3972,8,181,11,181,12,181,3973,1,182,1,182,1,183,1,183, - 1,183,1,183,1,183,1,183,3,183,3984,8,183,1,183,1,183,1,183,1,183, - 1,183,1,183,1,183,1,183,1,183,3,183,3995,8,183,1,184,1,184,1,184, - 1,184,1,184,1,185,1,185,1,185,5,185,4005,8,185,10,185,12,185,4008, - 9,185,1,186,1,186,1,186,1,186,1,186,1,187,1,187,1,187,5,187,4018, - 8,187,10,187,12,187,4021,9,187,1,188,1,188,1,188,1,188,1,188,1,188, - 1,188,3,188,4030,8,188,1,189,1,189,1,189,1,190,1,190,1,191,1,191, - 1,192,1,192,1,192,3,192,4042,8,192,1,192,1,192,3,192,4046,8,192, - 1,192,3,192,4049,8,192,1,192,1,192,1,192,1,192,1,192,3,192,4056, - 8,192,1,193,1,193,1,193,1,194,1,194,1,194,3,194,4064,8,194,1,195, - 1,195,1,196,1,196,1,196,1,196,1,196,1,196,3,196,4074,8,196,3,196, - 4076,8,196,1,197,1,197,1,197,1,197,3,197,4082,8,197,1,197,1,197, - 1,197,3,197,4087,8,197,1,197,1,197,3,197,4091,8,197,1,197,1,197, - 1,197,3,197,4096,8,197,1,197,1,197,1,197,1,197,3,197,4102,8,197, - 1,197,1,197,1,197,1,197,1,197,3,197,4109,8,197,1,197,1,197,1,197, - 1,197,3,197,4115,8,197,3,197,4117,8,197,1,198,1,198,1,198,1,198, - 1,198,3,198,4124,8,198,1,198,1,198,1,198,1,198,1,198,1,198,3,198, - 4132,8,198,1,199,1,199,1,199,3,199,4137,8,199,1,200,1,200,1,200, - 1,200,1,200,1,201,1,201,1,201,1,201,3,201,4148,8,201,1,201,1,201, - 1,201,1,201,1,201,3,201,4155,8,201,1,202,1,202,3,202,4159,8,202, - 1,203,1,203,1,203,1,203,1,203,1,203,1,203,1,203,1,203,1,204,1,204, - 1,204,1,204,1,204,1,204,3,204,4176,8,204,1,204,3,204,4179,8,204, - 1,204,3,204,4182,8,204,1,204,3,204,4185,8,204,1,204,3,204,4188,8, - 204,1,205,1,205,1,205,1,205,1,205,1,205,3,205,4196,8,205,1,205,3, - 205,4199,8,205,1,205,3,205,4202,8,205,1,206,1,206,1,206,1,206,3, - 206,4208,8,206,1,206,1,206,1,207,1,207,5,207,4214,8,207,10,207,12, - 207,4217,9,207,1,207,3,207,4220,8,207,1,207,1,207,1,207,1,207,1, - 207,1,207,1,207,1,207,1,207,1,207,3,207,4232,8,207,1,207,1,207,1, - 207,1,207,3,207,4238,8,207,1,208,3,208,4241,8,208,1,208,1,208,1, - 208,3,208,4246,8,208,1,208,1,208,3,208,4250,8,208,1,208,1,208,1, - 208,1,208,1,208,3,208,4257,8,208,1,208,1,208,1,208,1,208,1,208,1, - 208,1,208,1,208,1,208,3,208,4268,8,208,1,209,1,209,1,209,1,209,1, - 209,1,210,1,210,1,210,1,210,1,210,1,210,1,211,1,211,1,211,1,212, - 1,212,1,212,1,213,1,213,1,213,1,213,3,213,4291,8,213,1,214,1,214, - 1,214,1,215,1,215,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216, - 1,216,1,217,1,217,1,218,1,218,3,218,4311,8,218,1,218,1,218,1,218, - 1,218,1,218,1,218,1,218,3,218,4320,8,218,1,218,3,218,4323,8,218, - 1,218,3,218,4326,8,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218, - 1,218,3,218,4336,8,218,1,218,3,218,4339,8,218,1,218,1,218,1,218, - 1,218,1,218,1,218,1,218,3,218,4348,8,218,1,218,1,218,3,218,4352, - 8,218,1,218,3,218,4355,8,218,1,218,1,218,1,218,1,218,1,218,1,218, - 3,218,4363,8,218,1,219,1,219,1,219,1,219,3,219,4369,8,219,1,220, - 1,220,3,220,4373,8,220,1,220,1,220,1,221,1,221,1,222,1,222,1,222, - 5,222,4382,8,222,10,222,12,222,4385,9,222,1,223,1,223,1,223,1,223, - 1,223,1,223,1,223,3,223,4394,8,223,1,224,1,224,1,224,1,225,4,225, - 4400,8,225,11,225,12,225,4401,1,226,1,226,1,226,3,226,4407,8,226, - 1,226,1,226,1,227,1,227,1,228,1,228,1,229,1,229,1,230,1,230,3,230, - 4419,8,230,1,230,1,230,1,231,1,231,1,232,1,232,1,233,1,233,1,233, - 1,233,1,233,1,234,1,234,1,234,1,234,3,234,4436,8,234,1,235,1,235, - 3,235,4440,8,235,1,235,1,235,5,235,4444,8,235,10,235,12,235,4447, - 9,235,1,236,1,236,1,236,1,236,3,236,4453,8,236,1,237,1,237,1,237, - 1,238,5,238,4459,8,238,10,238,12,238,4462,9,238,1,239,1,239,1,239, - 1,239,1,239,1,239,1,239,1,239,1,239,1,239,1,239,3,239,4475,8,239, - 1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240, - 1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240, - 1,240,1,240,3,240,4501,8,240,1,241,1,241,1,241,5,241,4506,8,241, - 10,241,12,241,4509,9,241,1,242,1,242,1,242,1,242,1,242,1,242,1,243, - 1,243,1,243,5,243,4520,8,243,10,243,12,243,4523,9,243,1,244,1,244, - 1,244,1,244,1,244,1,244,1,245,1,245,3,245,4533,8,245,1,245,3,245, - 4536,8,245,1,246,1,246,1,246,1,246,1,246,1,246,1,246,1,246,1,246, - 1,247,1,247,3,247,4549,8,247,1,247,1,247,1,247,1,247,1,247,1,247, - 1,247,3,247,4558,8,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247, - 1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247, - 1,247,1,247,1,247,1,247,1,247,3,247,4583,8,247,1,247,1,247,1,247, - 1,247,1,247,1,247,1,247,1,247,1,247,3,247,4594,8,247,1,247,1,247, - 1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247, - 1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247, - 1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247, - 1,247,1,247,1,247,1,247,1,247,3,247,4636,8,247,1,247,1,247,1,247, - 1,247,1,247,1,247,3,247,4644,8,247,1,247,1,247,1,247,1,247,3,247, - 4650,8,247,1,248,1,248,1,248,1,248,1,249,1,249,1,249,5,249,4659, - 8,249,10,249,12,249,4662,9,249,1,250,1,250,1,250,3,250,4667,8,250, - 1,251,1,251,1,251,1,251,1,251,1,251,3,251,4675,8,251,1,252,1,252, - 1,252,1,252,1,253,1,253,1,253,5,253,4684,8,253,10,253,12,253,4687, - 9,253,1,254,1,254,1,254,1,254,1,255,1,255,1,256,1,256,1,256,5,256, - 4698,8,256,10,256,12,256,4701,9,256,1,257,1,257,1,257,1,257,1,257, - 1,257,3,257,4709,8,257,1,257,1,257,1,257,3,257,4714,8,257,1,257, - 1,257,1,257,1,257,1,257,1,257,1,257,1,257,1,257,3,257,4725,8,257, - 1,258,1,258,1,258,1,258,1,259,1,259,1,259,1,259,1,259,3,259,4736, - 8,259,1,259,1,259,1,259,1,259,1,259,1,259,3,259,4744,8,259,1,259, - 1,259,1,259,1,260,1,260,1,260,5,260,4752,8,260,10,260,12,260,4755, - 9,260,1,261,1,261,1,261,1,261,3,261,4761,8,261,1,261,3,261,4764, - 8,261,1,261,1,261,1,261,1,261,3,261,4770,8,261,1,261,3,261,4773, - 8,261,1,261,1,261,1,261,1,261,1,261,1,261,1,261,1,261,1,261,1,261, - 1,261,1,261,1,261,3,261,4788,8,261,1,262,1,262,1,263,1,263,1,263, - 1,264,1,264,1,264,1,264,1,264,1,264,3,264,4801,8,264,1,265,1,265, - 1,266,1,266,1,266,1,266,1,266,1,266,1,266,1,267,1,267,1,267,1,267, - 1,267,1,267,1,267,1,267,1,267,1,267,1,267,1,267,1,267,1,267,1,267, - 1,267,1,267,1,267,3,267,4830,8,267,1,268,1,268,1,268,5,268,4835, - 8,268,10,268,12,268,4838,9,268,1,269,1,269,1,269,1,269,1,269,1,269, - 1,269,1,269,1,269,1,269,1,269,1,269,3,269,4852,8,269,1,270,1,270, - 1,270,1,270,1,270,1,270,1,270,1,271,1,271,1,271,3,271,4864,8,271, - 1,271,1,271,3,271,4868,8,271,1,271,1,271,1,271,3,271,4873,8,271, - 1,271,1,271,3,271,4877,8,271,1,271,1,271,1,271,3,271,4882,8,271, - 1,271,1,271,3,271,4886,8,271,1,271,1,271,1,271,1,271,3,271,4892, - 8,271,1,271,1,271,3,271,4896,8,271,1,271,1,271,1,271,3,271,4901, - 8,271,1,271,1,271,3,271,4905,8,271,1,271,1,271,1,271,1,271,3,271, - 4911,8,271,1,271,1,271,3,271,4915,8,271,1,271,1,271,1,271,3,271, - 4920,8,271,1,271,1,271,3,271,4924,8,271,1,271,1,271,1,271,3,271, - 4929,8,271,1,271,1,271,3,271,4933,8,271,1,271,1,271,1,271,3,271, - 4938,8,271,1,271,1,271,3,271,4942,8,271,1,271,1,271,1,271,1,271, - 1,271,3,271,4949,8,271,1,271,1,271,3,271,4953,8,271,1,271,1,271, - 1,271,1,271,1,271,3,271,4960,8,271,1,271,1,271,3,271,4964,8,271, - 1,271,1,271,1,271,1,271,1,271,3,271,4971,8,271,1,271,1,271,3,271, - 4975,8,271,1,271,1,271,1,271,1,271,1,271,3,271,4982,8,271,1,271, - 1,271,3,271,4986,8,271,1,271,1,271,1,271,1,271,3,271,4992,8,271, - 1,271,1,271,3,271,4996,8,271,1,271,1,271,1,271,1,271,3,271,5002, - 8,271,1,271,1,271,3,271,5006,8,271,1,271,1,271,1,271,3,271,5011, - 8,271,1,271,1,271,3,271,5015,8,271,1,271,1,271,1,271,1,271,1,271, - 3,271,5022,8,271,1,271,1,271,3,271,5026,8,271,1,271,1,271,3,271, - 5030,8,271,1,271,1,271,3,271,5034,8,271,1,271,1,271,3,271,5038,8, - 271,1,271,1,271,1,271,3,271,5043,8,271,1,271,1,271,3,271,5047,8, - 271,1,271,1,271,1,271,3,271,5052,8,271,1,271,1,271,3,271,5056,8, - 271,1,271,1,271,1,271,3,271,5061,8,271,1,271,1,271,3,271,5065,8, - 271,1,271,1,271,1,271,3,271,5070,8,271,1,271,1,271,1,271,1,271,3, - 271,5076,8,271,1,271,1,271,1,271,3,271,5081,8,271,1,271,1,271,1, - 271,1,271,3,271,5087,8,271,1,271,1,271,1,271,3,271,5092,8,271,1, - 271,1,271,1,271,1,271,3,271,5098,8,271,1,271,1,271,1,271,3,271,5103, - 8,271,1,271,1,271,3,271,5107,8,271,1,271,1,271,1,271,3,271,5112, - 8,271,1,271,1,271,3,271,5116,8,271,1,271,1,271,1,271,1,271,3,271, - 5122,8,271,1,271,1,271,3,271,5126,8,271,1,271,1,271,1,271,3,271, - 5131,8,271,1,271,1,271,1,271,1,271,1,271,1,271,3,271,5139,8,271, - 1,271,1,271,1,271,1,271,3,271,5145,8,271,1,271,1,271,1,271,1,271, - 3,271,5151,8,271,1,271,1,271,1,271,1,271,3,271,5157,8,271,1,271, - 1,271,1,271,1,271,3,271,5163,8,271,1,271,1,271,1,271,1,271,1,271, - 3,271,5170,8,271,1,271,1,271,1,271,3,271,5175,8,271,1,271,1,271, - 3,271,5179,8,271,1,271,1,271,1,271,3,271,5184,8,271,1,271,1,271, - 3,271,5188,8,271,1,271,1,271,1,271,3,271,5193,8,271,1,271,1,271, - 1,271,1,271,3,271,5199,8,271,1,271,1,271,1,271,1,271,1,271,3,271, - 5206,8,271,1,271,1,271,1,271,3,271,5211,8,271,1,271,1,271,1,271, - 1,271,1,271,3,271,5218,8,271,1,271,1,271,1,271,1,271,1,271,1,271, - 1,271,1,271,3,271,5228,8,271,1,271,1,271,3,271,5232,8,271,1,271, - 1,271,1,271,1,271,3,271,5238,8,271,3,271,5240,8,271,1,272,1,272, - 1,272,5,272,5245,8,272,10,272,12,272,5248,9,272,1,273,3,273,5251, - 8,273,1,273,1,273,1,273,3,273,5256,8,273,1,273,1,273,1,273,1,273, - 1,273,1,273,1,273,1,273,1,273,1,273,1,273,1,273,1,273,1,273,1,273, - 1,273,3,273,5274,8,273,1,274,1,274,1,274,1,274,1,274,1,274,1,274, - 1,274,1,274,1,274,1,274,1,274,1,274,3,274,5289,8,274,1,274,1,274, - 1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,274,1,274, - 1,274,1,274,1,274,3,274,5307,8,274,1,275,1,275,1,276,1,276,1,276, - 5,276,5314,8,276,10,276,12,276,5317,9,276,1,277,1,277,1,277,1,277, - 1,278,1,278,3,278,5325,8,278,1,279,1,279,3,279,5329,8,279,1,280, - 1,280,4,280,5333,8,280,11,280,12,280,5334,1,281,1,281,1,281,5,281, - 5340,8,281,10,281,12,281,5343,9,281,1,282,1,282,3,282,5347,8,282, - 1,282,1,282,1,282,5,282,5352,8,282,10,282,12,282,5355,9,282,1,282, - 1,282,3,282,5359,8,282,1,282,3,282,5362,8,282,1,283,3,283,5365,8, - 283,1,283,1,283,3,283,5369,8,283,1,284,1,284,1,284,1,284,1,284,1, - 284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,3,284,5440, - 8,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, - 1,284,1,284,1,284,1,284,1,284,1,284,1,284,3,284,5536,8,284,1,285, - 1,285,3,285,5540,8,285,1,286,1,286,1,286,3,286,5545,8,286,1,286, - 1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,3,286,5556,8,286, - 1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,3,286,5567, - 8,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,3,286, - 5578,8,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286, - 3,286,5589,8,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286, - 1,286,3,286,5600,8,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286, - 1,286,1,286,1,286,3,286,5612,8,286,1,286,1,286,1,286,1,286,1,286, - 1,286,1,286,1,286,1,286,3,286,5623,8,286,1,286,1,286,1,286,1,286, - 1,286,1,286,1,286,1,286,1,286,3,286,5634,8,286,1,286,1,286,1,286, - 1,286,1,286,1,286,1,286,1,286,3,286,5644,8,286,1,286,1,286,1,286, - 1,286,1,286,3,286,5651,8,286,1,287,1,287,1,287,1,288,1,288,3,288, - 5658,8,288,1,289,1,289,1,289,1,289,3,289,5664,8,289,1,290,1,290, - 1,290,1,290,1,290,1,290,3,290,5672,8,290,1,290,1,290,1,290,3,290, - 5677,8,290,1,290,1,290,1,290,3,290,5682,8,290,1,290,1,290,1,290, - 3,290,5687,8,290,1,290,1,290,1,290,1,290,3,290,5693,8,290,1,290, - 1,290,1,290,1,290,1,290,3,290,5700,8,290,1,290,1,290,1,290,1,290, - 3,290,5706,8,290,1,290,1,290,1,290,1,290,3,290,5712,8,290,1,290, - 1,290,1,290,3,290,5717,8,290,1,290,1,290,1,290,1,290,3,290,5723, - 8,290,1,290,1,290,1,290,1,290,1,290,3,290,5730,8,290,1,290,1,290, - 1,290,3,290,5735,8,290,1,290,1,290,1,290,1,290,3,290,5741,8,290, - 1,290,1,290,1,290,1,290,1,290,3,290,5748,8,290,1,290,3,290,5751, - 8,290,1,291,1,291,1,292,1,292,1,293,1,293,1,293,1,293,1,293,1,293, - 1,293,3,293,5764,8,293,1,294,1,294,1,294,1,294,1,294,1,294,1,294, - 3,294,5773,8,294,1,294,1,294,1,294,1,294,1,294,1,294,1,294,1,294, - 1,294,1,294,3,294,5785,8,294,3,294,5787,8,294,1,295,1,295,1,295, - 1,295,1,295,1,295,1,295,1,295,1,295,1,295,1,295,1,295,1,295,1,295, - 1,295,1,295,3,295,5805,8,295,1,296,1,296,1,296,5,296,5810,8,296, - 10,296,12,296,5813,9,296,1,297,1,297,1,298,1,298,1,298,5,298,5820, - 8,298,10,298,12,298,5823,9,298,1,299,1,299,3,299,5827,8,299,1,299, - 1,299,3,299,5831,8,299,1,299,1,299,3,299,5835,8,299,1,299,1,299, - 3,299,5839,8,299,3,299,5841,8,299,1,300,1,300,1,300,1,300,1,300, - 1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300, - 1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300, - 1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300, - 1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300, - 1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,1,300,3,300,5901, - 8,300,1,301,1,301,1,301,5,301,5906,8,301,10,301,12,301,5909,9,301, - 1,302,1,302,1,302,3,302,5914,8,302,1,303,1,303,1,303,1,303,1,304, - 1,304,1,304,1,304,1,304,3,304,5925,8,304,1,304,3,304,5928,8,304, - 1,305,1,305,1,305,1,305,1,305,3,305,5935,8,305,1,305,3,305,5938, - 8,305,1,305,1,305,1,305,1,305,1,305,1,305,1,305,1,305,3,305,5948, - 8,305,1,305,3,305,5951,8,305,3,305,5953,8,305,1,306,1,306,1,306, - 1,306,1,307,1,307,1,307,1,307,1,308,1,308,1,308,1,308,1,308,1,308, - 1,309,5,309,5970,8,309,10,309,12,309,5973,9,309,1,310,1,310,1,310, - 1,310,1,310,1,310,1,310,1,310,1,310,3,310,5984,8,310,1,311,1,311, - 1,311,1,311,1,311,1,311,1,311,3,311,5993,8,311,1,311,1,311,1,311, - 1,311,1,311,1,311,1,311,3,311,6002,8,311,1,311,1,311,1,311,1,311, - 1,311,1,311,1,311,1,311,1,311,1,311,3,311,6014,8,311,3,311,6016, - 8,311,1,312,1,312,1,313,1,313,3,313,6022,8,313,1,313,1,313,3,313, - 6026,8,313,1,313,3,313,6029,8,313,1,313,3,313,6032,8,313,1,313,1, - 313,1,313,3,313,6037,8,313,1,313,1,313,1,313,1,313,3,313,6043,8, - 313,1,313,3,313,6046,8,313,1,313,3,313,6049,8,313,1,313,3,313,6052, - 8,313,1,313,3,313,6055,8,313,1,314,1,314,1,315,1,315,1,316,1,316, - 1,317,1,317,1,317,1,318,1,318,1,318,5,318,6069,8,318,10,318,12,318, - 6072,9,318,1,319,3,319,6075,8,319,1,319,3,319,6078,8,319,1,319,3, - 319,6081,8,319,1,319,3,319,6084,8,319,1,319,3,319,6087,8,319,1,319, - 1,319,1,319,3,319,6092,8,319,1,319,3,319,6095,8,319,3,319,6097,8, - 319,1,320,1,320,1,320,1,320,1,320,1,320,1,320,1,320,1,320,1,320, - 1,320,3,320,6110,8,320,1,321,1,321,1,321,1,321,1,321,1,322,1,322, - 1,322,5,322,6120,8,322,10,322,12,322,6123,9,322,1,323,1,323,1,323, - 1,324,1,324,1,325,1,325,1,326,1,326,1,326,1,326,3,326,6136,8,326, - 1,327,1,327,3,327,6140,8,327,1,327,1,327,1,327,1,327,3,327,6146, - 8,327,1,327,1,327,1,327,1,327,1,327,1,327,1,327,1,327,3,327,6156, - 8,327,3,327,6158,8,327,1,327,1,327,1,327,3,327,6163,8,327,1,328, - 1,328,1,328,1,328,5,328,6169,8,328,10,328,12,328,6172,9,328,1,328, - 1,328,1,329,1,329,1,329,1,330,1,330,3,330,6181,8,330,1,330,1,330, - 1,331,1,331,1,331,5,331,6188,8,331,10,331,12,331,6191,9,331,1,332, - 1,332,1,332,5,332,6196,8,332,10,332,12,332,6199,9,332,1,333,1,333, - 1,333,1,333,1,333,1,333,3,333,6207,8,333,3,333,6209,8,333,1,334, - 1,334,1,334,5,334,6214,8,334,10,334,12,334,6217,9,334,1,335,1,335, - 1,335,1,335,1,335,1,335,3,335,6225,8,335,3,335,6227,8,335,1,336, - 1,336,1,336,5,336,6232,8,336,10,336,12,336,6235,9,336,1,337,1,337, - 1,337,1,337,1,337,1,337,3,337,6243,8,337,3,337,6245,8,337,1,338, - 1,338,3,338,6249,8,338,1,338,1,338,1,339,1,339,1,339,5,339,6256, - 8,339,10,339,12,339,6259,9,339,1,340,1,340,3,340,6263,8,340,1,340, - 1,340,1,340,1,340,3,340,6269,8,340,1,340,1,340,1,340,3,340,6274, - 8,340,1,341,1,341,3,341,6278,8,341,1,341,1,341,1,341,3,341,6283, - 8,341,1,342,1,342,1,343,1,343,1,344,1,344,1,344,1,344,1,344,1,344, - 1,344,1,344,1,344,1,344,1,344,1,344,3,344,6301,8,344,1,345,1,345, - 1,345,3,345,6306,8,345,1,346,1,346,1,347,1,347,1,347,1,347,1,347, - 1,347,1,347,1,347,1,347,1,347,1,347,3,347,6321,8,347,1,347,1,347, - 1,348,1,348,1,348,5,348,6328,8,348,10,348,12,348,6331,9,348,1,349, - 1,349,1,349,1,350,1,350,1,350,5,350,6339,8,350,10,350,12,350,6342, - 9,350,1,351,4,351,6345,8,351,11,351,12,351,6346,1,352,1,352,1,352, - 1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352, - 1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352, - 1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,1,352,3,352, - 6384,8,352,1,353,1,353,1,353,1,353,1,353,1,353,1,353,1,353,1,353, - 1,353,1,353,1,353,1,353,1,353,1,353,1,353,1,353,1,353,3,353,6404, - 8,353,1,353,1,353,1,353,1,353,1,353,3,353,6411,8,353,1,354,1,354, - 1,354,1,354,1,354,1,354,1,354,5,354,6420,8,354,10,354,12,354,6423, - 9,354,1,355,1,355,1,355,1,356,1,356,1,356,1,357,1,357,1,357,5,357, - 6434,8,357,10,357,12,357,6437,9,357,1,358,1,358,1,358,1,358,3,358, - 6443,8,358,1,359,1,359,1,359,1,359,1,359,1,359,3,359,6451,8,359, - 1,360,4,360,6454,8,360,11,360,12,360,6455,1,361,1,361,1,362,1,362, - 1,362,3,362,6463,8,362,1,362,1,362,3,362,6467,8,362,1,362,1,362, - 1,362,3,362,6472,8,362,1,362,1,362,3,362,6476,8,362,1,362,1,362, - 1,362,3,362,6481,8,362,1,362,1,362,3,362,6485,8,362,3,362,6487,8, - 362,1,363,1,363,1,363,3,363,6492,8,363,1,363,1,363,3,363,6496,8, - 363,1,364,1,364,1,364,3,364,6501,8,364,1,364,1,364,3,364,6505,8, - 364,1,365,1,365,1,365,1,365,1,365,1,365,1,365,1,365,1,365,1,365, - 1,365,1,365,1,365,1,365,1,365,1,365,1,365,1,365,1,365,1,365,1,365, - 1,365,3,365,6529,8,365,1,366,1,366,1,366,5,366,6534,8,366,10,366, - 12,366,6537,9,366,1,366,1,366,1,367,1,367,1,367,5,367,6544,8,367, - 10,367,12,367,6547,9,367,1,368,1,368,1,368,1,369,1,369,1,369,1,370, - 4,370,6556,8,370,11,370,12,370,6557,1,371,1,371,1,371,3,371,6563, - 8,371,1,372,1,372,1,372,1,372,1,372,1,372,1,372,1,372,1,372,1,372, - 1,372,3,372,6576,8,372,1,372,1,372,1,372,1,372,1,372,1,372,1,372, - 1,372,1,372,1,372,3,372,6588,8,372,1,372,1,372,1,372,1,372,1,372, - 1,372,1,372,1,372,1,372,1,372,3,372,6600,8,372,3,372,6602,8,372, - 1,373,1,373,1,373,1,373,3,373,6608,8,373,1,374,1,374,1,374,1,375, - 1,375,3,375,6615,8,375,1,375,1,375,1,375,1,375,1,375,1,375,1,375, - 1,375,1,375,1,376,1,376,1,376,1,376,1,376,1,376,1,376,1,376,1,376, - 1,376,1,376,1,376,1,376,1,376,1,376,1,376,1,376,1,376,1,376,1,376, - 1,376,1,376,1,376,1,376,1,376,1,376,1,376,1,376,1,376,1,376,1,376, - 1,376,1,376,1,376,3,376,6660,8,376,1,377,1,377,1,377,1,377,1,377, - 1,377,1,377,1,377,1,377,1,377,1,377,1,377,1,377,1,377,1,377,1,377, - 3,377,6678,8,377,1,378,1,378,3,378,6682,8,378,1,378,1,378,1,378, - 3,378,6687,8,378,1,378,3,378,6690,8,378,1,379,1,379,3,379,6694,8, - 379,1,379,1,379,1,379,3,379,6699,8,379,1,379,1,379,1,379,3,379,6704, - 8,379,1,379,3,379,6707,8,379,1,380,1,380,1,380,5,380,6712,8,380, - 10,380,12,380,6715,9,380,1,381,1,381,1,382,1,382,1,382,1,382,1,382, - 1,382,1,382,1,382,1,382,1,382,1,382,1,382,3,382,6731,8,382,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,3,383,6802,8,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,3,383,6833,8,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,3,383,6887,8,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,3,383,6897,8,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,3,383,6907,8,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,3,383,6918,8,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,3,383,6928,8,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,3,383,6939,8,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,3,383,6949,8,383,1,383,1,383,1,383,3,383,6954, - 8,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,3,383,6963,8,383, - 1,383,1,383,1,383,3,383,6968,8,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,3,383,6978,8,383,1,383,1,383,1,383,3,383,6983, - 8,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,3,383,6992,8,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 3,383,7005,8,383,1,383,1,383,1,383,3,383,7010,8,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383, - 1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,1,383,3,383,7122, - 8,383,3,383,7124,8,383,1,384,1,384,1,384,1,385,1,385,1,385,1,385, - 3,385,7133,8,385,1,385,1,385,1,385,1,385,1,385,1,385,1,385,1,385, - 1,385,3,385,7144,8,385,1,385,1,385,1,385,1,385,1,385,1,385,1,385, - 1,385,1,385,3,385,7155,8,385,1,385,1,385,1,385,1,385,1,385,1,385, - 1,385,1,385,1,385,1,385,1,385,3,385,7168,8,385,1,385,1,385,1,385, - 1,385,1,385,1,385,1,385,1,385,1,385,1,385,3,385,7180,8,385,1,385, - 1,385,1,385,1,385,1,385,1,385,1,385,1,385,1,385,3,385,7191,8,385, - 1,385,1,385,1,385,1,385,1,385,3,385,7198,8,385,1,386,1,386,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,3,387,7288,8,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,3,387,7341,8,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,3,387,7351,8,387,1,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,3,387,7362,8,387, - 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,3,387,7373, - 8,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387, - 1,387,1,387,3,387,7387,8,387,1,388,1,388,1,388,1,388,1,388,1,388, - 1,388,1,388,1,389,1,389,1,389,5,389,7400,8,389,10,389,12,389,7403, - 9,389,1,390,1,390,1,390,1,390,1,390,1,390,1,390,1,390,3,390,7413, - 8,390,1,391,1,391,1,391,1,391,1,391,3,391,7420,8,391,1,392,1,392, - 1,392,1,392,1,392,1,392,1,392,1,392,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,3,393,7474,8,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393,1,393, - 1,393,1,393,1,393,1,393,1,393,3,393,7615,8,393,1,394,1,394,1,394, - 1,394,3,394,7621,8,394,1,394,3,394,7624,8,394,1,395,1,395,1,396, - 1,396,1,396,1,396,1,396,1,396,3,396,7634,8,396,1,397,1,397,1,397, - 1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397, - 1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397, - 1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397,1,397, - 1,397,1,397,3,397,7674,8,397,1,398,1,398,1,398,1,398,1,398,1,398, - 1,398,1,398,3,398,7684,8,398,1,399,1,399,1,399,5,399,7689,8,399, - 10,399,12,399,7692,9,399,1,400,1,400,1,401,1,401,1,401,1,401,1,401, - 1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401, - 1,401,1,401,3,401,7714,8,401,1,401,1,401,1,401,1,401,1,401,1,401, - 1,401,3,401,7723,8,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401, - 3,401,7732,8,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,3,401, - 7741,8,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401, - 1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401, - 1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401,1,401, - 3,401,7774,8,401,1,402,1,402,3,402,7778,8,402,1,402,1,402,1,402, - 1,402,1,402,1,402,1,402,1,402,3,402,7788,8,402,1,402,1,402,3,402, - 7792,8,402,1,402,1,402,1,403,1,403,1,403,1,403,1,403,1,403,3,403, - 7802,8,403,1,404,3,404,7805,8,404,1,404,1,404,3,404,7809,8,404,5, - 404,7811,8,404,10,404,12,404,7814,9,404,1,405,1,405,1,405,1,405, - 1,405,3,405,7821,8,405,1,406,1,406,1,407,1,407,1,408,1,408,1,409, - 1,409,1,409,3,409,7832,8,409,1,410,1,410,1,410,1,411,1,411,1,411, - 1,412,1,412,1,412,1,412,3,412,7844,8,412,1,413,1,413,3,413,7848, - 8,413,1,413,3,413,7851,8,413,1,413,1,413,3,413,7855,8,413,1,413, - 3,413,7858,8,413,1,413,1,413,1,413,3,413,7863,8,413,1,413,1,413, - 3,413,7867,8,413,1,413,3,413,7870,8,413,1,413,1,413,1,413,1,413, - 3,413,7876,8,413,1,413,1,413,1,413,1,413,1,413,1,413,1,413,1,413, - 1,413,3,413,7887,8,413,1,413,3,413,7890,8,413,1,413,1,413,1,413, - 1,413,1,413,3,413,7897,8,413,1,413,1,413,3,413,7901,8,413,1,413, - 1,413,1,413,3,413,7906,8,413,1,413,3,413,7909,8,413,3,413,7911,8, - 413,1,414,1,414,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415, - 1,415,1,415,3,415,7925,8,415,1,416,1,416,3,416,7929,8,416,1,416, - 5,416,7932,8,416,10,416,12,416,7935,9,416,1,417,1,417,1,418,1,418, - 3,418,7941,8,418,1,418,1,418,1,419,1,419,1,419,3,419,7948,8,419, - 1,419,3,419,7951,8,419,1,419,1,419,1,419,3,419,7956,8,419,1,419, - 3,419,7959,8,419,1,419,1,419,1,419,1,419,1,419,1,419,1,419,3,419, - 7968,8,419,3,419,7970,8,419,1,419,1,419,1,419,3,419,7975,8,419,1, - 420,1,420,3,420,7979,8,420,1,420,1,420,1,420,1,421,1,421,1,421,1, - 422,1,422,1,422,1,422,3,422,7991,8,422,1,422,3,422,7994,8,422,1, - 423,1,423,1,424,4,424,7999,8,424,11,424,12,424,8000,1,425,1,425, - 3,425,8005,8,425,1,425,1,425,1,425,3,425,8010,8,425,1,426,1,426, - 1,426,1,426,1,426,1,426,1,426,1,426,3,426,8020,8,426,1,427,1,427, - 1,428,1,428,1,428,1,428,1,428,1,428,3,428,8030,8,428,1,428,3,428, - 8033,8,428,1,428,3,428,8036,8,428,3,428,8038,8,428,1,429,1,429,1, - 429,1,429,3,429,8044,8,429,1,430,1,430,1,430,5,430,8049,8,430,10, - 430,12,430,8052,9,430,1,431,1,431,1,432,1,432,1,432,1,432,1,432, - 1,432,1,433,1,433,1,433,1,433,1,433,1,434,1,434,1,434,1,434,3,434, - 8071,8,434,1,434,1,434,1,434,1,435,1,435,1,435,1,435,1,435,1,435, - 1,435,1,435,1,435,1,435,1,435,1,435,1,435,1,435,1,435,3,435,8091, - 8,435,1,435,1,435,3,435,8095,8,435,1,435,1,435,1,435,3,435,8100, - 8,435,1,436,1,436,1,437,1,437,1,437,1,437,1,437,1,437,1,437,1,438, - 1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438, - 1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438, - 1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438, - 1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438, - 1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438,1,438, - 1,438,1,438,3,438,8169,8,438,1,438,1,438,1,438,3,438,8174,8,438, - 1,439,1,439,1,440,1,440,3,440,8180,8,440,1,440,1,440,1,440,1,440, - 1,440,1,440,1,440,1,440,1,440,1,441,1,441,3,441,8193,8,441,1,441, - 1,441,3,441,8197,8,441,1,441,1,441,3,441,8201,8,441,1,441,1,441, - 1,441,1,441,3,441,8207,8,441,3,441,8209,8,441,1,442,1,442,1,442, - 1,442,5,442,8215,8,442,10,442,12,442,8218,9,442,1,442,1,442,1,443, - 1,443,1,443,1,444,1,444,3,444,8227,8,444,1,444,3,444,8230,8,444, - 1,444,3,444,8233,8,444,1,444,3,444,8236,8,444,1,444,3,444,8239,8, - 444,1,444,1,444,1,444,1,444,1,444,3,444,8246,8,444,1,444,3,444,8249, - 8,444,3,444,8251,8,444,1,445,1,445,3,445,8255,8,445,1,445,3,445, - 8258,8,445,1,445,1,445,1,445,1,445,1,445,3,445,8265,8,445,3,445, - 8267,8,445,1,446,1,446,1,446,5,446,8272,8,446,10,446,12,446,8275, - 9,446,1,447,1,447,1,448,1,448,3,448,8281,8,448,1,449,1,449,3,449, - 8285,8,449,1,450,1,450,3,450,8289,8,450,1,451,1,451,1,452,1,452, - 1,452,5,452,8296,8,452,10,452,12,452,8299,9,452,1,453,1,453,1,453, - 3,453,8304,8,453,1,454,1,454,3,454,8308,8,454,1,455,1,455,3,455, - 8312,8,455,1,456,1,456,1,456,3,456,8317,8,456,1,457,1,457,1,458, - 1,458,1,459,1,459,1,459,1,459,1,460,1,460,3,460,8329,8,460,1,461, - 1,461,1,461,5,461,8334,8,461,10,461,12,461,8337,9,461,1,462,1,462, - 1,463,1,463,1,463,1,463,1,463,3,463,8346,8,463,1,463,1,463,1,463, - 1,463,1,463,1,463,1,463,1,463,1,463,1,463,1,463,3,463,8359,8,463, - 1,464,1,464,1,464,1,464,1,464,1,464,1,464,1,464,1,464,3,464,8370, - 8,464,1,465,1,465,1,465,5,465,8375,8,465,10,465,12,465,8378,9,465, - 1,466,1,466,3,466,8382,8,466,1,467,1,467,3,467,8386,8,467,1,468, - 1,468,3,468,8390,8,468,1,469,1,469,1,469,3,469,8395,8,469,1,469, - 1,469,1,469,1,470,1,470,1,470,1,470,1,471,1,471,1,471,1,471,3,471, - 8408,8,471,1,472,1,472,1,472,3,472,8413,8,472,1,472,1,472,3,472, - 8417,8,472,1,472,1,472,3,472,8421,8,472,1,472,1,472,1,472,1,472, - 1,472,3,472,8428,8,472,1,472,3,472,8431,8,472,3,472,8433,8,472,1, - 473,1,473,1,473,1,473,1,474,1,474,3,474,8441,8,474,1,474,1,474,3, - 474,8445,8,474,1,475,3,475,8448,8,475,1,475,1,475,1,475,1,475,1, - 475,3,475,8455,8,475,1,475,3,475,8458,8,475,1,476,1,476,1,476,3, - 476,8463,8,476,1,477,1,477,1,477,1,477,3,477,8469,8,477,1,477,1, - 477,1,477,1,477,3,477,8475,8,477,1,477,1,477,3,477,8479,8,477,1, - 478,1,478,1,479,1,479,1,479,5,479,8486,8,479,10,479,12,479,8489, - 9,479,1,480,1,480,1,480,1,481,1,481,1,481,3,481,8497,8,481,1,481, - 1,481,1,481,1,481,1,481,3,481,8504,8,481,1,481,3,481,8507,8,481, - 1,482,1,482,1,482,1,482,3,482,8513,8,482,1,482,1,482,1,482,3,482, - 8518,8,482,1,483,1,483,1,483,1,484,3,484,8524,8,484,1,484,1,484, - 1,484,1,484,3,484,8530,8,484,1,484,3,484,8533,8,484,1,484,3,484, - 8536,8,484,1,485,1,485,1,485,1,486,1,486,3,486,8543,8,486,1,486, - 1,486,3,486,8547,8,486,1,486,3,486,8550,8,486,1,487,1,487,1,487, - 1,487,1,488,1,488,1,488,1,488,1,488,1,488,1,488,1,488,1,488,3,488, - 8565,8,488,1,488,3,488,8568,8,488,1,489,1,489,1,490,1,490,1,490, - 3,490,8575,8,490,1,491,3,491,8578,8,491,1,491,1,491,1,491,1,491, - 1,491,3,491,8585,8,491,1,491,3,491,8588,8,491,1,491,3,491,8591,8, - 491,1,492,1,492,1,492,5,492,8596,8,492,10,492,12,492,8599,9,492, - 1,493,1,493,1,493,1,493,1,493,1,493,1,493,1,493,1,493,3,493,8610, - 8,493,1,493,1,493,1,493,1,493,1,493,3,493,8617,8,493,3,493,8619, - 8,493,1,494,1,494,1,494,1,495,1,495,1,495,5,495,8627,8,495,10,495, - 12,495,8630,9,495,1,496,1,496,1,496,1,496,1,496,1,496,1,496,1,496, - 1,497,1,497,1,498,1,498,1,498,1,498,1,498,5,498,8647,8,498,10,498, - 12,498,8650,9,498,1,499,1,499,1,499,1,499,1,499,3,499,8657,8,499, - 1,500,1,500,3,500,8661,8,500,1,501,1,501,1,501,1,501,1,501,1,501, - 1,501,1,501,3,501,8671,8,501,1,502,1,502,3,502,8675,8,502,1,502, - 1,502,3,502,8679,8,502,1,502,1,502,3,502,8683,8,502,3,502,8685,8, - 502,1,502,1,502,1,502,3,502,8690,8,502,1,502,1,502,3,502,8694,8, - 502,1,502,1,502,3,502,8698,8,502,3,502,8700,8,502,3,502,8702,8,502, - 1,503,1,503,3,503,8706,8,503,1,504,1,504,3,504,8710,8,504,1,504, - 3,504,8713,8,504,1,504,3,504,8716,8,504,1,504,3,504,8719,8,504,1, - 504,3,504,8722,8,504,3,504,8724,8,504,1,504,3,504,8727,8,504,1,504, - 3,504,8730,8,504,1,504,3,504,8733,8,504,1,504,3,504,8736,8,504,1, - 504,3,504,8739,8,504,1,504,3,504,8742,8,504,1,504,1,504,1,504,1, - 504,1,504,1,504,1,504,3,504,8751,8,504,3,504,8753,8,504,1,504,1, - 504,1,504,3,504,8758,8,504,5,504,8760,8,504,10,504,12,504,8763,9, - 504,1,505,1,505,1,505,3,505,8768,8,505,1,506,1,506,3,506,8772,8, - 506,1,507,1,507,3,507,8776,8,507,1,507,1,507,1,508,1,508,1,508,5, - 508,8783,8,508,10,508,12,508,8786,9,508,1,509,1,509,3,509,8790,8, - 509,1,509,1,509,3,509,8794,8,509,1,509,1,509,1,509,1,509,3,509,8800, - 8,509,1,509,3,509,8803,8,509,1,510,1,510,1,510,1,510,1,510,1,510, - 1,510,1,510,1,511,1,511,1,511,1,511,1,511,1,511,1,511,1,511,1,511, - 3,511,8822,8,511,1,511,1,511,1,511,1,512,1,512,1,512,3,512,8830, - 8,512,1,513,1,513,1,514,1,514,1,514,1,514,1,514,3,514,8839,8,514, - 1,515,1,515,3,515,8843,8,515,1,516,3,516,8846,8,516,1,516,1,516, - 3,516,8850,8,516,1,516,1,516,1,516,3,516,8855,8,516,1,516,1,516, - 1,516,1,516,3,516,8861,8,516,1,517,1,517,1,518,1,518,1,519,1,519, - 1,519,1,519,1,519,1,519,3,519,8873,8,519,1,520,1,520,1,521,1,521, - 1,522,1,522,1,522,1,522,1,523,1,523,1,523,5,523,8886,8,523,10,523, - 12,523,8889,9,523,1,524,1,524,1,524,1,524,3,524,8895,8,524,1,524, - 3,524,8898,8,524,1,525,1,525,3,525,8902,8,525,1,525,1,525,3,525, - 8906,8,525,1,525,1,525,3,525,8910,8,525,3,525,8912,8,525,1,526,1, - 526,1,527,1,527,1,527,1,527,3,527,8920,8,527,1,528,1,528,1,528,1, - 528,1,528,1,528,1,528,3,528,8929,8,528,1,528,1,528,1,528,1,528,3, - 528,8935,8,528,3,528,8937,8,528,1,529,1,529,1,529,1,529,1,529,3, - 529,8944,8,529,1,530,1,530,3,530,8948,8,530,1,531,1,531,1,532,1, - 532,1,532,1,532,1,532,3,532,8957,8,532,1,533,1,533,3,533,8961,8, - 533,1,534,1,534,1,535,1,535,1,536,1,536,1,536,3,536,8970,8,536,1, - 536,1,536,1,537,1,537,1,537,5,537,8977,8,537,10,537,12,537,8980, - 9,537,1,538,1,538,1,538,1,538,1,538,1,538,1,538,1,538,1,538,3,538, - 8991,8,538,1,539,1,539,1,539,1,540,1,540,1,540,1,540,1,540,1,541, - 1,541,1,541,1,541,1,541,1,542,1,542,1,542,1,542,1,542,1,542,1,543, - 1,543,1,543,1,544,1,544,1,544,1,544,3,544,9019,8,544,1,545,1,545, - 1,546,4,546,9024,8,546,11,546,12,546,9025,1,547,1,547,3,547,9030, - 8,547,1,547,3,547,9033,8,547,1,548,1,548,1,548,3,548,9038,8,548, - 1,548,1,548,3,548,9042,8,548,1,548,3,548,9045,8,548,1,549,1,549, - 1,549,1,550,1,550,1,550,1,550,1,550,1,550,1,550,1,550,1,550,5,550, - 9059,8,550,10,550,12,550,9062,9,550,1,551,1,551,1,551,1,552,1,552, - 1,552,5,552,9070,8,552,10,552,12,552,9073,9,552,1,553,1,553,3,553, - 9077,8,553,1,553,3,553,9080,8,553,1,553,3,553,9083,8,553,1,553,1, - 553,3,553,9087,8,553,1,553,1,553,3,553,9091,8,553,1,553,1,553,3, - 553,9095,8,553,1,553,1,553,1,553,3,553,9100,8,553,1,553,1,553,3, - 553,9104,8,553,1,553,1,553,3,553,9108,8,553,3,553,9110,8,553,1,553, - 1,553,1,553,1,553,1,553,1,553,1,553,3,553,9119,8,553,1,553,1,553, - 1,553,3,553,9124,8,553,1,553,1,553,1,553,1,553,3,553,9130,8,553, - 1,553,1,553,3,553,9134,8,553,3,553,9136,8,553,1,553,1,553,1,553, - 1,553,1,553,3,553,9143,8,553,1,553,1,553,1,553,3,553,9148,8,553, - 1,553,1,553,1,553,1,553,5,553,9154,8,553,10,553,12,553,9157,9,553, - 1,554,3,554,9160,8,554,1,554,1,554,1,554,1,554,1,554,3,554,9167, - 8,554,1,555,1,555,1,556,1,556,1,556,3,556,9174,8,556,1,556,3,556, - 9177,8,556,1,556,1,556,1,556,1,556,3,556,9183,8,556,1,557,1,557, - 3,557,9187,8,557,1,558,1,558,1,558,1,558,1,558,1,558,1,558,3,558, - 9196,8,558,1,559,3,559,9199,8,559,1,559,1,559,3,559,9203,8,559,1, - 559,1,559,1,559,1,559,1,559,1,559,3,559,9211,8,559,1,559,1,559,1, - 559,1,559,3,559,9217,8,559,3,559,9219,8,559,1,560,3,560,9222,8,560, - 1,560,1,560,3,560,9226,8,560,1,560,3,560,9229,8,560,1,560,3,560, - 9232,8,560,1,561,1,561,3,561,9236,8,561,1,561,1,561,3,561,9240,8, - 561,1,561,1,561,1,561,1,561,3,561,9246,8,561,1,561,3,561,9249,8, - 561,1,561,1,561,1,561,1,561,1,561,1,561,1,561,3,561,9258,8,561,1, - 561,1,561,1,561,1,561,1,561,3,561,9265,8,561,3,561,9267,8,561,1, - 562,1,562,1,562,5,562,9272,8,562,10,562,12,562,9275,9,562,1,563, - 1,563,1,563,5,563,9280,8,563,10,563,12,563,9283,9,563,1,564,1,564, - 3,564,9287,8,564,1,564,3,564,9290,8,564,1,565,1,565,1,565,1,565, - 1,565,1,565,3,565,9298,8,565,1,566,1,566,1,566,1,566,1,566,1,567, - 1,567,3,567,9307,8,567,1,567,1,567,1,567,1,567,1,567,1,567,3,567, - 9315,8,567,3,567,9317,8,567,1,568,1,568,3,568,9321,8,568,1,569,1, - 569,1,569,5,569,9326,8,569,10,569,12,569,9329,9,569,1,570,1,570, - 1,570,1,570,1,570,1,571,1,571,1,571,1,572,1,572,1,572,1,573,1,573, - 1,573,1,573,1,573,3,573,9347,8,573,1,574,1,574,1,575,1,575,1,575, - 5,575,9354,8,575,10,575,12,575,9357,9,575,1,576,1,576,1,576,3,576, - 9362,8,576,1,577,1,577,1,577,1,577,1,577,1,577,1,577,1,577,1,577, - 1,577,1,577,1,577,1,577,1,577,1,577,1,577,1,577,3,577,9381,8,577, - 1,577,1,577,1,578,1,578,1,578,5,578,9388,8,578,10,578,12,578,9391, - 9,578,1,579,1,579,1,579,3,579,9396,8,579,1,579,1,579,3,579,9400, - 8,579,1,580,4,580,9403,8,580,11,580,12,580,9404,1,581,1,581,1,581, - 1,581,1,581,1,581,1,581,1,581,3,581,9415,8,581,1,582,1,582,1,582, - 5,582,9420,8,582,10,582,12,582,9423,9,582,1,583,1,583,1,583,1,583, - 1,583,1,583,3,583,9431,8,583,1,584,3,584,9434,8,584,1,584,1,584, - 1,584,1,584,1,584,1,584,1,584,3,584,9443,8,584,3,584,9445,8,584, - 1,584,1,584,1,584,1,584,3,584,9451,8,584,1,585,1,585,3,585,9455, - 8,585,1,585,5,585,9458,8,585,10,585,12,585,9461,9,585,1,586,1,586, - 1,586,1,586,1,586,1,586,1,586,3,586,9470,8,586,1,586,1,586,1,586, - 1,586,3,586,9476,8,586,3,586,9478,8,586,1,587,1,587,1,587,1,587, - 3,587,9484,8,587,1,588,1,588,3,588,9488,8,588,1,588,3,588,9491,8, - 588,1,589,1,589,1,589,1,589,1,590,1,590,1,590,1,590,1,590,1,590, - 1,590,3,590,9504,8,590,1,590,1,590,1,590,1,590,3,590,9510,8,590, - 1,590,1,590,3,590,9514,8,590,1,590,1,590,3,590,9518,8,590,1,590, - 3,590,9521,8,590,1,591,1,591,1,591,1,591,1,592,1,592,3,592,9529, - 8,592,1,593,1,593,3,593,9533,8,593,1,594,1,594,3,594,9537,8,594, - 1,594,1,594,1,594,1,594,1,595,1,595,3,595,9545,8,595,1,596,1,596, - 1,596,1,596,1,596,3,596,9552,8,596,1,597,1,597,1,597,1,597,1,597, - 3,597,9559,8,597,1,598,1,598,3,598,9563,8,598,1,598,1,598,1,598, - 1,598,3,598,9569,8,598,3,598,9571,8,598,1,599,1,599,1,600,1,600, - 1,600,1,600,1,600,3,600,9580,8,600,1,600,3,600,9583,8,600,1,601, - 1,601,1,602,1,602,1,602,1,602,1,602,1,602,3,602,9593,8,602,1,603, - 1,603,1,603,1,603,1,603,1,603,1,603,1,603,1,603,1,603,1,603,1,603, - 1,603,1,603,3,603,9609,8,603,1,603,1,603,1,603,1,603,3,603,9615, - 8,603,1,603,1,603,1,603,3,603,9620,8,603,1,604,1,604,1,604,1,604, - 1,604,3,604,9627,8,604,1,605,1,605,1,605,1,606,1,606,1,607,1,607, - 3,607,9636,8,607,1,608,1,608,1,608,5,608,9641,8,608,10,608,12,608, - 9644,9,608,1,609,1,609,1,609,5,609,9649,8,609,10,609,12,609,9652, - 9,609,1,610,1,610,1,610,5,610,9657,8,610,10,610,12,610,9660,9,610, - 1,611,1,611,3,611,9664,8,611,1,611,1,611,3,611,9668,8,611,1,612, - 3,612,9671,8,612,1,612,1,612,1,613,1,613,3,613,9677,8,613,1,614, - 1,614,1,614,3,614,9682,8,614,1,614,1,614,1,614,1,614,1,614,1,614, - 1,614,1,614,1,614,1,614,1,614,1,614,1,614,1,614,3,614,9698,8,614, - 1,614,3,614,9701,8,614,3,614,9703,8,614,1,615,1,615,1,615,1,615, - 1,615,1,615,1,615,1,615,1,615,1,615,3,615,9715,8,615,3,615,9717, - 8,615,1,616,1,616,3,616,9721,8,616,1,616,1,616,1,616,1,616,1,616, - 1,616,3,616,9729,8,616,3,616,9731,8,616,1,616,1,616,3,616,9735,8, - 616,3,616,9737,8,616,1,617,1,617,1,617,1,617,5,617,9743,8,617,10, - 617,12,617,9746,9,617,1,618,3,618,9749,8,618,1,618,1,618,1,619,1, - 619,1,619,5,619,9756,8,619,10,619,12,619,9759,9,619,1,620,1,620, - 1,620,5,620,9764,8,620,10,620,12,620,9767,9,620,1,621,1,621,1,621, - 3,621,9772,8,621,1,622,3,622,9775,8,622,1,622,1,622,1,623,1,623, - 1,623,1,623,1,623,3,623,9784,8,623,1,624,1,624,1,624,3,624,9789, - 8,624,1,625,1,625,1,625,5,625,9794,8,625,10,625,12,625,9797,9,625, - 1,626,1,626,1,626,1,626,1,626,1,626,1,626,3,626,9806,8,626,1,626, - 1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626, - 1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626, - 1,626,3,626,9832,8,626,1,626,1,626,1,626,1,626,1,626,1,626,1,626, - 1,626,1,626,3,626,9843,8,626,5,626,9845,8,626,10,626,12,626,9848, - 9,626,1,627,1,627,1,627,1,627,1,627,3,627,9855,8,627,1,627,1,627, - 1,627,1,627,1,627,1,627,1,627,1,627,1,627,1,627,1,627,1,627,1,627, - 1,627,1,627,1,627,1,627,1,627,1,627,1,627,3,627,9877,8,627,1,627, - 1,627,1,627,1,627,1,627,1,627,1,627,3,627,9886,8,627,1,628,1,628, - 1,629,1,629,1,629,1,629,1,629,1,629,3,629,9896,8,629,1,629,3,629, - 9899,8,629,1,629,1,629,1,629,3,629,9904,8,629,1,629,1,629,1,629, - 3,629,9909,8,629,1,629,1,629,3,629,9913,8,629,1,629,3,629,9916,8, - 629,1,630,1,630,3,630,9920,8,630,1,630,3,630,9923,8,630,1,630,3, - 630,9926,8,630,1,630,3,630,9929,8,630,1,631,1,631,3,631,9933,8,631, - 1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632, - 1,632,3,632,9947,8,632,1,632,1,632,1,632,1,632,1,632,3,632,9954, - 8,632,1,632,1,632,1,632,1,632,1,632,3,632,9961,8,632,1,632,1,632, - 1,632,1,632,1,632,3,632,9968,8,632,1,632,1,632,1,632,1,632,1,632, - 1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632, - 3,632,9986,8,632,1,632,1,632,1,632,1,632,1,632,1,632,3,632,9994, - 8,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632, - 3,632,10006,8,632,1,632,1,632,1,632,1,632,3,632,10012,8,632,1,632, - 1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,3,632, - 10025,8,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632, - 1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632, - 1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632, - 1,632,1,632,1,632,1,632,1,632,1,632,3,632,10064,8,632,3,632,10066, - 8,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632, - 1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,3,632,10086,8,632, - 1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,3,632,10096,8,632, - 1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,3,632,10107, - 8,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632,1,632, - 3,632,10119,8,632,1,633,1,633,1,633,1,633,1,633,3,633,10126,8,633, - 1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,1,634,3,634, - 10138,8,634,1,635,1,635,1,635,1,635,1,635,1,636,1,636,1,636,5,636, - 10148,8,636,10,636,12,636,10151,9,636,1,637,1,637,1,637,3,637,10156, - 8,637,1,638,1,638,1,639,1,639,1,639,1,639,3,639,10164,8,639,1,640, - 1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640, - 1,640,1,640,1,640,3,640,10181,8,640,1,641,1,641,1,641,1,642,1,642, - 1,642,1,642,1,642,1,642,1,643,1,643,1,643,1,643,1,643,1,643,1,644, - 1,644,1,644,1,645,1,645,1,645,5,645,10204,8,645,10,645,12,645,10207, - 9,645,1,646,1,646,1,646,1,646,1,647,1,647,1,647,3,647,10216,8,647, - 1,648,1,648,3,648,10220,8,648,1,648,3,648,10223,8,648,1,648,3,648, - 10226,8,648,1,648,3,648,10229,8,648,1,648,1,648,1,649,1,649,1,650, - 1,650,1,650,1,650,1,651,1,651,1,651,3,651,10242,8,651,1,651,1,651, - 1,651,3,651,10247,8,651,1,651,1,651,1,651,3,651,10252,8,651,3,651, - 10254,8,651,1,652,1,652,1,652,1,652,1,652,1,652,3,652,10262,8,652, - 1,653,1,653,1,653,1,653,1,653,1,653,1,653,3,653,10271,8,653,1,654, - 1,654,1,654,1,654,1,654,1,654,1,654,3,654,10280,8,654,1,655,1,655, - 1,655,3,655,10285,8,655,1,655,1,655,1,655,1,655,1,655,1,655,1,655, - 3,655,10294,8,655,1,656,1,656,1,656,3,656,10299,8,656,1,656,1,656, - 1,657,1,657,1,657,1,657,1,657,1,657,1,658,1,658,1,659,1,659,3,659, - 10313,8,659,1,660,1,660,1,661,1,661,1,661,1,661,1,661,1,661,3,661, - 10323,8,661,1,662,1,662,1,662,1,662,1,662,1,662,3,662,10331,8,662, - 1,663,1,663,1,663,1,663,1,663,1,663,1,663,1,663,1,663,1,663,1,663, - 1,663,3,663,10345,8,663,1,664,1,664,1,664,5,664,10350,8,664,10,664, - 12,664,10353,9,664,1,665,1,665,1,665,5,665,10358,8,665,10,665,12, - 665,10361,9,665,1,666,1,666,1,666,5,666,10366,8,666,10,666,12,666, - 10369,9,666,1,667,1,667,1,667,1,667,1,667,3,667,10376,8,667,1,668, - 1,668,3,668,10380,8,668,1,669,1,669,1,669,5,669,10385,8,669,10,669, - 12,669,10388,9,669,1,670,1,670,1,670,1,670,1,670,3,670,10395,8,670, - 1,671,1,671,1,671,5,671,10400,8,671,10,671,12,671,10403,9,671,1, - 672,1,672,1,672,3,672,10408,8,672,1,672,1,672,1,673,1,673,1,673, - 5,673,10415,8,673,10,673,12,673,10418,9,673,1,674,1,674,1,674,1, - 674,1,675,1,675,1,675,1,675,1,675,1,675,1,675,1,675,3,675,10432, - 8,675,1,676,1,676,1,677,1,677,1,677,1,677,1,677,1,677,1,677,3,677, - 10443,8,677,1,678,1,678,1,678,1,678,1,679,1,679,1,679,1,679,1,679, - 1,679,1,679,1,679,1,679,1,679,1,679,1,679,1,679,1,679,1,679,1,679, - 1,679,1,679,1,679,1,679,1,679,1,679,1,679,1,679,1,679,1,679,1,679, - 3,679,10476,8,679,1,680,1,680,1,680,1,680,1,680,1,680,1,680,3,680, - 10485,8,680,1,681,1,681,1,681,1,681,1,681,3,681,10492,8,681,1,682, - 1,682,3,682,10496,8,682,1,682,1,682,3,682,10500,8,682,1,682,1,682, - 1,683,4,683,10505,8,683,11,683,12,683,10506,1,684,1,684,1,684,1, - 684,1,684,1,685,1,685,1,685,1,686,1,686,1,687,1,687,3,687,10521, - 8,687,1,688,1,688,1,688,3,688,10526,8,688,1,688,1,688,1,688,3,688, - 10531,8,688,1,688,1,688,3,688,10535,8,688,3,688,10537,8,688,1,688, - 3,688,10540,8,688,1,689,1,689,1,690,4,690,10545,8,690,11,690,12, - 690,10546,1,691,5,691,10550,8,691,10,691,12,691,10553,9,691,1,692, - 1,692,1,693,1,693,1,693,5,693,10560,8,693,10,693,12,693,10563,9, - 693,1,694,1,694,1,694,1,694,1,694,3,694,10570,8,694,1,694,3,694, - 10573,8,694,1,695,1,695,1,695,5,695,10578,8,695,10,695,12,695,10581, - 9,695,1,696,1,696,1,696,5,696,10586,8,696,10,696,12,696,10589,9, - 696,1,697,1,697,1,697,5,697,10594,8,697,10,697,12,697,10597,9,697, - 1,698,1,698,1,698,5,698,10602,8,698,10,698,12,698,10605,9,698,1, - 699,1,699,1,699,5,699,10610,8,699,10,699,12,699,10613,9,699,1,700, - 1,700,3,700,10617,8,700,1,701,1,701,3,701,10621,8,701,1,702,1,702, - 3,702,10625,8,702,1,703,1,703,3,703,10629,8,703,1,704,1,704,3,704, - 10633,8,704,1,705,1,705,3,705,10637,8,705,1,706,1,706,3,706,10641, - 8,706,1,707,1,707,1,707,5,707,10646,8,707,10,707,12,707,10649,9, - 707,1,708,1,708,1,708,5,708,10654,8,708,10,708,12,708,10657,9,708, - 1,709,1,709,3,709,10661,8,709,1,710,1,710,3,710,10665,8,710,1,711, - 1,711,3,711,10669,8,711,1,712,1,712,1,713,1,713,1,714,1,714,1,714, - 1,714,3,714,10679,8,714,1,715,1,715,1,715,1,715,3,715,10685,8,715, - 1,716,1,716,5,716,10689,8,716,10,716,12,716,10692,9,716,1,716,3, - 716,10695,8,716,1,717,1,717,1,718,1,718,1,719,1,719,1,720,1,720, - 1,721,1,721,1,721,1,721,3,721,10709,8,721,1,722,1,722,1,722,1,722, - 3,722,10715,8,722,1,723,1,723,1,723,1,723,3,723,10721,8,723,1,724, - 1,724,1,724,1,724,1,724,1,724,1,724,1,724,1,724,1,724,3,724,10733, - 8,724,1,724,1,724,1,724,3,724,10738,8,724,1,724,1,724,1,724,1,724, - 1,724,1,724,3,724,10746,8,724,1,724,1,724,1,724,1,724,1,724,3,724, - 10753,8,724,1,724,1,724,1,724,3,724,10758,8,724,1,725,1,725,1,726, - 1,726,1,727,1,727,1,728,1,728,1,729,1,729,3,729,10770,8,729,1,730, - 1,730,1,730,1,730,5,730,10776,8,730,10,730,12,730,10779,9,730,1, - 730,1,730,3,730,10783,8,730,1,731,1,731,1,731,1,732,1,732,1,732, - 1,732,1,732,3,732,10793,8,732,1,733,1,733,1,734,1,734,1,735,1,735, - 1,735,1,735,1,735,3,735,10804,8,735,1,736,1,736,1,736,5,736,10809, - 8,736,10,736,12,736,10812,9,736,1,737,1,737,1,737,1,737,3,737,10818, - 8,737,1,738,1,738,1,739,1,739,1,739,1,739,1,739,1,739,1,739,3,739, - 10829,8,739,1,739,3,739,10832,8,739,3,739,10834,8,739,1,740,1,740, - 3,740,10838,8,740,1,740,3,740,10841,8,740,1,741,1,741,1,741,1,741, - 3,741,10847,8,741,1,742,1,742,1,742,1,742,3,742,10853,8,742,1,743, - 1,743,3,743,10857,8,743,1,744,1,744,1,744,1,744,3,744,10863,8,744, - 1,745,1,745,1,745,1,745,1,745,1,745,3,745,10871,8,745,1,746,1,746, - 3,746,10875,8,746,1,746,1,746,1,746,1,746,1,746,1,746,3,746,10883, - 8,746,1,747,1,747,1,748,1,748,1,749,1,749,1,749,1,749,1,749,1,749, - 1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749, - 1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749, - 1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749, - 1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749,1,749, - 1,749,3,749,10940,8,749,1,750,1,750,1,751,1,751,1,752,1,752,1,752, - 1,752,1,753,5,753,10951,8,753,10,753,12,753,10954,9,753,1,754,1, - 754,1,754,1,754,1,754,1,754,1,754,1,754,1,754,1,754,1,754,1,754, - 1,754,1,754,1,754,1,754,1,754,1,754,1,754,1,754,3,754,10976,8,754, - 1,755,1,755,1,756,1,756,1,756,1,756,3,756,10984,8,756,1,757,1,757, - 3,757,10988,8,757,1,758,1,758,1,758,1,758,1,758,1,758,1,758,1,759, - 1,759,1,759,3,759,11000,8,759,3,759,11002,8,759,1,760,1,760,1,761, - 4,761,11007,8,761,11,761,12,761,11008,1,762,1,762,1,762,1,762,1, - 763,1,763,1,763,3,763,11018,8,763,1,764,1,764,1,764,1,764,1,764, - 1,764,1,764,1,764,1,764,1,764,1,764,1,764,1,764,1,764,1,764,1,764, - 3,764,11036,8,764,1,764,1,764,1,765,1,765,1,765,1,765,3,765,11044, - 8,765,1,766,1,766,1,767,1,767,1,767,1,767,1,767,3,767,11053,8,767, - 1,768,1,768,1,768,5,768,11058,8,768,10,768,12,768,11061,9,768,1, - 769,1,769,1,769,1,770,1,770,1,771,1,771,3,771,11070,8,771,1,772, - 1,772,1,773,1,773,3,773,11076,8,773,1,774,1,774,1,775,1,775,1,775, - 3,775,11083,8,775,1,776,1,776,1,776,3,776,11088,8,776,1,777,1,777, - 1,777,1,777,3,777,11094,8,777,1,778,1,778,3,778,11098,8,778,1,779, - 1,779,1,780,5,780,11103,8,780,10,780,12,780,11106,9,780,1,781,1, - 781,1,781,1,781,1,781,1,781,1,781,1,781,1,781,1,781,1,781,1,781, - 1,781,1,781,1,781,1,781,1,781,1,781,1,781,1,781,1,781,1,781,1,781, - 1,781,1,781,1,781,1,781,3,781,11135,8,781,1,782,1,782,1,782,1,782, - 1,783,1,783,1,783,1,783,1,783,1,783,1,783,3,783,11148,8,783,1,783, - 1,783,1,783,1,783,1,783,1,783,1,783,3,783,11157,8,783,1,784,1,784, - 3,784,11161,8,784,1,785,1,785,1,785,1,785,1,785,1,786,1,786,1,786, - 1,786,1,786,1,786,1,787,1,787,1,787,3,787,11177,8,787,1,788,1,788, - 1,788,5,788,11182,8,788,10,788,12,788,11185,9,788,1,789,1,789,1, - 789,1,789,1,790,1,790,1,791,1,791,1,792,1,792,3,792,11197,8,792, - 1,792,1,792,1,792,1,792,5,792,11203,8,792,10,792,12,792,11206,9, - 792,1,793,1,793,1,793,1,793,1,793,1,793,1,793,1,793,1,793,1,793, - 1,794,1,794,1,794,1,794,1,794,5,794,11223,8,794,10,794,12,794,11226, - 9,794,1,795,1,795,1,795,3,795,11231,8,795,1,796,1,796,1,796,1,796, - 1,796,1,796,1,796,1,796,1,797,1,797,3,797,11243,8,797,1,798,4,798, - 11246,8,798,11,798,12,798,11247,1,799,1,799,1,799,1,799,1,799,1, - 800,1,800,1,800,3,800,11258,8,800,1,801,1,801,1,801,1,802,1,802, - 1,802,1,802,1,802,1,803,1,803,1,803,1,803,1,803,1,804,1,804,1,804, - 1,804,1,804,1,804,1,804,1,804,1,804,1,804,1,804,1,804,1,804,1,804, - 1,804,1,804,1,804,3,804,11290,8,804,1,805,1,805,1,805,3,805,11295, - 8,805,1,806,1,806,1,806,1,806,1,806,5,806,11302,8,806,10,806,12, - 806,11305,9,806,1,806,1,806,3,806,11309,8,806,1,807,1,807,3,807, - 11313,8,807,1,808,1,808,1,808,3,808,11318,8,808,1,809,1,809,1,810, - 1,810,1,810,1,810,1,810,1,810,1,810,1,810,1,810,1,811,1,811,1,811, - 3,811,11334,8,811,1,812,1,812,1,812,3,812,11339,8,812,1,812,1,812, - 1,813,1,813,1,814,1,814,1,814,1,814,1,814,1,814,1,814,1,814,1,814, - 3,814,11354,8,814,1,814,3,814,11357,8,814,1,814,1,814,1,815,1,815, - 3,815,11363,8,815,1,816,1,816,3,816,11367,8,816,1,816,1,816,1,816, - 1,816,1,816,1,816,1,816,3,816,11376,8,816,1,816,1,816,1,816,1,816, - 1,816,1,816,3,816,11384,8,816,1,816,1,816,1,816,1,816,1,816,1,816, - 1,816,3,816,11393,8,816,1,816,1,816,1,816,1,816,3,816,11399,8,816, - 1,817,1,817,1,818,1,818,1,818,4,818,11406,8,818,11,818,12,818,11407, - 3,818,11410,8,818,1,819,1,819,1,819,3,819,11415,8,819,1,820,1,820, - 1,820,1,820,1,821,1,821,1,821,5,821,11424,8,821,10,821,12,821,11427, - 9,821,1,822,1,822,1,822,1,822,1,822,1,823,1,823,1,823,3,823,11437, - 8,823,1,824,1,824,1,824,1,824,1,824,1,824,1,824,1,825,1,825,1,825, - 1,826,1,826,1,826,1,826,1,826,1,826,1,826,1,826,1,826,3,826,11458, - 8,826,1,826,1,826,1,827,1,827,1,827,3,827,11465,8,827,1,828,1,828, - 1,828,5,828,11470,8,828,10,828,12,828,11473,9,828,1,829,1,829,1, - 829,3,829,11478,8,829,1,829,3,829,11481,8,829,1,830,1,830,1,830, - 1,830,1,830,1,830,1,830,1,830,1,830,3,830,11492,8,830,1,830,1,830, - 1,830,1,830,1,830,3,830,11499,8,830,3,830,11501,8,830,1,830,1,830, - 1,831,1,831,1,831,1,831,1,831,3,831,11510,8,831,1,832,1,832,1,832, - 5,832,11515,8,832,10,832,12,832,11518,9,832,1,833,1,833,1,833,3, - 833,11523,8,833,1,834,1,834,1,834,1,834,3,834,11529,8,834,1,835, - 1,835,3,835,11533,8,835,1,836,1,836,3,836,11537,8,836,1,836,1,836, - 1,836,1,836,1,836,1,836,1,837,1,837,1,838,1,838,1,838,3,838,11550, - 8,838,1,839,1,839,1,839,1,839,1,839,1,839,1,839,1,839,1,839,1,839, - 1,839,1,839,1,839,3,839,11565,8,839,3,839,11567,8,839,1,840,1,840, - 3,840,11571,8,840,1,840,1,840,1,840,1,841,3,841,11577,8,841,1,841, - 1,841,1,841,3,841,11582,8,841,1,841,1,841,3,841,11586,8,841,1,841, - 3,841,11589,8,841,1,841,3,841,11592,8,841,1,841,1,841,1,841,1,841, - 1,841,4,841,11599,8,841,11,841,12,841,11600,1,842,3,842,11604,8, - 842,1,842,1,842,3,842,11608,8,842,1,842,1,842,3,842,11612,8,842, - 3,842,11614,8,842,1,842,3,842,11617,8,842,1,842,3,842,11620,8,842, - 1,843,1,843,1,844,1,844,1,844,1,844,3,844,11628,8,844,1,844,1,844, - 1,844,1,844,1,844,3,844,11635,8,844,1,844,1,844,1,844,1,844,1,844, - 3,844,11642,8,844,1,844,1,844,1,844,1,844,3,844,11648,8,844,3,844, - 11650,8,844,1,845,1,845,1,845,1,845,1,845,3,845,11657,8,845,1,845, - 1,845,1,845,3,845,11662,8,845,1,845,1,845,1,846,1,846,1,846,1,846, - 1,846,1,846,1,846,1,846,1,846,1,846,1,846,1,846,1,846,1,846,4,846, - 11680,8,846,11,846,12,846,11681,1,847,1,847,1,847,1,847,3,847,11688, - 8,847,1,848,1,848,1,848,1,848,5,848,11694,8,848,10,848,12,848,11697, - 9,848,1,848,1,848,1,849,1,849,3,849,11703,8,849,1,850,1,850,1,850, - 1,850,1,851,1,851,1,851,1,852,1,852,3,852,11714,8,852,1,852,1,852, - 1,853,1,853,3,853,11720,8,853,1,853,1,853,1,854,1,854,3,854,11726, - 8,854,1,854,1,854,1,855,1,855,1,855,1,855,1,855,1,855,1,855,1,855, - 1,855,3,855,11739,8,855,1,855,3,855,11742,8,855,1,856,1,856,3,856, - 11746,8,856,1,857,1,857,1,857,3,857,11751,8,857,1,858,4,858,11754, - 8,858,11,858,12,858,11755,1,859,1,859,1,859,1,859,1,859,1,860,1, - 860,1,860,5,860,11766,8,860,10,860,12,860,11769,9,860,1,861,1,861, - 1,861,3,861,11774,8,861,1,862,1,862,3,862,11778,8,862,1,863,1,863, - 3,863,11782,8,863,1,864,1,864,3,864,11786,8,864,1,865,1,865,1,865, - 1,866,1,866,3,866,11793,8,866,1,867,1,867,1,868,3,868,11798,8,868, - 1,868,3,868,11801,8,868,1,868,3,868,11804,8,868,1,868,3,868,11807, - 8,868,1,868,3,868,11810,8,868,1,868,3,868,11813,8,868,1,868,3,868, - 11816,8,868,1,869,1,869,1,870,1,870,1,871,1,871,1,872,1,872,1,873, - 1,873,3,873,11828,8,873,1,874,1,874,1,874,1,874,1,874,0,1,1252,875, - 0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44, - 46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88, - 90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,122,124, - 126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156, - 158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188, - 190,192,194,196,198,200,202,204,206,208,210,212,214,216,218,220, - 222,224,226,228,230,232,234,236,238,240,242,244,246,248,250,252, - 254,256,258,260,262,264,266,268,270,272,274,276,278,280,282,284, - 286,288,290,292,294,296,298,300,302,304,306,308,310,312,314,316, - 318,320,322,324,326,328,330,332,334,336,338,340,342,344,346,348, - 350,352,354,356,358,360,362,364,366,368,370,372,374,376,378,380, - 382,384,386,388,390,392,394,396,398,400,402,404,406,408,410,412, - 414,416,418,420,422,424,426,428,430,432,434,436,438,440,442,444, - 446,448,450,452,454,456,458,460,462,464,466,468,470,472,474,476, - 478,480,482,484,486,488,490,492,494,496,498,500,502,504,506,508, - 510,512,514,516,518,520,522,524,526,528,530,532,534,536,538,540, - 542,544,546,548,550,552,554,556,558,560,562,564,566,568,570,572, - 574,576,578,580,582,584,586,588,590,592,594,596,598,600,602,604, - 606,608,610,612,614,616,618,620,622,624,626,628,630,632,634,636, - 638,640,642,644,646,648,650,652,654,656,658,660,662,664,666,668, - 670,672,674,676,678,680,682,684,686,688,690,692,694,696,698,700, - 702,704,706,708,710,712,714,716,718,720,722,724,726,728,730,732, - 734,736,738,740,742,744,746,748,750,752,754,756,758,760,762,764, - 766,768,770,772,774,776,778,780,782,784,786,788,790,792,794,796, - 798,800,802,804,806,808,810,812,814,816,818,820,822,824,826,828, - 830,832,834,836,838,840,842,844,846,848,850,852,854,856,858,860, - 862,864,866,868,870,872,874,876,878,880,882,884,886,888,890,892, - 894,896,898,900,902,904,906,908,910,912,914,916,918,920,922,924, - 926,928,930,932,934,936,938,940,942,944,946,948,950,952,954,956, - 958,960,962,964,966,968,970,972,974,976,978,980,982,984,986,988, - 990,992,994,996,998,1000,1002,1004,1006,1008,1010,1012,1014,1016, - 1018,1020,1022,1024,1026,1028,1030,1032,1034,1036,1038,1040,1042, - 1044,1046,1048,1050,1052,1054,1056,1058,1060,1062,1064,1066,1068, - 1070,1072,1074,1076,1078,1080,1082,1084,1086,1088,1090,1092,1094, - 1096,1098,1100,1102,1104,1106,1108,1110,1112,1114,1116,1118,1120, - 1122,1124,1126,1128,1130,1132,1134,1136,1138,1140,1142,1144,1146, - 1148,1150,1152,1154,1156,1158,1160,1162,1164,1166,1168,1170,1172, - 1174,1176,1178,1180,1182,1184,1186,1188,1190,1192,1194,1196,1198, - 1200,1202,1204,1206,1208,1210,1212,1214,1216,1218,1220,1222,1224, - 1226,1228,1230,1232,1234,1236,1238,1240,1242,1244,1246,1248,1250, - 1252,1254,1256,1258,1260,1262,1264,1266,1268,1270,1272,1274,1276, - 1278,1280,1282,1284,1286,1288,1290,1292,1294,1296,1298,1300,1302, - 1304,1306,1308,1310,1312,1314,1316,1318,1320,1322,1324,1326,1328, - 1330,1332,1334,1336,1338,1340,1342,1344,1346,1348,1350,1352,1354, - 1356,1358,1360,1362,1364,1366,1368,1370,1372,1374,1376,1378,1380, - 1382,1384,1386,1388,1390,1392,1394,1396,1398,1400,1402,1404,1406, - 1408,1410,1412,1414,1416,1418,1420,1422,1424,1426,1428,1430,1432, - 1434,1436,1438,1440,1442,1444,1446,1448,1450,1452,1454,1456,1458, - 1460,1462,1464,1466,1468,1470,1472,1474,1476,1478,1480,1482,1484, - 1486,1488,1490,1492,1494,1496,1498,1500,1502,1504,1506,1508,1510, - 1512,1514,1516,1518,1520,1522,1524,1526,1528,1530,1532,1534,1536, - 1538,1540,1542,1544,1546,1548,1550,1552,1554,1556,1558,1560,1562, - 1564,1566,1568,1570,1572,1574,1576,1578,1580,1582,1584,1586,1588, - 1590,1592,1594,1596,1598,1600,1602,1604,1606,1608,1610,1612,1614, - 1616,1618,1620,1622,1624,1626,1628,1630,1632,1634,1636,1638,1640, - 1642,1644,1646,1648,1650,1652,1654,1656,1658,1660,1662,1664,1666, - 1668,1670,1672,1674,1676,1678,1680,1682,1684,1686,1688,1690,1692, - 1694,1696,1698,1700,1702,1704,1706,1708,1710,1712,1714,1716,1718, - 1720,1722,1724,1726,1728,1730,1732,1734,1736,1738,1740,1742,1744, - 1746,1748,0,87,2,0,195,195,364,364,1,0,228,229,1,0,236,237,1,0,234, - 235,1,0,232,233,1,0,230,231,1,0,535,536,1,0,537,538,1,0,539,540, - 2,0,66,66,318,318,2,0,99,99,318,318,1,0,529,531,2,0,10,10,94,94, - 2,0,133,133,191,191,2,0,254,254,332,332,2,0,162,162,363,363,2,0, - 180,180,221,221,5,0,30,30,288,288,329,329,352,352,354,354,2,0,109, - 109,532,532,2,0,367,367,439,439,2,0,139,139,312,312,2,0,191,191, - 333,333,2,0,313,313,333,333,2,0,150,150,315,315,2,0,64,64,94,94, - 2,0,352,352,354,354,2,0,200,200,224,224,9,0,30,30,160,160,165,165, - 179,179,219,219,227,227,342,342,345,345,438,438,3,0,113,113,284, - 284,336,336,2,0,53,53,78,78,3,0,173,173,260,260,262,262,2,0,9,9, - 94,94,5,0,30,30,88,88,182,182,241,241,369,369,2,0,92,92,226,226, - 2,0,341,341,414,414,1,0,448,449,2,0,92,92,414,414,2,0,135,135,145, - 145,3,0,66,66,99,99,318,318,4,0,163,163,185,185,283,283,353,353, - 3,0,321,321,357,357,445,445,2,0,167,167,314,314,2,0,64,64,68,68, - 10,0,46,46,88,88,182,182,202,202,241,241,352,352,354,354,357,358, - 369,369,521,523,5,0,212,212,329,329,350,350,361,361,455,456,2,0, - 37,37,55,55,2,0,10,10,53,53,4,0,88,88,182,182,241,241,369,369,2, - 0,137,137,242,242,2,0,356,356,380,380,2,0,151,151,254,254,1,0,31, - 32,2,0,60,60,96,96,2,0,99,99,349,349,2,0,201,201,334,334,1,0,527, - 528,2,0,213,213,254,254,2,0,30,30,56,56,2,0,320,320,414,414,2,0, - 207,207,268,268,4,0,113,113,115,115,119,119,126,126,2,0,360,360, - 477,477,2,0,391,392,406,406,1,0,391,392,1,0,418,419,1,0,18,19,2, - 0,117,117,122,122,5,0,10,10,16,17,21,21,23,23,25,25,1,0,12,13,3, - 0,9,9,14,14,27,27,3,0,39,39,73,73,95,95,2,0,166,166,188,188,2,0, - 304,304,450,450,2,0,208,208,289,289,3,0,30,30,34,34,90,90,6,0,9, - 10,12,17,21,21,23,23,25,25,27,27,2,0,20,20,22,22,1,0,483,486,10, - 0,124,124,129,228,238,386,433,452,455,469,471,471,473,473,475,475, - 478,488,547,548,3,0,106,123,125,128,472,472,4,0,30,52,54,70,72,105, - 454,454,2,0,62,62,116,116,2,0,10,10,20,20,2,0,167,167,507,507,1, - 0,512,517,2,0,144,144,210,210,36,0,33,33,35,35,43,43,45,45,53,53, - 57,57,61,61,116,116,123,123,130,130,144,144,153,153,157,157,161, - 161,167,167,172,172,207,207,210,210,241,241,249,249,265,265,268, - 269,279,279,293,293,307,307,313,313,319,319,323,324,333,333,360, - 360,433,434,477,477,490,502,504,504,506,518,520,520,13157,0,1753, - 1,0,0,0,2,1758,1,0,0,0,4,1760,1,0,0,0,6,1881,1,0,0,0,8,1883,1,0, - 0,0,10,1887,1,0,0,0,12,1890,1,0,0,0,14,1898,1,0,0,0,16,1903,1,0, - 0,0,18,1909,1,0,0,0,20,1947,1,0,0,0,22,1959,1,0,0,0,24,1961,1,0, - 0,0,26,1969,1,0,0,0,28,1981,1,0,0,0,30,1983,1,0,0,0,32,1992,1,0, - 0,0,34,2020,1,0,0,0,36,2022,1,0,0,0,38,2070,1,0,0,0,40,2072,1,0, - 0,0,42,2080,1,0,0,0,44,2087,1,0,0,0,46,2089,1,0,0,0,48,2104,1,0, - 0,0,50,2111,1,0,0,0,52,2120,1,0,0,0,54,2122,1,0,0,0,56,2136,1,0, - 0,0,58,2140,1,0,0,0,60,2176,1,0,0,0,62,2178,1,0,0,0,64,2186,1,0, - 0,0,66,2196,1,0,0,0,68,2203,1,0,0,0,70,2209,1,0,0,0,72,2215,1,0, - 0,0,74,2233,1,0,0,0,76,2237,1,0,0,0,78,2241,1,0,0,0,80,2245,1,0, - 0,0,82,2247,1,0,0,0,84,2258,1,0,0,0,86,2262,1,0,0,0,88,2267,1,0, - 0,0,90,2272,1,0,0,0,92,2274,1,0,0,0,94,2286,1,0,0,0,96,2293,1,0, - 0,0,98,2295,1,0,0,0,100,2297,1,0,0,0,102,2299,1,0,0,0,104,2435,1, - 0,0,0,106,2437,1,0,0,0,108,2454,1,0,0,0,110,2456,1,0,0,0,112,2470, - 1,0,0,0,114,2472,1,0,0,0,116,2488,1,0,0,0,118,2490,1,0,0,0,120,2711, - 1,0,0,0,122,2718,1,0,0,0,124,2720,1,0,0,0,126,2722,1,0,0,0,128,2725, - 1,0,0,0,130,2734,1,0,0,0,132,2736,1,0,0,0,134,2740,1,0,0,0,136,2743, - 1,0,0,0,138,2751,1,0,0,0,140,2763,1,0,0,0,142,2780,1,0,0,0,144,2808, - 1,0,0,0,146,2810,1,0,0,0,148,2813,1,0,0,0,150,2821,1,0,0,0,152,2826, - 1,0,0,0,154,2863,1,0,0,0,156,2865,1,0,0,0,158,2907,1,0,0,0,160,2909, - 1,0,0,0,162,2911,1,0,0,0,164,2916,1,0,0,0,166,2923,1,0,0,0,168,2928, - 1,0,0,0,170,2970,1,0,0,0,172,2972,1,0,0,0,174,2975,1,0,0,0,176,2980, - 1,0,0,0,178,2982,1,0,0,0,180,2990,1,0,0,0,182,3001,1,0,0,0,184,3003, - 1,0,0,0,186,3011,1,0,0,0,188,3013,1,0,0,0,190,3096,1,0,0,0,192,3098, - 1,0,0,0,194,3100,1,0,0,0,196,3102,1,0,0,0,198,3106,1,0,0,0,200,3114, - 1,0,0,0,202,3125,1,0,0,0,204,3129,1,0,0,0,206,3131,1,0,0,0,208,3152, - 1,0,0,0,210,3155,1,0,0,0,212,3164,1,0,0,0,214,3174,1,0,0,0,216,3195, - 1,0,0,0,218,3255,1,0,0,0,220,3257,1,0,0,0,222,3266,1,0,0,0,224,3271, - 1,0,0,0,226,3273,1,0,0,0,228,3276,1,0,0,0,230,3284,1,0,0,0,232,3287, - 1,0,0,0,234,3294,1,0,0,0,236,3382,1,0,0,0,238,3384,1,0,0,0,240,3387, - 1,0,0,0,242,3391,1,0,0,0,244,3395,1,0,0,0,246,3403,1,0,0,0,248,3411, - 1,0,0,0,250,3416,1,0,0,0,252,3419,1,0,0,0,254,3427,1,0,0,0,256,3437, - 1,0,0,0,258,3450,1,0,0,0,260,3452,1,0,0,0,262,3456,1,0,0,0,264,3469, - 1,0,0,0,266,3471,1,0,0,0,268,3476,1,0,0,0,270,3478,1,0,0,0,272,3485, - 1,0,0,0,274,3516,1,0,0,0,276,3518,1,0,0,0,278,3527,1,0,0,0,280,3529, - 1,0,0,0,282,3538,1,0,0,0,284,3542,1,0,0,0,286,3550,1,0,0,0,288,3555, - 1,0,0,0,290,3559,1,0,0,0,292,3578,1,0,0,0,294,3588,1,0,0,0,296,3602, - 1,0,0,0,298,3618,1,0,0,0,300,3624,1,0,0,0,302,3639,1,0,0,0,304,3652, - 1,0,0,0,306,3654,1,0,0,0,308,3664,1,0,0,0,310,3676,1,0,0,0,312,3684, - 1,0,0,0,314,3686,1,0,0,0,316,3691,1,0,0,0,318,3729,1,0,0,0,320,3731, - 1,0,0,0,322,3739,1,0,0,0,324,3741,1,0,0,0,326,3749,1,0,0,0,328,3771, - 1,0,0,0,330,3773,1,0,0,0,332,3777,1,0,0,0,334,3784,1,0,0,0,336,3786, - 1,0,0,0,338,3788,1,0,0,0,340,3790,1,0,0,0,342,3801,1,0,0,0,344,3804, - 1,0,0,0,346,3818,1,0,0,0,348,3828,1,0,0,0,350,3830,1,0,0,0,352,3839, - 1,0,0,0,354,3842,1,0,0,0,356,3947,1,0,0,0,358,3949,1,0,0,0,360,3968, - 1,0,0,0,362,3971,1,0,0,0,364,3975,1,0,0,0,366,3994,1,0,0,0,368,3996, - 1,0,0,0,370,4001,1,0,0,0,372,4009,1,0,0,0,374,4014,1,0,0,0,376,4029, - 1,0,0,0,378,4031,1,0,0,0,380,4034,1,0,0,0,382,4036,1,0,0,0,384,4038, - 1,0,0,0,386,4057,1,0,0,0,388,4060,1,0,0,0,390,4065,1,0,0,0,392,4067, - 1,0,0,0,394,4116,1,0,0,0,396,4118,1,0,0,0,398,4136,1,0,0,0,400,4138, - 1,0,0,0,402,4143,1,0,0,0,404,4158,1,0,0,0,406,4160,1,0,0,0,408,4169, - 1,0,0,0,410,4189,1,0,0,0,412,4203,1,0,0,0,414,4237,1,0,0,0,416,4267, - 1,0,0,0,418,4269,1,0,0,0,420,4274,1,0,0,0,422,4280,1,0,0,0,424,4283, - 1,0,0,0,426,4286,1,0,0,0,428,4292,1,0,0,0,430,4295,1,0,0,0,432,4297, - 1,0,0,0,434,4306,1,0,0,0,436,4362,1,0,0,0,438,4368,1,0,0,0,440,4370, - 1,0,0,0,442,4376,1,0,0,0,444,4378,1,0,0,0,446,4393,1,0,0,0,448,4395, - 1,0,0,0,450,4399,1,0,0,0,452,4403,1,0,0,0,454,4410,1,0,0,0,456,4412, - 1,0,0,0,458,4414,1,0,0,0,460,4416,1,0,0,0,462,4422,1,0,0,0,464,4424, - 1,0,0,0,466,4426,1,0,0,0,468,4435,1,0,0,0,470,4439,1,0,0,0,472,4452, - 1,0,0,0,474,4454,1,0,0,0,476,4460,1,0,0,0,478,4474,1,0,0,0,480,4500, - 1,0,0,0,482,4502,1,0,0,0,484,4510,1,0,0,0,486,4516,1,0,0,0,488,4524, - 1,0,0,0,490,4535,1,0,0,0,492,4537,1,0,0,0,494,4649,1,0,0,0,496,4651, - 1,0,0,0,498,4655,1,0,0,0,500,4663,1,0,0,0,502,4674,1,0,0,0,504,4676, - 1,0,0,0,506,4680,1,0,0,0,508,4688,1,0,0,0,510,4692,1,0,0,0,512,4694, - 1,0,0,0,514,4724,1,0,0,0,516,4726,1,0,0,0,518,4730,1,0,0,0,520,4748, - 1,0,0,0,522,4787,1,0,0,0,524,4789,1,0,0,0,526,4791,1,0,0,0,528,4800, - 1,0,0,0,530,4802,1,0,0,0,532,4804,1,0,0,0,534,4829,1,0,0,0,536,4831, - 1,0,0,0,538,4851,1,0,0,0,540,4853,1,0,0,0,542,5239,1,0,0,0,544,5241, - 1,0,0,0,546,5273,1,0,0,0,548,5306,1,0,0,0,550,5308,1,0,0,0,552,5310, - 1,0,0,0,554,5318,1,0,0,0,556,5322,1,0,0,0,558,5326,1,0,0,0,560,5332, - 1,0,0,0,562,5336,1,0,0,0,564,5344,1,0,0,0,566,5364,1,0,0,0,568,5535, - 1,0,0,0,570,5539,1,0,0,0,572,5650,1,0,0,0,574,5652,1,0,0,0,576,5657, - 1,0,0,0,578,5663,1,0,0,0,580,5750,1,0,0,0,582,5752,1,0,0,0,584,5754, - 1,0,0,0,586,5756,1,0,0,0,588,5786,1,0,0,0,590,5804,1,0,0,0,592,5806, - 1,0,0,0,594,5814,1,0,0,0,596,5816,1,0,0,0,598,5840,1,0,0,0,600,5900, - 1,0,0,0,602,5902,1,0,0,0,604,5913,1,0,0,0,606,5915,1,0,0,0,608,5919, - 1,0,0,0,610,5952,1,0,0,0,612,5954,1,0,0,0,614,5958,1,0,0,0,616,5962, - 1,0,0,0,618,5971,1,0,0,0,620,5983,1,0,0,0,622,6015,1,0,0,0,624,6017, - 1,0,0,0,626,6019,1,0,0,0,628,6056,1,0,0,0,630,6058,1,0,0,0,632,6060, - 1,0,0,0,634,6062,1,0,0,0,636,6065,1,0,0,0,638,6096,1,0,0,0,640,6109, - 1,0,0,0,642,6111,1,0,0,0,644,6116,1,0,0,0,646,6124,1,0,0,0,648,6127, - 1,0,0,0,650,6129,1,0,0,0,652,6135,1,0,0,0,654,6137,1,0,0,0,656,6164, - 1,0,0,0,658,6175,1,0,0,0,660,6178,1,0,0,0,662,6184,1,0,0,0,664,6192, - 1,0,0,0,666,6208,1,0,0,0,668,6210,1,0,0,0,670,6226,1,0,0,0,672,6228, - 1,0,0,0,674,6244,1,0,0,0,676,6246,1,0,0,0,678,6252,1,0,0,0,680,6273, - 1,0,0,0,682,6282,1,0,0,0,684,6284,1,0,0,0,686,6286,1,0,0,0,688,6300, - 1,0,0,0,690,6302,1,0,0,0,692,6307,1,0,0,0,694,6309,1,0,0,0,696,6324, - 1,0,0,0,698,6332,1,0,0,0,700,6335,1,0,0,0,702,6344,1,0,0,0,704,6383, - 1,0,0,0,706,6410,1,0,0,0,708,6412,1,0,0,0,710,6424,1,0,0,0,712,6427, - 1,0,0,0,714,6430,1,0,0,0,716,6438,1,0,0,0,718,6450,1,0,0,0,720,6453, - 1,0,0,0,722,6457,1,0,0,0,724,6486,1,0,0,0,726,6488,1,0,0,0,728,6497, - 1,0,0,0,730,6528,1,0,0,0,732,6535,1,0,0,0,734,6540,1,0,0,0,736,6548, - 1,0,0,0,738,6551,1,0,0,0,740,6555,1,0,0,0,742,6562,1,0,0,0,744,6601, - 1,0,0,0,746,6607,1,0,0,0,748,6609,1,0,0,0,750,6612,1,0,0,0,752,6659, - 1,0,0,0,754,6677,1,0,0,0,756,6689,1,0,0,0,758,6706,1,0,0,0,760,6708, - 1,0,0,0,762,6716,1,0,0,0,764,6730,1,0,0,0,766,7123,1,0,0,0,768,7125, - 1,0,0,0,770,7197,1,0,0,0,772,7199,1,0,0,0,774,7386,1,0,0,0,776,7388, - 1,0,0,0,778,7396,1,0,0,0,780,7412,1,0,0,0,782,7419,1,0,0,0,784,7421, - 1,0,0,0,786,7614,1,0,0,0,788,7616,1,0,0,0,790,7625,1,0,0,0,792,7633, - 1,0,0,0,794,7673,1,0,0,0,796,7675,1,0,0,0,798,7685,1,0,0,0,800,7693, - 1,0,0,0,802,7773,1,0,0,0,804,7775,1,0,0,0,806,7801,1,0,0,0,808,7804, - 1,0,0,0,810,7820,1,0,0,0,812,7822,1,0,0,0,814,7824,1,0,0,0,816,7826, - 1,0,0,0,818,7828,1,0,0,0,820,7833,1,0,0,0,822,7836,1,0,0,0,824,7843, - 1,0,0,0,826,7910,1,0,0,0,828,7912,1,0,0,0,830,7924,1,0,0,0,832,7926, - 1,0,0,0,834,7936,1,0,0,0,836,7938,1,0,0,0,838,7944,1,0,0,0,840,7976, - 1,0,0,0,842,7983,1,0,0,0,844,7986,1,0,0,0,846,7995,1,0,0,0,848,7998, - 1,0,0,0,850,8002,1,0,0,0,852,8019,1,0,0,0,854,8021,1,0,0,0,856,8023, - 1,0,0,0,858,8039,1,0,0,0,860,8045,1,0,0,0,862,8053,1,0,0,0,864,8055, - 1,0,0,0,866,8061,1,0,0,0,868,8066,1,0,0,0,870,8075,1,0,0,0,872,8101, - 1,0,0,0,874,8103,1,0,0,0,876,8173,1,0,0,0,878,8175,1,0,0,0,880,8177, - 1,0,0,0,882,8208,1,0,0,0,884,8210,1,0,0,0,886,8221,1,0,0,0,888,8250, - 1,0,0,0,890,8266,1,0,0,0,892,8268,1,0,0,0,894,8276,1,0,0,0,896,8278, - 1,0,0,0,898,8284,1,0,0,0,900,8288,1,0,0,0,902,8290,1,0,0,0,904,8292, - 1,0,0,0,906,8303,1,0,0,0,908,8305,1,0,0,0,910,8309,1,0,0,0,912,8313, - 1,0,0,0,914,8318,1,0,0,0,916,8320,1,0,0,0,918,8322,1,0,0,0,920,8326, - 1,0,0,0,922,8330,1,0,0,0,924,8338,1,0,0,0,926,8358,1,0,0,0,928,8369, - 1,0,0,0,930,8371,1,0,0,0,932,8379,1,0,0,0,934,8385,1,0,0,0,936,8389, - 1,0,0,0,938,8391,1,0,0,0,940,8399,1,0,0,0,942,8407,1,0,0,0,944,8432, - 1,0,0,0,946,8434,1,0,0,0,948,8438,1,0,0,0,950,8447,1,0,0,0,952,8459, - 1,0,0,0,954,8468,1,0,0,0,956,8480,1,0,0,0,958,8482,1,0,0,0,960,8490, - 1,0,0,0,962,8493,1,0,0,0,964,8517,1,0,0,0,966,8519,1,0,0,0,968,8523, - 1,0,0,0,970,8537,1,0,0,0,972,8540,1,0,0,0,974,8551,1,0,0,0,976,8567, - 1,0,0,0,978,8569,1,0,0,0,980,8574,1,0,0,0,982,8577,1,0,0,0,984,8592, - 1,0,0,0,986,8618,1,0,0,0,988,8620,1,0,0,0,990,8623,1,0,0,0,992,8631, - 1,0,0,0,994,8639,1,0,0,0,996,8648,1,0,0,0,998,8656,1,0,0,0,1000, - 8660,1,0,0,0,1002,8670,1,0,0,0,1004,8701,1,0,0,0,1006,8705,1,0,0, - 0,1008,8752,1,0,0,0,1010,8767,1,0,0,0,1012,8769,1,0,0,0,1014,8773, - 1,0,0,0,1016,8779,1,0,0,0,1018,8787,1,0,0,0,1020,8804,1,0,0,0,1022, - 8812,1,0,0,0,1024,8829,1,0,0,0,1026,8831,1,0,0,0,1028,8833,1,0,0, - 0,1030,8842,1,0,0,0,1032,8860,1,0,0,0,1034,8862,1,0,0,0,1036,8864, - 1,0,0,0,1038,8866,1,0,0,0,1040,8874,1,0,0,0,1042,8876,1,0,0,0,1044, - 8878,1,0,0,0,1046,8882,1,0,0,0,1048,8890,1,0,0,0,1050,8911,1,0,0, - 0,1052,8913,1,0,0,0,1054,8915,1,0,0,0,1056,8921,1,0,0,0,1058,8938, - 1,0,0,0,1060,8947,1,0,0,0,1062,8949,1,0,0,0,1064,8956,1,0,0,0,1066, - 8960,1,0,0,0,1068,8962,1,0,0,0,1070,8964,1,0,0,0,1072,8966,1,0,0, - 0,1074,8973,1,0,0,0,1076,8990,1,0,0,0,1078,8992,1,0,0,0,1080,8995, - 1,0,0,0,1082,9000,1,0,0,0,1084,9005,1,0,0,0,1086,9011,1,0,0,0,1088, - 9018,1,0,0,0,1090,9020,1,0,0,0,1092,9023,1,0,0,0,1094,9027,1,0,0, - 0,1096,9034,1,0,0,0,1098,9046,1,0,0,0,1100,9049,1,0,0,0,1102,9063, - 1,0,0,0,1104,9066,1,0,0,0,1106,9135,1,0,0,0,1108,9159,1,0,0,0,1110, - 9168,1,0,0,0,1112,9182,1,0,0,0,1114,9184,1,0,0,0,1116,9195,1,0,0, - 0,1118,9218,1,0,0,0,1120,9221,1,0,0,0,1122,9266,1,0,0,0,1124,9268, - 1,0,0,0,1126,9276,1,0,0,0,1128,9284,1,0,0,0,1130,9291,1,0,0,0,1132, - 9299,1,0,0,0,1134,9316,1,0,0,0,1136,9318,1,0,0,0,1138,9322,1,0,0, - 0,1140,9330,1,0,0,0,1142,9335,1,0,0,0,1144,9338,1,0,0,0,1146,9341, - 1,0,0,0,1148,9348,1,0,0,0,1150,9350,1,0,0,0,1152,9358,1,0,0,0,1154, - 9363,1,0,0,0,1156,9384,1,0,0,0,1158,9392,1,0,0,0,1160,9402,1,0,0, - 0,1162,9414,1,0,0,0,1164,9416,1,0,0,0,1166,9430,1,0,0,0,1168,9450, - 1,0,0,0,1170,9459,1,0,0,0,1172,9477,1,0,0,0,1174,9483,1,0,0,0,1176, - 9485,1,0,0,0,1178,9492,1,0,0,0,1180,9520,1,0,0,0,1182,9522,1,0,0, - 0,1184,9528,1,0,0,0,1186,9532,1,0,0,0,1188,9534,1,0,0,0,1190,9542, - 1,0,0,0,1192,9546,1,0,0,0,1194,9553,1,0,0,0,1196,9570,1,0,0,0,1198, - 9572,1,0,0,0,1200,9574,1,0,0,0,1202,9584,1,0,0,0,1204,9592,1,0,0, - 0,1206,9619,1,0,0,0,1208,9621,1,0,0,0,1210,9628,1,0,0,0,1212,9631, - 1,0,0,0,1214,9633,1,0,0,0,1216,9637,1,0,0,0,1218,9645,1,0,0,0,1220, - 9653,1,0,0,0,1222,9661,1,0,0,0,1224,9670,1,0,0,0,1226,9674,1,0,0, - 0,1228,9678,1,0,0,0,1230,9704,1,0,0,0,1232,9718,1,0,0,0,1234,9738, - 1,0,0,0,1236,9748,1,0,0,0,1238,9752,1,0,0,0,1240,9760,1,0,0,0,1242, - 9768,1,0,0,0,1244,9774,1,0,0,0,1246,9778,1,0,0,0,1248,9785,1,0,0, - 0,1250,9790,1,0,0,0,1252,9805,1,0,0,0,1254,9885,1,0,0,0,1256,9887, - 1,0,0,0,1258,9889,1,0,0,0,1260,9928,1,0,0,0,1262,9932,1,0,0,0,1264, - 10118,1,0,0,0,1266,10125,1,0,0,0,1268,10137,1,0,0,0,1270,10139,1, - 0,0,0,1272,10144,1,0,0,0,1274,10152,1,0,0,0,1276,10157,1,0,0,0,1278, - 10163,1,0,0,0,1280,10180,1,0,0,0,1282,10182,1,0,0,0,1284,10185,1, - 0,0,0,1286,10191,1,0,0,0,1288,10197,1,0,0,0,1290,10200,1,0,0,0,1292, - 10208,1,0,0,0,1294,10212,1,0,0,0,1296,10217,1,0,0,0,1298,10232,1, - 0,0,0,1300,10234,1,0,0,0,1302,10253,1,0,0,0,1304,10261,1,0,0,0,1306, - 10270,1,0,0,0,1308,10272,1,0,0,0,1310,10293,1,0,0,0,1312,10295,1, - 0,0,0,1314,10302,1,0,0,0,1316,10308,1,0,0,0,1318,10312,1,0,0,0,1320, - 10314,1,0,0,0,1322,10322,1,0,0,0,1324,10330,1,0,0,0,1326,10344,1, - 0,0,0,1328,10346,1,0,0,0,1330,10354,1,0,0,0,1332,10362,1,0,0,0,1334, - 10375,1,0,0,0,1336,10379,1,0,0,0,1338,10381,1,0,0,0,1340,10394,1, - 0,0,0,1342,10396,1,0,0,0,1344,10404,1,0,0,0,1346,10411,1,0,0,0,1348, - 10419,1,0,0,0,1350,10431,1,0,0,0,1352,10433,1,0,0,0,1354,10435,1, - 0,0,0,1356,10444,1,0,0,0,1358,10475,1,0,0,0,1360,10484,1,0,0,0,1362, - 10491,1,0,0,0,1364,10493,1,0,0,0,1366,10504,1,0,0,0,1368,10508,1, - 0,0,0,1370,10513,1,0,0,0,1372,10516,1,0,0,0,1374,10518,1,0,0,0,1376, - 10539,1,0,0,0,1378,10541,1,0,0,0,1380,10544,1,0,0,0,1382,10551,1, - 0,0,0,1384,10554,1,0,0,0,1386,10556,1,0,0,0,1388,10572,1,0,0,0,1390, - 10574,1,0,0,0,1392,10582,1,0,0,0,1394,10590,1,0,0,0,1396,10598,1, - 0,0,0,1398,10606,1,0,0,0,1400,10614,1,0,0,0,1402,10618,1,0,0,0,1404, - 10622,1,0,0,0,1406,10626,1,0,0,0,1408,10630,1,0,0,0,1410,10634,1, - 0,0,0,1412,10638,1,0,0,0,1414,10642,1,0,0,0,1416,10650,1,0,0,0,1418, - 10658,1,0,0,0,1420,10662,1,0,0,0,1422,10666,1,0,0,0,1424,10670,1, - 0,0,0,1426,10672,1,0,0,0,1428,10678,1,0,0,0,1430,10684,1,0,0,0,1432, - 10694,1,0,0,0,1434,10696,1,0,0,0,1436,10698,1,0,0,0,1438,10700,1, - 0,0,0,1440,10702,1,0,0,0,1442,10708,1,0,0,0,1444,10714,1,0,0,0,1446, - 10720,1,0,0,0,1448,10757,1,0,0,0,1450,10759,1,0,0,0,1452,10761,1, - 0,0,0,1454,10763,1,0,0,0,1456,10765,1,0,0,0,1458,10767,1,0,0,0,1460, - 10782,1,0,0,0,1462,10784,1,0,0,0,1464,10792,1,0,0,0,1466,10794,1, - 0,0,0,1468,10796,1,0,0,0,1470,10803,1,0,0,0,1472,10805,1,0,0,0,1474, - 10817,1,0,0,0,1476,10819,1,0,0,0,1478,10833,1,0,0,0,1480,10837,1, - 0,0,0,1482,10846,1,0,0,0,1484,10852,1,0,0,0,1486,10856,1,0,0,0,1488, - 10862,1,0,0,0,1490,10870,1,0,0,0,1492,10882,1,0,0,0,1494,10884,1, - 0,0,0,1496,10886,1,0,0,0,1498,10939,1,0,0,0,1500,10941,1,0,0,0,1502, - 10943,1,0,0,0,1504,10945,1,0,0,0,1506,10952,1,0,0,0,1508,10975,1, - 0,0,0,1510,10977,1,0,0,0,1512,10983,1,0,0,0,1514,10987,1,0,0,0,1516, - 10989,1,0,0,0,1518,10996,1,0,0,0,1520,11003,1,0,0,0,1522,11006,1, - 0,0,0,1524,11010,1,0,0,0,1526,11017,1,0,0,0,1528,11019,1,0,0,0,1530, - 11043,1,0,0,0,1532,11045,1,0,0,0,1534,11052,1,0,0,0,1536,11054,1, - 0,0,0,1538,11062,1,0,0,0,1540,11065,1,0,0,0,1542,11069,1,0,0,0,1544, - 11071,1,0,0,0,1546,11075,1,0,0,0,1548,11077,1,0,0,0,1550,11082,1, - 0,0,0,1552,11087,1,0,0,0,1554,11093,1,0,0,0,1556,11097,1,0,0,0,1558, - 11099,1,0,0,0,1560,11104,1,0,0,0,1562,11134,1,0,0,0,1564,11136,1, - 0,0,0,1566,11156,1,0,0,0,1568,11160,1,0,0,0,1570,11162,1,0,0,0,1572, - 11167,1,0,0,0,1574,11176,1,0,0,0,1576,11178,1,0,0,0,1578,11186,1, - 0,0,0,1580,11190,1,0,0,0,1582,11192,1,0,0,0,1584,11196,1,0,0,0,1586, - 11207,1,0,0,0,1588,11224,1,0,0,0,1590,11230,1,0,0,0,1592,11232,1, - 0,0,0,1594,11242,1,0,0,0,1596,11245,1,0,0,0,1598,11249,1,0,0,0,1600, - 11257,1,0,0,0,1602,11259,1,0,0,0,1604,11262,1,0,0,0,1606,11267,1, - 0,0,0,1608,11272,1,0,0,0,1610,11294,1,0,0,0,1612,11308,1,0,0,0,1614, - 11312,1,0,0,0,1616,11317,1,0,0,0,1618,11319,1,0,0,0,1620,11321,1, - 0,0,0,1622,11333,1,0,0,0,1624,11335,1,0,0,0,1626,11342,1,0,0,0,1628, - 11344,1,0,0,0,1630,11362,1,0,0,0,1632,11398,1,0,0,0,1634,11400,1, - 0,0,0,1636,11409,1,0,0,0,1638,11414,1,0,0,0,1640,11416,1,0,0,0,1642, - 11420,1,0,0,0,1644,11428,1,0,0,0,1646,11436,1,0,0,0,1648,11438,1, - 0,0,0,1650,11445,1,0,0,0,1652,11448,1,0,0,0,1654,11464,1,0,0,0,1656, - 11466,1,0,0,0,1658,11480,1,0,0,0,1660,11482,1,0,0,0,1662,11509,1, - 0,0,0,1664,11511,1,0,0,0,1666,11522,1,0,0,0,1668,11528,1,0,0,0,1670, - 11532,1,0,0,0,1672,11534,1,0,0,0,1674,11544,1,0,0,0,1676,11549,1, - 0,0,0,1678,11566,1,0,0,0,1680,11568,1,0,0,0,1682,11576,1,0,0,0,1684, - 11613,1,0,0,0,1686,11621,1,0,0,0,1688,11649,1,0,0,0,1690,11651,1, - 0,0,0,1692,11665,1,0,0,0,1694,11687,1,0,0,0,1696,11689,1,0,0,0,1698, - 11702,1,0,0,0,1700,11704,1,0,0,0,1702,11708,1,0,0,0,1704,11711,1, - 0,0,0,1706,11717,1,0,0,0,1708,11723,1,0,0,0,1710,11741,1,0,0,0,1712, - 11745,1,0,0,0,1714,11750,1,0,0,0,1716,11753,1,0,0,0,1718,11757,1, - 0,0,0,1720,11762,1,0,0,0,1722,11773,1,0,0,0,1724,11777,1,0,0,0,1726, - 11781,1,0,0,0,1728,11785,1,0,0,0,1730,11787,1,0,0,0,1732,11792,1, - 0,0,0,1734,11794,1,0,0,0,1736,11797,1,0,0,0,1738,11817,1,0,0,0,1740, - 11819,1,0,0,0,1742,11821,1,0,0,0,1744,11823,1,0,0,0,1746,11825,1, - 0,0,0,1748,11829,1,0,0,0,1750,1752,3,4,2,0,1751,1750,1,0,0,0,1752, - 1755,1,0,0,0,1753,1751,1,0,0,0,1753,1754,1,0,0,0,1754,1756,1,0,0, - 0,1755,1753,1,0,0,0,1756,1757,5,0,0,1,1757,1,1,0,0,0,1758,1759,3, - 1504,752,0,1759,3,1,0,0,0,1760,1762,3,6,3,0,1761,1763,5,7,0,0,1762, - 1761,1,0,0,0,1762,1763,1,0,0,0,1763,5,1,0,0,0,1764,1882,3,488,244, - 0,1765,1882,3,864,432,0,1766,1882,3,856,428,0,1767,1882,3,858,429, - 0,1768,1882,3,616,308,0,1769,1882,3,870,435,0,1770,1882,3,514,257, - 0,1771,1882,3,350,175,0,1772,1882,3,356,178,0,1773,1882,3,366,183, - 0,1774,1882,3,392,196,0,1775,1882,3,716,358,0,1776,1882,3,42,21, - 0,1777,1882,3,770,385,0,1778,1882,3,774,387,0,1779,1882,3,786,393, - 0,1780,1882,3,776,388,0,1781,1882,3,784,392,0,1782,1882,3,410,205, - 0,1783,1882,3,412,206,0,1784,1882,3,310,155,0,1785,1882,3,866,433, - 0,1786,1882,3,104,52,0,1787,1882,3,764,382,0,1788,1882,3,150,75, - 0,1789,1882,3,794,397,0,1790,1882,3,30,15,0,1791,1882,3,32,16,0, - 1792,1882,3,26,13,0,1793,1882,3,802,401,0,1794,1882,3,292,146,0, - 1795,1882,3,876,438,0,1796,1882,3,874,437,0,1797,1882,3,406,203, - 0,1798,1882,3,890,445,0,1799,1882,3,10,5,0,1800,1882,3,100,50,0, - 1801,1882,3,156,78,0,1802,1882,3,882,441,0,1803,1882,3,568,284,0, - 1804,1882,3,94,47,0,1805,1882,3,158,79,0,1806,1882,3,432,216,0,1807, - 1882,3,294,147,0,1808,1882,3,492,246,0,1809,1882,3,744,372,0,1810, - 1882,3,880,440,0,1811,1882,3,868,434,0,1812,1882,3,344,172,0,1813, - 1882,3,358,179,0,1814,1882,3,384,192,0,1815,1882,3,394,197,0,1816, - 1882,3,654,327,0,1817,1882,3,40,20,0,1818,1882,3,300,150,0,1819, - 1882,3,518,259,0,1820,1882,3,532,266,0,1821,1882,3,788,394,0,1822, - 1882,3,534,267,0,1823,1882,3,408,204,0,1824,1882,3,326,163,0,1825, - 1882,3,46,23,0,1826,1882,3,308,154,0,1827,1882,3,188,94,0,1828,1882, - 3,796,398,0,1829,1882,3,290,145,0,1830,1882,3,340,170,0,1831,1882, - 3,750,375,0,1832,1882,3,436,218,0,1833,1882,3,480,240,0,1834,1882, - 3,12,6,0,1835,1882,3,24,12,0,1836,1882,3,402,201,0,1837,1882,3,844, - 422,0,1838,1882,3,948,474,0,1839,1882,3,992,496,0,1840,1882,3,494, - 247,0,1841,1882,3,968,484,0,1842,1882,3,102,51,0,1843,1882,3,738, - 369,0,1844,1882,3,542,271,0,1845,1882,3,944,472,0,1846,1882,3,926, - 463,0,1847,1882,3,578,289,0,1848,1882,3,586,293,0,1849,1882,3,608, - 304,0,1850,1882,3,1682,841,0,1851,1882,3,396,198,0,1852,1882,3,626, - 313,0,1853,1882,3,950,475,0,1854,1882,3,822,411,0,1855,1882,3,306, - 153,0,1856,1882,3,842,421,0,1857,1882,3,972,486,0,1858,1882,3,818, - 409,0,1859,1882,3,938,469,0,1860,1882,3,540,270,0,1861,1882,3,754, - 377,0,1862,1882,3,726,363,0,1863,1882,3,724,362,0,1864,1882,3,728, - 364,0,1865,1882,3,766,383,0,1866,1882,3,588,294,0,1867,1882,3,610, - 305,0,1868,1882,3,804,402,0,1869,1882,3,572,286,0,1870,1882,3,1000, - 500,0,1871,1882,3,826,413,0,1872,1882,3,564,282,0,1873,1882,3,824, - 412,0,1874,1882,3,982,491,0,1875,1882,3,888,444,0,1876,1882,3,82, - 41,0,1877,1882,3,54,27,0,1878,1882,3,92,46,0,1879,1882,3,838,419, - 0,1880,1882,3,8,4,0,1881,1764,1,0,0,0,1881,1765,1,0,0,0,1881,1766, - 1,0,0,0,1881,1767,1,0,0,0,1881,1768,1,0,0,0,1881,1769,1,0,0,0,1881, - 1770,1,0,0,0,1881,1771,1,0,0,0,1881,1772,1,0,0,0,1881,1773,1,0,0, - 0,1881,1774,1,0,0,0,1881,1775,1,0,0,0,1881,1776,1,0,0,0,1881,1777, - 1,0,0,0,1881,1778,1,0,0,0,1881,1779,1,0,0,0,1881,1780,1,0,0,0,1881, - 1781,1,0,0,0,1881,1782,1,0,0,0,1881,1783,1,0,0,0,1881,1784,1,0,0, - 0,1881,1785,1,0,0,0,1881,1786,1,0,0,0,1881,1787,1,0,0,0,1881,1788, - 1,0,0,0,1881,1789,1,0,0,0,1881,1790,1,0,0,0,1881,1791,1,0,0,0,1881, - 1792,1,0,0,0,1881,1793,1,0,0,0,1881,1794,1,0,0,0,1881,1795,1,0,0, - 0,1881,1796,1,0,0,0,1881,1797,1,0,0,0,1881,1798,1,0,0,0,1881,1799, - 1,0,0,0,1881,1800,1,0,0,0,1881,1801,1,0,0,0,1881,1802,1,0,0,0,1881, - 1803,1,0,0,0,1881,1804,1,0,0,0,1881,1805,1,0,0,0,1881,1806,1,0,0, - 0,1881,1807,1,0,0,0,1881,1808,1,0,0,0,1881,1809,1,0,0,0,1881,1810, - 1,0,0,0,1881,1811,1,0,0,0,1881,1812,1,0,0,0,1881,1813,1,0,0,0,1881, - 1814,1,0,0,0,1881,1815,1,0,0,0,1881,1816,1,0,0,0,1881,1817,1,0,0, - 0,1881,1818,1,0,0,0,1881,1819,1,0,0,0,1881,1820,1,0,0,0,1881,1821, - 1,0,0,0,1881,1822,1,0,0,0,1881,1823,1,0,0,0,1881,1824,1,0,0,0,1881, - 1825,1,0,0,0,1881,1826,1,0,0,0,1881,1827,1,0,0,0,1881,1828,1,0,0, - 0,1881,1829,1,0,0,0,1881,1830,1,0,0,0,1881,1831,1,0,0,0,1881,1832, - 1,0,0,0,1881,1833,1,0,0,0,1881,1834,1,0,0,0,1881,1835,1,0,0,0,1881, - 1836,1,0,0,0,1881,1837,1,0,0,0,1881,1838,1,0,0,0,1881,1839,1,0,0, - 0,1881,1840,1,0,0,0,1881,1841,1,0,0,0,1881,1842,1,0,0,0,1881,1843, - 1,0,0,0,1881,1844,1,0,0,0,1881,1845,1,0,0,0,1881,1846,1,0,0,0,1881, - 1847,1,0,0,0,1881,1848,1,0,0,0,1881,1849,1,0,0,0,1881,1850,1,0,0, - 0,1881,1851,1,0,0,0,1881,1852,1,0,0,0,1881,1853,1,0,0,0,1881,1854, - 1,0,0,0,1881,1855,1,0,0,0,1881,1856,1,0,0,0,1881,1857,1,0,0,0,1881, - 1858,1,0,0,0,1881,1859,1,0,0,0,1881,1860,1,0,0,0,1881,1861,1,0,0, - 0,1881,1862,1,0,0,0,1881,1863,1,0,0,0,1881,1864,1,0,0,0,1881,1865, - 1,0,0,0,1881,1866,1,0,0,0,1881,1867,1,0,0,0,1881,1868,1,0,0,0,1881, - 1869,1,0,0,0,1881,1870,1,0,0,0,1881,1871,1,0,0,0,1881,1872,1,0,0, - 0,1881,1873,1,0,0,0,1881,1874,1,0,0,0,1881,1875,1,0,0,0,1881,1876, - 1,0,0,0,1881,1877,1,0,0,0,1881,1878,1,0,0,0,1881,1879,1,0,0,0,1881, - 1880,1,0,0,0,1882,7,1,0,0,0,1883,1885,5,581,0,0,1884,1886,5,582, - 0,0,1885,1884,1,0,0,0,1885,1886,1,0,0,0,1886,9,1,0,0,0,1887,1888, - 5,433,0,0,1888,1889,3,1258,629,0,1889,11,1,0,0,0,1890,1891,5,46, - 0,0,1891,1892,5,318,0,0,1892,1894,3,1468,734,0,1893,1895,3,14,7, - 0,1894,1893,1,0,0,0,1894,1895,1,0,0,0,1895,1896,1,0,0,0,1896,1897, - 3,16,8,0,1897,13,1,0,0,0,1898,1899,5,105,0,0,1899,15,1,0,0,0,1900, - 1902,3,22,11,0,1901,1900,1,0,0,0,1902,1905,1,0,0,0,1903,1901,1,0, - 0,0,1903,1904,1,0,0,0,1904,17,1,0,0,0,1905,1903,1,0,0,0,1906,1908, - 3,20,10,0,1907,1906,1,0,0,0,1908,1911,1,0,0,0,1909,1907,1,0,0,0, - 1909,1910,1,0,0,0,1910,19,1,0,0,0,1911,1909,1,0,0,0,1912,1915,5, - 287,0,0,1913,1916,3,1458,729,0,1914,1916,5,78,0,0,1915,1913,1,0, - 0,0,1915,1914,1,0,0,0,1916,1948,1,0,0,0,1917,1918,7,0,0,0,1918,1919, - 5,287,0,0,1919,1948,3,1458,729,0,1920,1948,7,1,0,0,1921,1948,7,2, - 0,0,1922,1948,7,3,0,0,1923,1948,7,4,0,0,1924,1948,7,5,0,0,1925,1948, - 7,6,0,0,1926,1948,7,7,0,0,1927,1948,7,8,0,0,1928,1929,5,164,0,0, - 1929,1930,5,74,0,0,1930,1948,3,1464,732,0,1931,1932,5,371,0,0,1932, - 1933,5,368,0,0,1933,1948,3,1458,729,0,1934,1935,5,68,0,0,1935,1936, - 5,318,0,0,1936,1948,3,1416,708,0,1937,1938,5,68,0,0,1938,1939,5, - 66,0,0,1939,1948,3,1416,708,0,1940,1941,5,318,0,0,1941,1948,3,1472, - 736,0,1942,1943,5,134,0,0,1943,1948,3,1416,708,0,1944,1945,5,99, - 0,0,1945,1948,3,1472,736,0,1946,1948,3,1492,746,0,1947,1912,1,0, - 0,0,1947,1917,1,0,0,0,1947,1920,1,0,0,0,1947,1921,1,0,0,0,1947,1922, - 1,0,0,0,1947,1923,1,0,0,0,1947,1924,1,0,0,0,1947,1925,1,0,0,0,1947, - 1926,1,0,0,0,1947,1927,1,0,0,0,1947,1928,1,0,0,0,1947,1931,1,0,0, - 0,1947,1934,1,0,0,0,1947,1937,1,0,0,0,1947,1940,1,0,0,0,1947,1942, - 1,0,0,0,1947,1944,1,0,0,0,1947,1946,1,0,0,0,1948,21,1,0,0,0,1949, - 1960,3,20,10,0,1950,1951,5,348,0,0,1951,1960,3,1456,728,0,1952,1953, - 5,134,0,0,1953,1960,3,1472,736,0,1954,1955,5,318,0,0,1955,1960,3, - 1472,736,0,1956,1957,5,68,0,0,1957,1958,7,9,0,0,1958,1960,3,1472, - 736,0,1959,1949,1,0,0,0,1959,1950,1,0,0,0,1959,1952,1,0,0,0,1959, - 1954,1,0,0,0,1959,1956,1,0,0,0,1960,23,1,0,0,0,1961,1962,5,46,0, - 0,1962,1963,5,99,0,0,1963,1965,3,1468,734,0,1964,1966,3,14,7,0,1965, - 1964,1,0,0,0,1965,1966,1,0,0,0,1966,1967,1,0,0,0,1967,1968,3,16, - 8,0,1968,25,1,0,0,0,1969,1970,5,138,0,0,1970,1971,7,10,0,0,1971, - 1973,3,1470,735,0,1972,1974,3,14,7,0,1973,1972,1,0,0,0,1973,1974, - 1,0,0,0,1974,1975,1,0,0,0,1975,1976,3,18,9,0,1976,27,1,0,0,0,1977, - 1982,1,0,0,0,1978,1979,5,68,0,0,1979,1980,5,175,0,0,1980,1982,3, - 1420,710,0,1981,1977,1,0,0,0,1981,1978,1,0,0,0,1982,29,1,0,0,0,1983, - 1984,5,138,0,0,1984,1987,7,10,0,0,1985,1988,5,30,0,0,1986,1988,3, - 1470,735,0,1987,1985,1,0,0,0,1987,1986,1,0,0,0,1988,1989,1,0,0,0, - 1989,1990,3,28,14,0,1990,1991,3,88,44,0,1991,31,1,0,0,0,1992,1993, - 5,138,0,0,1993,1994,5,442,0,0,1994,1996,3,1426,713,0,1995,1997,3, - 660,330,0,1996,1995,1,0,0,0,1996,1997,1,0,0,0,1997,1998,1,0,0,0, - 1998,1999,3,34,17,0,1999,33,1,0,0,0,2000,2002,3,36,18,0,2001,2003, - 5,315,0,0,2002,2001,1,0,0,0,2002,2003,1,0,0,0,2003,2021,1,0,0,0, - 2004,2005,5,309,0,0,2005,2006,5,94,0,0,2006,2021,3,1424,712,0,2007, - 2008,5,282,0,0,2008,2009,5,94,0,0,2009,2021,3,1470,735,0,2010,2011, - 5,333,0,0,2011,2012,5,323,0,0,2012,2021,3,48,24,0,2013,2015,5,269, - 0,0,2014,2013,1,0,0,0,2014,2015,1,0,0,0,2015,2016,1,0,0,0,2016,2017, - 5,462,0,0,2017,2018,5,80,0,0,2018,2019,5,204,0,0,2019,2021,3,1436, - 718,0,2020,2000,1,0,0,0,2020,2004,1,0,0,0,2020,2007,1,0,0,0,2020, - 2010,1,0,0,0,2020,2014,1,0,0,0,2021,35,1,0,0,0,2022,2026,3,38,19, - 0,2023,2025,3,38,19,0,2024,2023,1,0,0,0,2025,2028,1,0,0,0,2026,2024, - 1,0,0,0,2026,2027,1,0,0,0,2027,37,1,0,0,0,2028,2026,1,0,0,0,2029, - 2071,5,222,0,0,2030,2071,5,338,0,0,2031,2071,5,377,0,0,2032,2034, - 5,77,0,0,2033,2032,1,0,0,0,2033,2034,1,0,0,0,2034,2035,1,0,0,0,2035, - 2071,5,250,0,0,2036,2038,5,205,0,0,2037,2036,1,0,0,0,2037,2038,1, - 0,0,0,2038,2039,1,0,0,0,2039,2040,5,327,0,0,2040,2047,5,243,0,0, - 2041,2043,5,205,0,0,2042,2041,1,0,0,0,2042,2043,1,0,0,0,2043,2044, - 1,0,0,0,2044,2045,5,327,0,0,2045,2047,5,181,0,0,2046,2037,1,0,0, - 0,2046,2042,1,0,0,0,2047,2071,1,0,0,0,2048,2049,5,460,0,0,2049,2071, - 7,11,0,0,2050,2051,5,170,0,0,2051,2071,3,1438,719,0,2052,2053,5, - 320,0,0,2053,2071,3,1436,718,0,2054,2055,5,333,0,0,2055,2056,3,1436, - 718,0,2056,2059,7,12,0,0,2057,2060,3,1436,718,0,2058,2060,5,53,0, - 0,2059,2057,1,0,0,0,2059,2058,1,0,0,0,2060,2071,1,0,0,0,2061,2062, - 5,333,0,0,2062,2063,3,1436,718,0,2063,2064,5,64,0,0,2064,2065,5, - 434,0,0,2065,2071,1,0,0,0,2066,2067,5,313,0,0,2067,2071,3,1436,718, - 0,2068,2069,5,313,0,0,2069,2071,5,30,0,0,2070,2029,1,0,0,0,2070, - 2030,1,0,0,0,2070,2031,1,0,0,0,2070,2033,1,0,0,0,2070,2046,1,0,0, - 0,2070,2048,1,0,0,0,2070,2050,1,0,0,0,2070,2052,1,0,0,0,2070,2054, - 1,0,0,0,2070,2061,1,0,0,0,2070,2066,1,0,0,0,2070,2068,1,0,0,0,2071, - 39,1,0,0,0,2072,2073,5,46,0,0,2073,2074,5,66,0,0,2074,2076,3,1466, - 733,0,2075,2077,3,14,7,0,2076,2075,1,0,0,0,2076,2077,1,0,0,0,2077, - 2078,1,0,0,0,2078,2079,3,16,8,0,2079,41,1,0,0,0,2080,2081,5,138, - 0,0,2081,2082,5,66,0,0,2082,2083,3,1470,735,0,2083,2084,3,44,22, - 0,2084,2085,5,99,0,0,2085,2086,3,1472,736,0,2086,43,1,0,0,0,2087, - 2088,7,13,0,0,2088,45,1,0,0,0,2089,2090,5,46,0,0,2090,2092,5,323, - 0,0,2091,2093,3,516,258,0,2092,2091,1,0,0,0,2092,2093,1,0,0,0,2093, - 2100,1,0,0,0,2094,2096,3,48,24,0,2095,2094,1,0,0,0,2095,2096,1,0, - 0,0,2096,2097,1,0,0,0,2097,2098,5,106,0,0,2098,2101,3,1470,735,0, - 2099,2101,3,48,24,0,2100,2095,1,0,0,0,2100,2099,1,0,0,0,2101,2102, - 1,0,0,0,2102,2103,3,50,25,0,2103,47,1,0,0,0,2104,2106,3,1474,737, - 0,2105,2107,3,560,280,0,2106,2105,1,0,0,0,2106,2107,1,0,0,0,2107, - 49,1,0,0,0,2108,2110,3,52,26,0,2109,2108,1,0,0,0,2110,2113,1,0,0, - 0,2111,2109,1,0,0,0,2111,2112,1,0,0,0,2112,51,1,0,0,0,2113,2111, - 1,0,0,0,2114,2121,3,188,94,0,2115,2121,3,626,313,0,2116,2121,3,308, - 154,0,2117,2121,3,436,218,0,2118,2121,3,586,293,0,2119,2121,3,838, - 419,0,2120,2114,1,0,0,0,2120,2115,1,0,0,0,2120,2116,1,0,0,0,2120, - 2117,1,0,0,0,2120,2118,1,0,0,0,2120,2119,1,0,0,0,2121,53,1,0,0,0, - 2122,2124,5,333,0,0,2123,2125,7,14,0,0,2124,2123,1,0,0,0,2124,2125, - 1,0,0,0,2125,2126,1,0,0,0,2126,2127,3,56,28,0,2127,55,1,0,0,0,2128, - 2129,5,356,0,0,2129,2137,3,832,416,0,2130,2131,5,332,0,0,2131,2132, - 5,154,0,0,2132,2133,5,36,0,0,2133,2134,5,356,0,0,2134,2137,3,832, - 416,0,2135,2137,3,60,30,0,2136,2128,1,0,0,0,2136,2130,1,0,0,0,2136, - 2135,1,0,0,0,2137,57,1,0,0,0,2138,2141,5,30,0,0,2139,2141,3,62,31, - 0,2140,2138,1,0,0,0,2140,2139,1,0,0,0,2141,2143,1,0,0,0,2142,2144, - 7,12,0,0,2143,2142,1,0,0,0,2143,2144,1,0,0,0,2144,2147,1,0,0,0,2145, - 2148,5,53,0,0,2146,2148,3,64,32,0,2147,2145,1,0,0,0,2147,2146,1, - 0,0,0,2147,2148,1,0,0,0,2148,59,1,0,0,0,2149,2150,5,418,0,0,2150, - 2151,5,386,0,0,2151,2177,3,74,37,0,2152,2153,5,152,0,0,2153,2177, - 3,1458,729,0,2154,2155,5,323,0,0,2155,2177,3,1422,711,0,2156,2158, - 5,267,0,0,2157,2159,3,76,38,0,2158,2157,1,0,0,0,2158,2159,1,0,0, - 0,2159,2177,1,0,0,0,2160,2161,5,318,0,0,2161,2177,3,80,40,0,2162, - 2163,5,332,0,0,2163,2164,5,106,0,0,2164,2177,3,80,40,0,2165,2166, - 5,383,0,0,2166,2167,5,279,0,0,2167,2177,3,1276,638,0,2168,2169,5, - 356,0,0,2169,2170,5,337,0,0,2170,2177,3,1458,729,0,2171,2172,3,62, - 31,0,2172,2173,5,64,0,0,2173,2174,5,434,0,0,2174,2177,1,0,0,0,2175, - 2177,3,58,29,0,2176,2149,1,0,0,0,2176,2152,1,0,0,0,2176,2154,1,0, - 0,0,2176,2156,1,0,0,0,2176,2160,1,0,0,0,2176,2162,1,0,0,0,2176,2165, - 1,0,0,0,2176,2168,1,0,0,0,2176,2171,1,0,0,0,2176,2175,1,0,0,0,2177, - 61,1,0,0,0,2178,2183,3,1474,737,0,2179,2180,5,11,0,0,2180,2182,3, - 1474,737,0,2181,2179,1,0,0,0,2182,2185,1,0,0,0,2183,2181,1,0,0,0, - 2183,2184,1,0,0,0,2184,63,1,0,0,0,2185,2183,1,0,0,0,2186,2191,3, - 66,33,0,2187,2188,5,6,0,0,2188,2190,3,66,33,0,2189,2187,1,0,0,0, - 2190,2193,1,0,0,0,2191,2189,1,0,0,0,2191,2192,1,0,0,0,2192,65,1, - 0,0,0,2193,2191,1,0,0,0,2194,2197,3,72,36,0,2195,2197,3,322,161, - 0,2196,2194,1,0,0,0,2196,2195,1,0,0,0,2197,67,1,0,0,0,2198,2199, - 5,300,0,0,2199,2204,7,15,0,0,2200,2201,5,310,0,0,2201,2204,5,300, - 0,0,2202,2204,5,330,0,0,2203,2198,1,0,0,0,2203,2200,1,0,0,0,2203, - 2202,1,0,0,0,2204,69,1,0,0,0,2205,2210,5,96,0,0,2206,2210,5,60,0, - 0,2207,2210,5,80,0,0,2208,2210,3,78,39,0,2209,2205,1,0,0,0,2209, - 2206,1,0,0,0,2209,2207,1,0,0,0,2209,2208,1,0,0,0,2210,71,1,0,0,0, - 2211,2216,5,96,0,0,2212,2216,5,60,0,0,2213,2216,5,80,0,0,2214,2216, - 3,80,40,0,2215,2211,1,0,0,0,2215,2212,1,0,0,0,2215,2213,1,0,0,0, - 2215,2214,1,0,0,0,2216,73,1,0,0,0,2217,2234,3,1458,729,0,2218,2234, - 3,1492,746,0,2219,2220,3,1202,601,0,2220,2222,3,1458,729,0,2221, - 2223,3,1206,603,0,2222,2221,1,0,0,0,2222,2223,1,0,0,0,2223,2234, - 1,0,0,0,2224,2225,3,1202,601,0,2225,2226,5,2,0,0,2226,2227,3,1456, - 728,0,2227,2228,5,3,0,0,2228,2229,3,1458,729,0,2229,2234,1,0,0,0, - 2230,2234,3,322,161,0,2231,2234,5,53,0,0,2232,2234,5,254,0,0,2233, - 2217,1,0,0,0,2233,2218,1,0,0,0,2233,2219,1,0,0,0,2233,2224,1,0,0, - 0,2233,2230,1,0,0,0,2233,2231,1,0,0,0,2233,2232,1,0,0,0,2234,75, - 1,0,0,0,2235,2238,3,1458,729,0,2236,2238,5,53,0,0,2237,2235,1,0, - 0,0,2237,2236,1,0,0,0,2238,77,1,0,0,0,2239,2242,3,1486,743,0,2240, - 2242,3,1458,729,0,2241,2239,1,0,0,0,2241,2240,1,0,0,0,2242,79,1, - 0,0,0,2243,2246,3,1488,744,0,2244,2246,3,1458,729,0,2245,2243,1, - 0,0,0,2245,2244,1,0,0,0,2246,81,1,0,0,0,2247,2248,5,313,0,0,2248, - 2249,3,84,42,0,2249,83,1,0,0,0,2250,2251,5,418,0,0,2251,2259,5,386, - 0,0,2252,2253,5,356,0,0,2253,2254,5,244,0,0,2254,2259,5,251,0,0, - 2255,2256,5,332,0,0,2256,2259,5,106,0,0,2257,2259,3,86,43,0,2258, - 2250,1,0,0,0,2258,2252,1,0,0,0,2258,2255,1,0,0,0,2258,2257,1,0,0, - 0,2259,85,1,0,0,0,2260,2263,5,30,0,0,2261,2263,3,62,31,0,2262,2260, - 1,0,0,0,2262,2261,1,0,0,0,2263,87,1,0,0,0,2264,2265,5,333,0,0,2265, - 2268,3,56,28,0,2266,2268,3,82,41,0,2267,2264,1,0,0,0,2267,2266,1, - 0,0,0,2268,89,1,0,0,0,2269,2270,5,333,0,0,2270,2273,3,60,30,0,2271, - 2273,3,82,41,0,2272,2269,1,0,0,0,2272,2271,1,0,0,0,2273,91,1,0,0, - 0,2274,2284,5,335,0,0,2275,2285,3,62,31,0,2276,2277,5,418,0,0,2277, - 2285,5,386,0,0,2278,2279,5,356,0,0,2279,2280,5,244,0,0,2280,2285, - 5,251,0,0,2281,2282,5,332,0,0,2282,2285,5,106,0,0,2283,2285,5,30, - 0,0,2284,2275,1,0,0,0,2284,2276,1,0,0,0,2284,2278,1,0,0,0,2284,2281, - 1,0,0,0,2284,2283,1,0,0,0,2285,93,1,0,0,0,2286,2287,5,333,0,0,2287, - 2288,5,165,0,0,2288,2289,3,96,48,0,2289,2290,3,98,49,0,2290,95,1, - 0,0,0,2291,2294,5,30,0,0,2292,2294,3,1390,695,0,2293,2291,1,0,0, - 0,2293,2292,1,0,0,0,2294,97,1,0,0,0,2295,2296,7,16,0,0,2296,99,1, - 0,0,0,2297,2298,5,155,0,0,2298,101,1,0,0,0,2299,2300,5,187,0,0,2300, - 2301,7,17,0,0,2301,103,1,0,0,0,2302,2303,5,138,0,0,2303,2305,5,92, - 0,0,2304,2306,3,748,374,0,2305,2304,1,0,0,0,2305,2306,1,0,0,0,2306, - 2307,1,0,0,0,2307,2310,3,1118,559,0,2308,2311,3,106,53,0,2309,2311, - 3,116,58,0,2310,2308,1,0,0,0,2310,2309,1,0,0,0,2311,2436,1,0,0,0, - 2312,2313,5,138,0,0,2313,2314,5,92,0,0,2314,2315,5,30,0,0,2315,2316, - 5,68,0,0,2316,2317,5,351,0,0,2317,2321,3,1402,701,0,2318,2319,5, - 281,0,0,2319,2320,5,147,0,0,2320,2322,3,1472,736,0,2321,2318,1,0, - 0,0,2321,2322,1,0,0,0,2322,2323,1,0,0,0,2323,2324,5,333,0,0,2324, - 2325,5,351,0,0,2325,2327,3,1400,700,0,2326,2328,3,978,489,0,2327, - 2326,1,0,0,0,2327,2328,1,0,0,0,2328,2436,1,0,0,0,2329,2330,5,138, - 0,0,2330,2332,5,92,0,0,2331,2333,3,748,374,0,2332,2331,1,0,0,0,2332, - 2333,1,0,0,0,2333,2334,1,0,0,0,2334,2335,3,1406,703,0,2335,2336, - 5,435,0,0,2336,2337,5,285,0,0,2337,2342,3,1412,706,0,2338,2339,5, - 62,0,0,2339,2340,5,422,0,0,2340,2343,3,108,54,0,2341,2343,5,53,0, - 0,2342,2338,1,0,0,0,2342,2341,1,0,0,0,2343,2436,1,0,0,0,2344,2345, - 5,138,0,0,2345,2347,5,92,0,0,2346,2348,3,748,374,0,2347,2346,1,0, - 0,0,2347,2348,1,0,0,0,2348,2349,1,0,0,0,2349,2350,3,1406,703,0,2350, - 2351,5,436,0,0,2351,2352,5,285,0,0,2352,2354,3,1412,706,0,2353,2355, - 7,18,0,0,2354,2353,1,0,0,0,2354,2355,1,0,0,0,2355,2436,1,0,0,0,2356, - 2357,5,138,0,0,2357,2359,5,226,0,0,2358,2360,3,748,374,0,2359,2358, - 1,0,0,0,2359,2360,1,0,0,0,2360,2361,1,0,0,0,2361,2364,3,1412,706, - 0,2362,2365,3,106,53,0,2363,2365,3,118,59,0,2364,2362,1,0,0,0,2364, - 2363,1,0,0,0,2365,2436,1,0,0,0,2366,2367,5,138,0,0,2367,2368,5,226, - 0,0,2368,2369,5,30,0,0,2369,2370,5,68,0,0,2370,2371,5,351,0,0,2371, - 2375,3,1402,701,0,2372,2373,5,281,0,0,2373,2374,5,147,0,0,2374,2376, - 3,1472,736,0,2375,2372,1,0,0,0,2375,2376,1,0,0,0,2376,2377,1,0,0, - 0,2377,2378,5,333,0,0,2378,2379,5,351,0,0,2379,2381,3,1402,701,0, - 2380,2382,3,978,489,0,2381,2380,1,0,0,0,2381,2382,1,0,0,0,2382,2436, - 1,0,0,0,2383,2384,5,138,0,0,2384,2386,5,328,0,0,2385,2387,3,748, - 374,0,2386,2385,1,0,0,0,2386,2387,1,0,0,0,2387,2388,1,0,0,0,2388, - 2389,3,1412,706,0,2389,2390,3,106,53,0,2390,2436,1,0,0,0,2391,2392, - 5,138,0,0,2392,2394,5,376,0,0,2393,2395,3,748,374,0,2394,2393,1, - 0,0,0,2394,2395,1,0,0,0,2395,2396,1,0,0,0,2396,2397,3,1410,705,0, - 2397,2398,3,106,53,0,2398,2436,1,0,0,0,2399,2400,5,138,0,0,2400, - 2401,5,259,0,0,2401,2403,5,376,0,0,2402,2404,3,748,374,0,2403,2402, - 1,0,0,0,2403,2404,1,0,0,0,2404,2405,1,0,0,0,2405,2406,3,1410,705, - 0,2406,2407,3,106,53,0,2407,2436,1,0,0,0,2408,2409,5,138,0,0,2409, - 2410,5,259,0,0,2410,2411,5,376,0,0,2411,2412,5,30,0,0,2412,2413, - 5,68,0,0,2413,2414,5,351,0,0,2414,2418,3,1402,701,0,2415,2416,5, - 281,0,0,2416,2417,5,147,0,0,2417,2419,3,1472,736,0,2418,2415,1,0, - 0,0,2418,2419,1,0,0,0,2419,2420,1,0,0,0,2420,2421,5,333,0,0,2421, - 2422,5,351,0,0,2422,2424,3,1400,700,0,2423,2425,3,978,489,0,2424, - 2423,1,0,0,0,2424,2425,1,0,0,0,2425,2436,1,0,0,0,2426,2427,5,138, - 0,0,2427,2428,5,63,0,0,2428,2430,5,92,0,0,2429,2431,3,748,374,0, - 2430,2429,1,0,0,0,2430,2431,1,0,0,0,2431,2432,1,0,0,0,2432,2433, - 3,1118,559,0,2433,2434,3,106,53,0,2434,2436,1,0,0,0,2435,2302,1, - 0,0,0,2435,2312,1,0,0,0,2435,2329,1,0,0,0,2435,2344,1,0,0,0,2435, - 2356,1,0,0,0,2435,2366,1,0,0,0,2435,2383,1,0,0,0,2435,2391,1,0,0, - 0,2435,2399,1,0,0,0,2435,2408,1,0,0,0,2435,2426,1,0,0,0,2436,105, - 1,0,0,0,2437,2442,3,120,60,0,2438,2439,5,6,0,0,2439,2441,3,120,60, - 0,2440,2438,1,0,0,0,2441,2444,1,0,0,0,2442,2440,1,0,0,0,2442,2443, - 1,0,0,0,2443,107,1,0,0,0,2444,2442,1,0,0,0,2445,2446,5,68,0,0,2446, - 2455,3,1178,589,0,2447,2448,5,64,0,0,2448,2449,3,110,55,0,2449,2450, - 5,94,0,0,2450,2451,3,110,55,0,2451,2455,1,0,0,0,2452,2453,5,105, - 0,0,2453,2455,3,114,57,0,2454,2445,1,0,0,0,2454,2447,1,0,0,0,2454, - 2452,1,0,0,0,2455,109,1,0,0,0,2456,2457,5,2,0,0,2457,2462,3,112, - 56,0,2458,2459,5,6,0,0,2459,2461,3,112,56,0,2460,2458,1,0,0,0,2461, - 2464,1,0,0,0,2462,2460,1,0,0,0,2462,2463,1,0,0,0,2463,2465,1,0,0, - 0,2464,2462,1,0,0,0,2465,2466,5,3,0,0,2466,111,1,0,0,0,2467,2471, - 3,1178,589,0,2468,2471,5,262,0,0,2469,2471,5,260,0,0,2470,2467,1, - 0,0,0,2470,2468,1,0,0,0,2470,2469,1,0,0,0,2471,113,1,0,0,0,2472, - 2473,5,2,0,0,2473,2474,5,533,0,0,2474,2475,3,322,161,0,2475,2476, - 5,6,0,0,2476,2477,5,534,0,0,2477,2478,3,322,161,0,2478,2479,5,3, - 0,0,2479,115,1,0,0,0,2480,2481,5,435,0,0,2481,2482,5,285,0,0,2482, - 2483,3,1412,706,0,2483,2484,3,144,72,0,2484,2489,1,0,0,0,2485,2486, - 5,436,0,0,2486,2487,5,285,0,0,2487,2489,3,1412,706,0,2488,2480,1, - 0,0,0,2488,2485,1,0,0,0,2489,117,1,0,0,0,2490,2491,5,435,0,0,2491, - 2492,5,285,0,0,2492,2493,3,1412,706,0,2493,119,1,0,0,0,2494,2497, - 5,133,0,0,2495,2496,5,45,0,0,2496,2498,3,1436,718,0,2497,2495,1, - 0,0,0,2497,2498,1,0,0,0,2498,2499,1,0,0,0,2499,2712,3,236,118,0, - 2500,2501,5,138,0,0,2501,2502,5,45,0,0,2502,2503,3,1436,718,0,2503, - 2504,3,476,238,0,2504,2712,1,0,0,0,2505,2506,5,372,0,0,2506,2507, - 5,45,0,0,2507,2712,3,1436,718,0,2508,2509,5,191,0,0,2509,2511,5, - 45,0,0,2510,2512,3,748,374,0,2511,2510,1,0,0,0,2511,2512,1,0,0,0, - 2512,2513,1,0,0,0,2513,2515,3,1436,718,0,2514,2516,3,124,62,0,2515, - 2514,1,0,0,0,2515,2516,1,0,0,0,2516,2712,1,0,0,0,2517,2518,5,333, - 0,0,2518,2519,5,379,0,0,2519,2712,5,277,0,0,2520,2521,5,158,0,0, - 2521,2522,5,80,0,0,2522,2712,3,1436,718,0,2523,2524,5,333,0,0,2524, - 2525,5,379,0,0,2525,2712,5,158,0,0,2526,2527,5,333,0,0,2527,2712, - 7,19,0,0,2528,2530,5,193,0,0,2529,2531,7,20,0,0,2530,2529,1,0,0, - 0,2530,2531,1,0,0,0,2531,2532,1,0,0,0,2532,2712,5,357,0,0,2533,2534, - 5,186,0,0,2534,2538,5,357,0,0,2535,2539,5,30,0,0,2536,2539,5,99, - 0,0,2537,2539,3,1436,718,0,2538,2535,1,0,0,0,2538,2536,1,0,0,0,2538, - 2537,1,0,0,0,2539,2712,1,0,0,0,2540,2541,5,193,0,0,2541,2542,7,20, - 0,0,2542,2543,5,321,0,0,2543,2712,3,1436,718,0,2544,2545,5,186,0, - 0,2545,2546,5,321,0,0,2546,2712,3,1436,718,0,2547,2549,5,269,0,0, - 2548,2547,1,0,0,0,2548,2549,1,0,0,0,2549,2550,1,0,0,0,2550,2551, - 5,228,0,0,2551,2712,3,1412,706,0,2552,2553,5,275,0,0,2553,2712,3, - 558,279,0,2554,2555,5,77,0,0,2555,2712,5,275,0,0,2556,2557,5,282, - 0,0,2557,2558,5,94,0,0,2558,2712,3,1470,735,0,2559,2560,5,333,0, - 0,2560,2561,5,351,0,0,2561,2712,3,1400,700,0,2562,2563,5,333,0,0, - 2563,2712,3,132,66,0,2564,2565,5,313,0,0,2565,2712,3,132,66,0,2566, - 2567,5,312,0,0,2567,2568,5,219,0,0,2568,2712,3,130,65,0,2569,2570, - 5,193,0,0,2570,2571,5,414,0,0,2571,2572,5,251,0,0,2572,2712,5,327, - 0,0,2573,2574,5,186,0,0,2574,2575,5,414,0,0,2575,2576,5,251,0,0, - 2576,2712,5,327,0,0,2577,2578,5,209,0,0,2578,2579,5,414,0,0,2579, - 2580,5,251,0,0,2580,2712,5,327,0,0,2581,2582,5,269,0,0,2582,2583, - 5,209,0,0,2583,2584,5,414,0,0,2584,2585,5,251,0,0,2585,2712,5,327, - 0,0,2586,2588,5,191,0,0,2587,2589,5,44,0,0,2588,2587,1,0,0,0,2588, - 2589,1,0,0,0,2589,2591,1,0,0,0,2590,2592,3,748,374,0,2591,2590,1, - 0,0,0,2591,2592,1,0,0,0,2592,2593,1,0,0,0,2593,2595,3,1432,716,0, - 2594,2596,3,124,62,0,2595,2594,1,0,0,0,2595,2596,1,0,0,0,2596,2712, - 1,0,0,0,2597,2599,5,133,0,0,2598,2600,5,44,0,0,2599,2598,1,0,0,0, - 2599,2600,1,0,0,0,2600,2602,1,0,0,0,2601,2603,3,516,258,0,2602,2601, - 1,0,0,0,2602,2603,1,0,0,0,2603,2604,1,0,0,0,2604,2712,3,206,103, - 0,2605,2607,5,138,0,0,2606,2608,5,44,0,0,2607,2606,1,0,0,0,2607, - 2608,1,0,0,0,2608,2609,1,0,0,0,2609,2610,3,1432,716,0,2610,2611, - 3,122,61,0,2611,2712,1,0,0,0,2612,2614,5,138,0,0,2613,2615,5,44, - 0,0,2614,2613,1,0,0,0,2614,2615,1,0,0,0,2615,2616,1,0,0,0,2616,2617, - 3,1432,716,0,2617,2618,7,21,0,0,2618,2619,5,77,0,0,2619,2620,5,78, - 0,0,2620,2712,1,0,0,0,2621,2623,5,138,0,0,2622,2624,5,44,0,0,2623, - 2622,1,0,0,0,2623,2624,1,0,0,0,2624,2625,1,0,0,0,2625,2626,3,1432, - 716,0,2626,2627,5,191,0,0,2627,2629,5,437,0,0,2628,2630,3,748,374, - 0,2629,2628,1,0,0,0,2629,2630,1,0,0,0,2630,2712,1,0,0,0,2631,2633, - 5,138,0,0,2632,2634,5,44,0,0,2633,2632,1,0,0,0,2633,2634,1,0,0,0, - 2634,2635,1,0,0,0,2635,2636,3,1432,716,0,2636,2637,5,333,0,0,2637, - 2638,5,342,0,0,2638,2639,3,1464,732,0,2639,2712,1,0,0,0,2640,2642, - 5,138,0,0,2641,2643,5,44,0,0,2642,2641,1,0,0,0,2642,2643,1,0,0,0, - 2643,2644,1,0,0,0,2644,2645,3,1432,716,0,2645,2646,7,22,0,0,2646, - 2647,3,132,66,0,2647,2712,1,0,0,0,2648,2650,5,138,0,0,2649,2651, - 5,44,0,0,2650,2649,1,0,0,0,2650,2651,1,0,0,0,2651,2652,1,0,0,0,2652, - 2653,3,1432,716,0,2653,2654,5,333,0,0,2654,2655,5,345,0,0,2655,2656, - 3,1474,737,0,2656,2712,1,0,0,0,2657,2659,5,138,0,0,2658,2660,5,44, - 0,0,2659,2658,1,0,0,0,2659,2660,1,0,0,0,2660,2661,1,0,0,0,2661,2662, - 3,1432,716,0,2662,2663,5,133,0,0,2663,2664,5,438,0,0,2664,2665,3, - 222,111,0,2665,2666,5,36,0,0,2666,2668,5,219,0,0,2667,2669,3,314, - 157,0,2668,2667,1,0,0,0,2668,2669,1,0,0,0,2669,2712,1,0,0,0,2670, - 2672,5,138,0,0,2671,2673,5,44,0,0,2672,2671,1,0,0,0,2672,2673,1, - 0,0,0,2673,2674,1,0,0,0,2674,2675,3,1432,716,0,2675,2676,3,140,70, - 0,2676,2712,1,0,0,0,2677,2679,5,138,0,0,2678,2680,5,44,0,0,2679, - 2678,1,0,0,0,2679,2680,1,0,0,0,2680,2681,1,0,0,0,2681,2682,3,1432, - 716,0,2682,2683,5,191,0,0,2683,2685,5,219,0,0,2684,2686,3,748,374, - 0,2685,2684,1,0,0,0,2685,2686,1,0,0,0,2686,2712,1,0,0,0,2687,2689, - 5,138,0,0,2688,2690,5,44,0,0,2689,2688,1,0,0,0,2689,2690,1,0,0,0, - 2690,2691,1,0,0,0,2691,2693,3,1432,716,0,2692,2694,3,768,384,0,2693, - 2692,1,0,0,0,2693,2694,1,0,0,0,2694,2695,1,0,0,0,2695,2696,5,360, - 0,0,2696,2698,3,1168,584,0,2697,2699,3,126,63,0,2698,2697,1,0,0, - 0,2698,2699,1,0,0,0,2699,2701,1,0,0,0,2700,2702,3,128,64,0,2701, - 2700,1,0,0,0,2701,2702,1,0,0,0,2702,2712,1,0,0,0,2703,2705,5,138, - 0,0,2704,2706,5,44,0,0,2705,2704,1,0,0,0,2705,2706,1,0,0,0,2706, - 2707,1,0,0,0,2707,2708,3,1432,716,0,2708,2709,3,372,186,0,2709,2712, - 1,0,0,0,2710,2712,3,372,186,0,2711,2494,1,0,0,0,2711,2500,1,0,0, - 0,2711,2505,1,0,0,0,2711,2508,1,0,0,0,2711,2517,1,0,0,0,2711,2520, - 1,0,0,0,2711,2523,1,0,0,0,2711,2526,1,0,0,0,2711,2528,1,0,0,0,2711, - 2533,1,0,0,0,2711,2540,1,0,0,0,2711,2544,1,0,0,0,2711,2548,1,0,0, - 0,2711,2552,1,0,0,0,2711,2554,1,0,0,0,2711,2556,1,0,0,0,2711,2559, - 1,0,0,0,2711,2562,1,0,0,0,2711,2564,1,0,0,0,2711,2566,1,0,0,0,2711, - 2569,1,0,0,0,2711,2573,1,0,0,0,2711,2577,1,0,0,0,2711,2581,1,0,0, - 0,2711,2586,1,0,0,0,2711,2597,1,0,0,0,2711,2605,1,0,0,0,2711,2612, - 1,0,0,0,2711,2621,1,0,0,0,2711,2631,1,0,0,0,2711,2640,1,0,0,0,2711, - 2648,1,0,0,0,2711,2657,1,0,0,0,2711,2670,1,0,0,0,2711,2677,1,0,0, - 0,2711,2687,1,0,0,0,2711,2703,1,0,0,0,2711,2710,1,0,0,0,2712,121, - 1,0,0,0,2713,2714,5,333,0,0,2714,2715,5,53,0,0,2715,2719,3,1212, - 606,0,2716,2717,5,191,0,0,2717,2719,5,53,0,0,2718,2713,1,0,0,0,2718, - 2716,1,0,0,0,2719,123,1,0,0,0,2720,2721,7,23,0,0,2721,125,1,0,0, - 0,2722,2723,5,43,0,0,2723,2724,3,558,279,0,2724,127,1,0,0,0,2725, - 2726,5,100,0,0,2726,2727,3,1212,606,0,2727,129,1,0,0,0,2728,2735, - 5,270,0,0,2729,2735,5,113,0,0,2730,2735,5,53,0,0,2731,2732,5,100, - 0,0,2732,2733,5,226,0,0,2733,2735,3,1436,718,0,2734,2728,1,0,0,0, - 2734,2729,1,0,0,0,2734,2730,1,0,0,0,2734,2731,1,0,0,0,2735,131,1, - 0,0,0,2736,2737,5,2,0,0,2737,2738,3,136,68,0,2738,2739,5,3,0,0,2739, - 133,1,0,0,0,2740,2741,5,105,0,0,2741,2742,3,132,66,0,2742,135,1, - 0,0,0,2743,2748,3,138,69,0,2744,2745,5,6,0,0,2745,2747,3,138,69, - 0,2746,2744,1,0,0,0,2747,2750,1,0,0,0,2748,2746,1,0,0,0,2748,2749, - 1,0,0,0,2749,137,1,0,0,0,2750,2748,1,0,0,0,2751,2760,3,1490,745, - 0,2752,2753,5,10,0,0,2753,2761,3,502,251,0,2754,2755,5,11,0,0,2755, - 2758,3,1490,745,0,2756,2757,5,10,0,0,2757,2759,3,502,251,0,2758, - 2756,1,0,0,0,2758,2759,1,0,0,0,2759,2761,1,0,0,0,2760,2752,1,0,0, - 0,2760,2754,1,0,0,0,2760,2761,1,0,0,0,2761,139,1,0,0,0,2762,2764, - 3,142,71,0,2763,2762,1,0,0,0,2764,2765,1,0,0,0,2765,2763,1,0,0,0, - 2765,2766,1,0,0,0,2766,141,1,0,0,0,2767,2772,5,314,0,0,2768,2770, - 3,14,7,0,2769,2768,1,0,0,0,2769,2770,1,0,0,0,2770,2771,1,0,0,0,2771, - 2773,3,322,161,0,2772,2769,1,0,0,0,2772,2773,1,0,0,0,2773,2781,1, - 0,0,0,2774,2778,5,333,0,0,2775,2779,3,318,159,0,2776,2777,5,438, - 0,0,2777,2779,3,222,111,0,2778,2775,1,0,0,0,2778,2776,1,0,0,0,2779, - 2781,1,0,0,0,2780,2767,1,0,0,0,2780,2774,1,0,0,0,2781,143,1,0,0, - 0,2782,2783,5,62,0,0,2783,2784,5,422,0,0,2784,2785,5,105,0,0,2785, - 2786,5,2,0,0,2786,2787,3,148,74,0,2787,2788,5,3,0,0,2788,2809,1, - 0,0,0,2789,2790,5,62,0,0,2790,2791,5,422,0,0,2791,2792,5,68,0,0, - 2792,2793,5,2,0,0,2793,2794,3,1328,664,0,2794,2795,5,3,0,0,2795, - 2809,1,0,0,0,2796,2797,5,62,0,0,2797,2798,5,422,0,0,2798,2799,5, - 64,0,0,2799,2800,5,2,0,0,2800,2801,3,1328,664,0,2801,2802,5,3,0, - 0,2802,2803,5,94,0,0,2803,2804,5,2,0,0,2804,2805,3,1328,664,0,2805, - 2806,5,3,0,0,2806,2809,1,0,0,0,2807,2809,5,53,0,0,2808,2782,1,0, - 0,0,2808,2789,1,0,0,0,2808,2796,1,0,0,0,2808,2807,1,0,0,0,2809,145, - 1,0,0,0,2810,2811,3,1488,744,0,2811,2812,3,1456,728,0,2812,147,1, - 0,0,0,2813,2818,3,146,73,0,2814,2815,5,6,0,0,2815,2817,3,146,73, - 0,2816,2814,1,0,0,0,2817,2820,1,0,0,0,2818,2816,1,0,0,0,2818,2819, - 1,0,0,0,2819,149,1,0,0,0,2820,2818,1,0,0,0,2821,2822,5,138,0,0,2822, - 2823,5,360,0,0,2823,2824,3,558,279,0,2824,2825,3,152,76,0,2825,151, - 1,0,0,0,2826,2831,3,154,77,0,2827,2828,5,6,0,0,2828,2830,3,154,77, - 0,2829,2827,1,0,0,0,2830,2833,1,0,0,0,2831,2829,1,0,0,0,2831,2832, - 1,0,0,0,2832,153,1,0,0,0,2833,2831,1,0,0,0,2834,2835,5,133,0,0,2835, - 2836,5,143,0,0,2836,2838,3,1152,576,0,2837,2839,3,124,62,0,2838, - 2837,1,0,0,0,2838,2839,1,0,0,0,2839,2864,1,0,0,0,2840,2841,5,191, - 0,0,2841,2843,5,143,0,0,2842,2844,3,748,374,0,2843,2842,1,0,0,0, - 2843,2844,1,0,0,0,2844,2845,1,0,0,0,2845,2847,3,1474,737,0,2846, - 2848,3,124,62,0,2847,2846,1,0,0,0,2847,2848,1,0,0,0,2848,2864,1, - 0,0,0,2849,2850,5,138,0,0,2850,2851,5,143,0,0,2851,2853,3,1474,737, - 0,2852,2854,3,768,384,0,2853,2852,1,0,0,0,2853,2854,1,0,0,0,2854, - 2855,1,0,0,0,2855,2856,5,360,0,0,2856,2858,3,1168,584,0,2857,2859, - 3,126,63,0,2858,2857,1,0,0,0,2858,2859,1,0,0,0,2859,2861,1,0,0,0, - 2860,2862,3,124,62,0,2861,2860,1,0,0,0,2861,2862,1,0,0,0,2862,2864, - 1,0,0,0,2863,2834,1,0,0,0,2863,2840,1,0,0,0,2863,2849,1,0,0,0,2864, - 155,1,0,0,0,2865,2868,5,157,0,0,2866,2869,3,994,497,0,2867,2869, - 5,30,0,0,2868,2866,1,0,0,0,2868,2867,1,0,0,0,2869,157,1,0,0,0,2870, - 2872,5,169,0,0,2871,2873,3,172,86,0,2872,2871,1,0,0,0,2872,2873, - 1,0,0,0,2873,2874,1,0,0,0,2874,2876,3,1406,703,0,2875,2877,3,240, - 120,0,2876,2875,1,0,0,0,2876,2877,1,0,0,0,2877,2878,1,0,0,0,2878, - 2880,3,160,80,0,2879,2881,3,162,81,0,2880,2879,1,0,0,0,2880,2881, - 1,0,0,0,2881,2882,1,0,0,0,2882,2884,3,164,82,0,2883,2885,3,174,87, - 0,2884,2883,1,0,0,0,2884,2885,1,0,0,0,2885,2887,1,0,0,0,2886,2888, - 3,14,7,0,2887,2886,1,0,0,0,2887,2888,1,0,0,0,2888,2889,1,0,0,0,2889, - 2891,3,166,83,0,2890,2892,3,1144,572,0,2891,2890,1,0,0,0,2891,2892, - 1,0,0,0,2892,2908,1,0,0,0,2893,2894,5,169,0,0,2894,2895,5,2,0,0, - 2895,2896,3,942,471,0,2896,2897,5,3,0,0,2897,2899,5,94,0,0,2898, - 2900,3,162,81,0,2899,2898,1,0,0,0,2899,2900,1,0,0,0,2900,2901,1, - 0,0,0,2901,2903,3,164,82,0,2902,2904,3,14,7,0,2903,2902,1,0,0,0, - 2903,2904,1,0,0,0,2904,2905,1,0,0,0,2905,2906,3,166,83,0,2906,2908, - 1,0,0,0,2907,2870,1,0,0,0,2907,2893,1,0,0,0,2908,159,1,0,0,0,2909, - 2910,7,24,0,0,2910,161,1,0,0,0,2911,2912,5,297,0,0,2912,163,1,0, - 0,0,2913,2917,3,1458,729,0,2914,2917,5,343,0,0,2915,2917,5,344,0, - 0,2916,2913,1,0,0,0,2916,2914,1,0,0,0,2916,2915,1,0,0,0,2917,165, - 1,0,0,0,2918,2924,3,168,84,0,2919,2920,5,2,0,0,2920,2921,3,178,89, - 0,2921,2922,5,3,0,0,2922,2924,1,0,0,0,2923,2918,1,0,0,0,2923,2919, - 1,0,0,0,2924,167,1,0,0,0,2925,2927,3,170,85,0,2926,2925,1,0,0,0, - 2927,2930,1,0,0,0,2928,2926,1,0,0,0,2928,2929,1,0,0,0,2929,169,1, - 0,0,0,2930,2928,1,0,0,0,2931,2971,5,107,0,0,2932,2971,5,112,0,0, - 2933,2935,5,183,0,0,2934,2936,3,872,436,0,2935,2934,1,0,0,0,2935, - 2936,1,0,0,0,2936,2937,1,0,0,0,2937,2971,3,1458,729,0,2938,2940, - 5,78,0,0,2939,2941,3,872,436,0,2940,2939,1,0,0,0,2940,2941,1,0,0, - 0,2941,2942,1,0,0,0,2942,2971,3,1458,729,0,2943,2971,5,171,0,0,2944, - 2971,5,216,0,0,2945,2947,5,298,0,0,2946,2948,3,872,436,0,2947,2946, - 1,0,0,0,2947,2948,1,0,0,0,2948,2949,1,0,0,0,2949,2971,3,1458,729, - 0,2950,2952,5,197,0,0,2951,2953,3,872,436,0,2952,2951,1,0,0,0,2952, - 2953,1,0,0,0,2953,2954,1,0,0,0,2954,2971,3,1458,729,0,2955,2956, - 5,209,0,0,2956,2957,5,298,0,0,2957,2971,3,244,122,0,2958,2959,5, - 209,0,0,2959,2960,5,298,0,0,2960,2971,5,9,0,0,2961,2962,5,209,0, - 0,2962,2963,5,77,0,0,2963,2964,5,78,0,0,2964,2971,3,244,122,0,2965, - 2966,5,209,0,0,2966,2967,5,78,0,0,2967,2971,3,244,122,0,2968,2969, - 5,194,0,0,2969,2971,3,1458,729,0,2970,2931,1,0,0,0,2970,2932,1,0, - 0,0,2970,2933,1,0,0,0,2970,2938,1,0,0,0,2970,2943,1,0,0,0,2970,2944, - 1,0,0,0,2970,2945,1,0,0,0,2970,2950,1,0,0,0,2970,2955,1,0,0,0,2970, - 2958,1,0,0,0,2970,2961,1,0,0,0,2970,2965,1,0,0,0,2970,2968,1,0,0, - 0,2971,171,1,0,0,0,2972,2973,5,107,0,0,2973,173,1,0,0,0,2974,2976, - 3,176,88,0,2975,2974,1,0,0,0,2975,2976,1,0,0,0,2976,2977,1,0,0,0, - 2977,2978,5,184,0,0,2978,2979,3,1458,729,0,2979,175,1,0,0,0,2980, - 2981,5,100,0,0,2981,177,1,0,0,0,2982,2987,3,180,90,0,2983,2984,5, - 6,0,0,2984,2986,3,180,90,0,2985,2983,1,0,0,0,2986,2989,1,0,0,0,2987, - 2985,1,0,0,0,2987,2988,1,0,0,0,2988,179,1,0,0,0,2989,2987,1,0,0, - 0,2990,2992,3,1490,745,0,2991,2993,3,182,91,0,2992,2991,1,0,0,0, - 2992,2993,1,0,0,0,2993,181,1,0,0,0,2994,3002,3,72,36,0,2995,3002, - 3,322,161,0,2996,3002,5,9,0,0,2997,2998,5,2,0,0,2998,2999,3,184, - 92,0,2999,3000,5,3,0,0,3000,3002,1,0,0,0,3001,2994,1,0,0,0,3001, - 2995,1,0,0,0,3001,2996,1,0,0,0,3001,2997,1,0,0,0,3002,183,1,0,0, - 0,3003,3008,3,186,93,0,3004,3005,5,6,0,0,3005,3007,3,186,93,0,3006, - 3004,1,0,0,0,3007,3010,1,0,0,0,3008,3006,1,0,0,0,3008,3009,1,0,0, - 0,3009,185,1,0,0,0,3010,3008,1,0,0,0,3011,3012,3,70,35,0,3012,187, - 1,0,0,0,3013,3015,5,46,0,0,3014,3016,3,190,95,0,3015,3014,1,0,0, - 0,3015,3016,1,0,0,0,3016,3017,1,0,0,0,3017,3019,5,92,0,0,3018,3020, - 3,516,258,0,3019,3018,1,0,0,0,3019,3020,1,0,0,0,3020,3021,1,0,0, - 0,3021,3087,3,1404,702,0,3022,3024,5,2,0,0,3023,3025,3,192,96,0, - 3024,3023,1,0,0,0,3024,3025,1,0,0,0,3025,3026,1,0,0,0,3026,3028, - 5,3,0,0,3027,3029,3,266,133,0,3028,3027,1,0,0,0,3028,3029,1,0,0, - 0,3029,3031,1,0,0,0,3030,3032,3,268,134,0,3031,3030,1,0,0,0,3031, - 3032,1,0,0,0,3032,3034,1,0,0,0,3033,3035,3,276,138,0,3034,3033,1, - 0,0,0,3034,3035,1,0,0,0,3035,3037,1,0,0,0,3036,3038,3,278,139,0, - 3037,3036,1,0,0,0,3037,3038,1,0,0,0,3038,3040,1,0,0,0,3039,3041, - 3,280,140,0,3040,3039,1,0,0,0,3040,3041,1,0,0,0,3041,3043,1,0,0, - 0,3042,3044,3,282,141,0,3043,3042,1,0,0,0,3043,3044,1,0,0,0,3044, - 3088,1,0,0,0,3045,3046,5,275,0,0,3046,3048,3,558,279,0,3047,3049, - 3,196,98,0,3048,3047,1,0,0,0,3048,3049,1,0,0,0,3049,3051,1,0,0,0, - 3050,3052,3,268,134,0,3051,3050,1,0,0,0,3051,3052,1,0,0,0,3052,3054, - 1,0,0,0,3053,3055,3,276,138,0,3054,3053,1,0,0,0,3054,3055,1,0,0, - 0,3055,3057,1,0,0,0,3056,3058,3,278,139,0,3057,3056,1,0,0,0,3057, - 3058,1,0,0,0,3058,3060,1,0,0,0,3059,3061,3,280,140,0,3060,3059,1, - 0,0,0,3060,3061,1,0,0,0,3061,3063,1,0,0,0,3062,3064,3,282,141,0, - 3063,3062,1,0,0,0,3063,3064,1,0,0,0,3064,3088,1,0,0,0,3065,3066, - 5,285,0,0,3066,3067,5,275,0,0,3067,3069,3,1412,706,0,3068,3070,3, - 196,98,0,3069,3068,1,0,0,0,3069,3070,1,0,0,0,3070,3071,1,0,0,0,3071, - 3073,3,144,72,0,3072,3074,3,268,134,0,3073,3072,1,0,0,0,3073,3074, - 1,0,0,0,3074,3076,1,0,0,0,3075,3077,3,276,138,0,3076,3075,1,0,0, - 0,3076,3077,1,0,0,0,3077,3079,1,0,0,0,3078,3080,3,278,139,0,3079, - 3078,1,0,0,0,3079,3080,1,0,0,0,3080,3082,1,0,0,0,3081,3083,3,280, - 140,0,3082,3081,1,0,0,0,3082,3083,1,0,0,0,3083,3085,1,0,0,0,3084, - 3086,3,282,141,0,3085,3084,1,0,0,0,3085,3086,1,0,0,0,3086,3088,1, - 0,0,0,3087,3022,1,0,0,0,3087,3045,1,0,0,0,3087,3065,1,0,0,0,3088, - 189,1,0,0,0,3089,3097,5,354,0,0,3090,3097,5,352,0,0,3091,3092,5, - 254,0,0,3092,3097,7,25,0,0,3093,3094,5,213,0,0,3094,3097,7,25,0, - 0,3095,3097,5,367,0,0,3096,3089,1,0,0,0,3096,3090,1,0,0,0,3096,3091, - 1,0,0,0,3096,3093,1,0,0,0,3096,3095,1,0,0,0,3097,191,1,0,0,0,3098, - 3099,3,198,99,0,3099,193,1,0,0,0,3100,3101,3,198,99,0,3101,195,1, - 0,0,0,3102,3103,5,2,0,0,3103,3104,3,200,100,0,3104,3105,5,3,0,0, - 3105,197,1,0,0,0,3106,3111,3,202,101,0,3107,3108,5,6,0,0,3108,3110, - 3,202,101,0,3109,3107,1,0,0,0,3110,3113,1,0,0,0,3111,3109,1,0,0, - 0,3111,3112,1,0,0,0,3112,199,1,0,0,0,3113,3111,1,0,0,0,3114,3119, - 3,204,102,0,3115,3116,5,6,0,0,3116,3118,3,204,102,0,3117,3115,1, - 0,0,0,3118,3121,1,0,0,0,3119,3117,1,0,0,0,3119,3120,1,0,0,0,3120, - 201,1,0,0,0,3121,3119,1,0,0,0,3122,3126,3,206,103,0,3123,3126,3, - 228,114,0,3124,3126,3,234,117,0,3125,3122,1,0,0,0,3125,3123,1,0, - 0,0,3125,3124,1,0,0,0,3126,203,1,0,0,0,3127,3130,3,212,106,0,3128, - 3130,3,234,117,0,3129,3127,1,0,0,0,3129,3128,1,0,0,0,3130,205,1, - 0,0,0,3131,3132,3,1434,717,0,3132,3134,3,1168,584,0,3133,3135,3, - 368,184,0,3134,3133,1,0,0,0,3134,3135,1,0,0,0,3135,3137,1,0,0,0, - 3136,3138,3,210,105,0,3137,3136,1,0,0,0,3137,3138,1,0,0,0,3138,3140, - 1,0,0,0,3139,3141,3,208,104,0,3140,3139,1,0,0,0,3140,3141,1,0,0, - 0,3141,3144,1,0,0,0,3142,3143,5,43,0,0,3143,3145,3,558,279,0,3144, - 3142,1,0,0,0,3144,3145,1,0,0,0,3145,3148,1,0,0,0,3146,3147,5,105, - 0,0,3147,3149,5,280,0,0,3148,3146,1,0,0,0,3148,3149,1,0,0,0,3149, - 3150,1,0,0,0,3150,3151,3,214,107,0,3151,207,1,0,0,0,3152,3153,5, - 543,0,0,3153,3154,3,1474,737,0,3154,209,1,0,0,0,3155,3162,5,345, - 0,0,3156,3163,5,544,0,0,3157,3163,5,205,0,0,3158,3163,5,545,0,0, - 3159,3163,5,546,0,0,3160,3163,5,53,0,0,3161,3163,3,1474,737,0,3162, - 3156,1,0,0,0,3162,3157,1,0,0,0,3162,3158,1,0,0,0,3162,3159,1,0,0, - 0,3162,3160,1,0,0,0,3162,3161,1,0,0,0,3163,211,1,0,0,0,3164,3167, - 3,1434,717,0,3165,3166,5,105,0,0,3166,3168,5,280,0,0,3167,3165,1, - 0,0,0,3167,3168,1,0,0,0,3168,3169,1,0,0,0,3169,3170,3,214,107,0, - 3170,213,1,0,0,0,3171,3173,3,216,108,0,3172,3171,1,0,0,0,3173,3176, - 1,0,0,0,3174,3172,1,0,0,0,3174,3175,1,0,0,0,3175,215,1,0,0,0,3176, - 3174,1,0,0,0,3177,3178,5,45,0,0,3178,3180,3,1436,718,0,3179,3177, - 1,0,0,0,3179,3180,1,0,0,0,3180,3181,1,0,0,0,3181,3183,3,218,109, - 0,3182,3184,3,224,112,0,3183,3182,1,0,0,0,3183,3184,1,0,0,0,3184, - 3186,1,0,0,0,3185,3187,3,226,113,0,3186,3185,1,0,0,0,3186,3187,1, - 0,0,0,3187,3196,1,0,0,0,3188,3190,3,218,109,0,3189,3191,3,224,112, - 0,3190,3189,1,0,0,0,3190,3191,1,0,0,0,3191,3193,1,0,0,0,3192,3194, - 3,226,113,0,3193,3192,1,0,0,0,3193,3194,1,0,0,0,3194,3196,1,0,0, - 0,3195,3179,1,0,0,0,3195,3188,1,0,0,0,3196,217,1,0,0,0,3197,3198, - 5,77,0,0,3198,3256,5,78,0,0,3199,3256,5,78,0,0,3200,3202,5,98,0, - 0,3201,3203,3,710,355,0,3202,3201,1,0,0,0,3202,3203,1,0,0,0,3203, - 3205,1,0,0,0,3204,3206,3,286,143,0,3205,3204,1,0,0,0,3205,3206,1, - 0,0,0,3206,3256,1,0,0,0,3207,3209,5,98,0,0,3208,3210,3,220,110,0, - 3209,3208,1,0,0,0,3209,3210,1,0,0,0,3210,3211,1,0,0,0,3211,3256, - 3,284,142,0,3212,3213,5,85,0,0,3213,3215,5,245,0,0,3214,3216,3,710, - 355,0,3215,3214,1,0,0,0,3215,3216,1,0,0,0,3216,3218,1,0,0,0,3217, - 3219,3,286,143,0,3218,3217,1,0,0,0,3218,3219,1,0,0,0,3219,3256,1, - 0,0,0,3220,3221,5,42,0,0,3221,3222,5,2,0,0,3222,3223,3,1212,606, - 0,3223,3225,5,3,0,0,3224,3226,3,238,119,0,3225,3224,1,0,0,0,3225, - 3226,1,0,0,0,3226,3256,1,0,0,0,3227,3228,5,53,0,0,3228,3256,3,1252, - 626,0,3229,3230,5,438,0,0,3230,3231,3,222,111,0,3231,3241,5,36,0, - 0,3232,3234,5,219,0,0,3233,3235,3,314,157,0,3234,3233,1,0,0,0,3234, - 3235,1,0,0,0,3235,3242,1,0,0,0,3236,3237,5,2,0,0,3237,3238,3,1212, - 606,0,3238,3239,5,3,0,0,3239,3240,5,440,0,0,3240,3242,1,0,0,0,3241, - 3232,1,0,0,0,3241,3236,1,0,0,0,3242,3256,1,0,0,0,3243,3244,5,86, - 0,0,3244,3246,3,1412,706,0,3245,3247,3,240,120,0,3246,3245,1,0,0, - 0,3246,3247,1,0,0,0,3247,3249,1,0,0,0,3248,3250,3,250,125,0,3249, - 3248,1,0,0,0,3249,3250,1,0,0,0,3250,3252,1,0,0,0,3251,3253,3,258, - 129,0,3252,3251,1,0,0,0,3252,3253,1,0,0,0,3253,3256,1,0,0,0,3254, - 3256,3,646,323,0,3255,3197,1,0,0,0,3255,3199,1,0,0,0,3255,3200,1, - 0,0,0,3255,3207,1,0,0,0,3255,3212,1,0,0,0,3255,3220,1,0,0,0,3255, - 3227,1,0,0,0,3255,3229,1,0,0,0,3255,3243,1,0,0,0,3255,3254,1,0,0, - 0,3256,219,1,0,0,0,3257,3259,5,273,0,0,3258,3260,5,77,0,0,3259,3258, - 1,0,0,0,3259,3260,1,0,0,0,3260,3261,1,0,0,0,3261,3262,5,56,0,0,3262, - 221,1,0,0,0,3263,3267,5,139,0,0,3264,3265,5,147,0,0,3265,3267,5, - 53,0,0,3266,3263,1,0,0,0,3266,3264,1,0,0,0,3267,223,1,0,0,0,3268, - 3272,5,54,0,0,3269,3270,5,77,0,0,3270,3272,5,54,0,0,3271,3268,1, - 0,0,0,3271,3269,1,0,0,0,3272,225,1,0,0,0,3273,3274,5,69,0,0,3274, - 3275,7,16,0,0,3275,227,1,0,0,0,3276,3277,5,120,0,0,3277,3278,3,1412, - 706,0,3278,3279,3,230,115,0,3279,229,1,0,0,0,3280,3281,7,26,0,0, - 3281,3283,3,232,116,0,3282,3280,1,0,0,0,3283,3286,1,0,0,0,3284,3282, - 1,0,0,0,3284,3285,1,0,0,0,3285,231,1,0,0,0,3286,3284,1,0,0,0,3287, - 3288,7,27,0,0,3288,233,1,0,0,0,3289,3290,5,45,0,0,3290,3291,3,1436, - 718,0,3291,3292,3,236,118,0,3292,3295,1,0,0,0,3293,3295,3,236,118, - 0,3294,3289,1,0,0,0,3294,3293,1,0,0,0,3295,235,1,0,0,0,3296,3297, - 5,42,0,0,3297,3298,5,2,0,0,3298,3299,3,1212,606,0,3299,3300,5,3, - 0,0,3300,3301,3,476,238,0,3301,3383,1,0,0,0,3302,3320,5,98,0,0,3303, - 3304,5,2,0,0,3304,3305,3,244,122,0,3305,3307,5,3,0,0,3306,3308,3, - 248,124,0,3307,3306,1,0,0,0,3307,3308,1,0,0,0,3308,3310,1,0,0,0, - 3309,3311,3,710,355,0,3310,3309,1,0,0,0,3310,3311,1,0,0,0,3311,3313, - 1,0,0,0,3312,3314,3,286,143,0,3313,3312,1,0,0,0,3313,3314,1,0,0, - 0,3314,3315,1,0,0,0,3315,3316,3,476,238,0,3316,3321,1,0,0,0,3317, - 3318,3,288,144,0,3318,3319,3,476,238,0,3319,3321,1,0,0,0,3320,3303, - 1,0,0,0,3320,3317,1,0,0,0,3321,3383,1,0,0,0,3322,3323,5,85,0,0,3323, - 3341,5,245,0,0,3324,3325,5,2,0,0,3325,3326,3,244,122,0,3326,3328, - 5,3,0,0,3327,3329,3,248,124,0,3328,3327,1,0,0,0,3328,3329,1,0,0, - 0,3329,3331,1,0,0,0,3330,3332,3,710,355,0,3331,3330,1,0,0,0,3331, - 3332,1,0,0,0,3332,3334,1,0,0,0,3333,3335,3,286,143,0,3334,3333,1, - 0,0,0,3334,3335,1,0,0,0,3335,3336,1,0,0,0,3336,3337,3,476,238,0, - 3337,3342,1,0,0,0,3338,3339,3,288,144,0,3339,3340,3,476,238,0,3340, - 3342,1,0,0,0,3341,3324,1,0,0,0,3341,3338,1,0,0,0,3342,3383,1,0,0, - 0,3343,3345,5,199,0,0,3344,3346,3,634,317,0,3345,3344,1,0,0,0,3345, - 3346,1,0,0,0,3346,3347,1,0,0,0,3347,3348,5,2,0,0,3348,3349,3,252, - 126,0,3349,3351,5,3,0,0,3350,3352,3,248,124,0,3351,3350,1,0,0,0, - 3351,3352,1,0,0,0,3352,3354,1,0,0,0,3353,3355,3,710,355,0,3354,3353, - 1,0,0,0,3354,3355,1,0,0,0,3355,3357,1,0,0,0,3356,3358,3,286,143, - 0,3357,3356,1,0,0,0,3357,3358,1,0,0,0,3358,3360,1,0,0,0,3359,3361, - 3,256,128,0,3360,3359,1,0,0,0,3360,3361,1,0,0,0,3361,3362,1,0,0, - 0,3362,3363,3,476,238,0,3363,3383,1,0,0,0,3364,3365,5,63,0,0,3365, - 3366,5,245,0,0,3366,3367,5,2,0,0,3367,3368,3,244,122,0,3368,3369, - 5,3,0,0,3369,3370,5,86,0,0,3370,3372,3,1412,706,0,3371,3373,3,240, - 120,0,3372,3371,1,0,0,0,3372,3373,1,0,0,0,3373,3375,1,0,0,0,3374, - 3376,3,250,125,0,3375,3374,1,0,0,0,3375,3376,1,0,0,0,3376,3378,1, - 0,0,0,3377,3379,3,258,129,0,3378,3377,1,0,0,0,3378,3379,1,0,0,0, - 3379,3380,1,0,0,0,3380,3381,3,476,238,0,3381,3383,1,0,0,0,3382,3296, - 1,0,0,0,3382,3302,1,0,0,0,3382,3322,1,0,0,0,3382,3343,1,0,0,0,3382, - 3364,1,0,0,0,3383,237,1,0,0,0,3384,3385,5,269,0,0,3385,3386,5,228, - 0,0,3386,239,1,0,0,0,3387,3388,5,2,0,0,3388,3389,3,244,122,0,3389, - 3390,5,3,0,0,3390,241,1,0,0,0,3391,3392,5,2,0,0,3392,3393,3,246, - 123,0,3393,3394,5,3,0,0,3394,243,1,0,0,0,3395,3400,3,1432,716,0, - 3396,3397,5,6,0,0,3397,3399,3,1432,716,0,3398,3396,1,0,0,0,3399, - 3402,1,0,0,0,3400,3398,1,0,0,0,3400,3401,1,0,0,0,3401,245,1,0,0, - 0,3402,3400,1,0,0,0,3403,3408,3,1434,717,0,3404,3405,5,6,0,0,3405, - 3407,3,1434,717,0,3406,3404,1,0,0,0,3407,3410,1,0,0,0,3408,3406, - 1,0,0,0,3408,3409,1,0,0,0,3409,247,1,0,0,0,3410,3408,1,0,0,0,3411, - 3412,5,441,0,0,3412,3413,5,2,0,0,3413,3414,3,244,122,0,3414,3415, - 5,3,0,0,3415,249,1,0,0,0,3416,3417,5,258,0,0,3417,3418,7,28,0,0, - 3418,251,1,0,0,0,3419,3424,3,254,127,0,3420,3421,5,6,0,0,3421,3423, - 3,254,127,0,3422,3420,1,0,0,0,3423,3426,1,0,0,0,3424,3422,1,0,0, - 0,3424,3425,1,0,0,0,3425,253,1,0,0,0,3426,3424,1,0,0,0,3427,3428, - 3,640,320,0,3428,3435,5,105,0,0,3429,3436,3,732,366,0,3430,3431, - 5,278,0,0,3431,3432,5,2,0,0,3432,3433,3,732,366,0,3433,3434,5,3, - 0,0,3434,3436,1,0,0,0,3435,3429,1,0,0,0,3435,3430,1,0,0,0,3436,255, - 1,0,0,0,3437,3438,5,103,0,0,3438,3439,5,2,0,0,3439,3440,3,1212,606, - 0,3440,3441,5,3,0,0,3441,257,1,0,0,0,3442,3451,3,260,130,0,3443, - 3451,3,262,131,0,3444,3445,3,260,130,0,3445,3446,3,262,131,0,3446, - 3451,1,0,0,0,3447,3448,3,262,131,0,3448,3449,3,260,130,0,3449,3451, - 1,0,0,0,3450,3442,1,0,0,0,3450,3443,1,0,0,0,3450,3444,1,0,0,0,3450, - 3447,1,0,0,0,3451,259,1,0,0,0,3452,3453,5,80,0,0,3453,3454,5,369, - 0,0,3454,3455,3,264,132,0,3455,261,1,0,0,0,3456,3457,5,80,0,0,3457, - 3458,5,182,0,0,3458,3459,3,264,132,0,3459,263,1,0,0,0,3460,3461, - 5,269,0,0,3461,3470,5,132,0,0,3462,3470,5,315,0,0,3463,3470,5,150, - 0,0,3464,3465,5,333,0,0,3465,3467,7,29,0,0,3466,3468,3,244,122,0, - 3467,3466,1,0,0,0,3467,3468,1,0,0,0,3468,3470,1,0,0,0,3469,3460, - 1,0,0,0,3469,3462,1,0,0,0,3469,3463,1,0,0,0,3469,3464,1,0,0,0,3470, - 265,1,0,0,0,3471,3472,5,238,0,0,3472,3473,5,2,0,0,3473,3474,3,1390, - 695,0,3474,3475,5,3,0,0,3475,267,1,0,0,0,3476,3477,3,270,135,0,3477, - 269,1,0,0,0,3478,3479,5,285,0,0,3479,3480,5,147,0,0,3480,3481,3, - 1474,737,0,3481,3482,5,2,0,0,3482,3483,3,272,136,0,3483,3484,5,3, - 0,0,3484,271,1,0,0,0,3485,3490,3,274,137,0,3486,3487,5,6,0,0,3487, - 3489,3,274,137,0,3488,3486,1,0,0,0,3489,3492,1,0,0,0,3490,3488,1, - 0,0,0,3490,3491,1,0,0,0,3491,273,1,0,0,0,3492,3490,1,0,0,0,3493, - 3495,3,1432,716,0,3494,3496,3,646,323,0,3495,3494,1,0,0,0,3495,3496, - 1,0,0,0,3496,3498,1,0,0,0,3497,3499,3,648,324,0,3498,3497,1,0,0, - 0,3498,3499,1,0,0,0,3499,3517,1,0,0,0,3500,3502,3,1262,631,0,3501, - 3503,3,646,323,0,3502,3501,1,0,0,0,3502,3503,1,0,0,0,3503,3505,1, - 0,0,0,3504,3506,3,648,324,0,3505,3504,1,0,0,0,3505,3506,1,0,0,0, - 3506,3517,1,0,0,0,3507,3508,5,2,0,0,3508,3509,3,1212,606,0,3509, - 3511,5,3,0,0,3510,3512,3,646,323,0,3511,3510,1,0,0,0,3511,3512,1, - 0,0,0,3512,3514,1,0,0,0,3513,3515,3,648,324,0,3514,3513,1,0,0,0, - 3514,3515,1,0,0,0,3515,3517,1,0,0,0,3516,3493,1,0,0,0,3516,3500, - 1,0,0,0,3516,3507,1,0,0,0,3517,275,1,0,0,0,3518,3519,5,100,0,0,3519, - 3520,3,1436,718,0,3520,277,1,0,0,0,3521,3522,5,105,0,0,3522,3528, - 3,132,66,0,3523,3524,5,379,0,0,3524,3528,5,277,0,0,3525,3526,5,105, - 0,0,3526,3528,5,277,0,0,3527,3521,1,0,0,0,3527,3523,1,0,0,0,3527, - 3525,1,0,0,0,3528,279,1,0,0,0,3529,3530,5,80,0,0,3530,3536,5,161, - 0,0,3531,3537,5,191,0,0,3532,3533,5,182,0,0,3533,3537,5,320,0,0, - 3534,3535,5,292,0,0,3535,3537,5,320,0,0,3536,3531,1,0,0,0,3536,3532, - 1,0,0,0,3536,3534,1,0,0,0,3537,281,1,0,0,0,3538,3539,5,351,0,0,3539, - 3540,3,1402,701,0,3540,283,1,0,0,0,3541,3543,3,642,321,0,3542,3541, - 1,0,0,0,3542,3543,1,0,0,0,3543,3545,1,0,0,0,3544,3546,3,1014,507, - 0,3545,3544,1,0,0,0,3545,3546,1,0,0,0,3546,3548,1,0,0,0,3547,3549, - 3,286,143,0,3548,3547,1,0,0,0,3548,3549,1,0,0,0,3549,285,1,0,0,0, - 3550,3551,5,100,0,0,3551,3552,5,226,0,0,3552,3553,5,351,0,0,3553, - 3554,3,1402,701,0,3554,287,1,0,0,0,3555,3556,5,100,0,0,3556,3557, - 5,226,0,0,3557,3558,3,1436,718,0,3558,289,1,0,0,0,3559,3560,5,46, - 0,0,3560,3565,5,342,0,0,3561,3563,3,516,258,0,3562,3561,1,0,0,0, - 3562,3563,1,0,0,0,3563,3564,1,0,0,0,3564,3566,3,558,279,0,3565,3562, - 1,0,0,0,3565,3566,1,0,0,0,3566,3568,1,0,0,0,3567,3569,3,918,459, - 0,3568,3567,1,0,0,0,3568,3569,1,0,0,0,3569,3570,1,0,0,0,3570,3573, - 5,80,0,0,3571,3574,3,1332,666,0,3572,3574,3,1328,664,0,3573,3571, - 1,0,0,0,3573,3572,1,0,0,0,3574,3575,1,0,0,0,3575,3576,5,64,0,0,3576, - 3577,3,1104,552,0,3577,291,1,0,0,0,3578,3579,5,138,0,0,3579,3581, - 5,342,0,0,3580,3582,3,748,374,0,3581,3580,1,0,0,0,3581,3582,1,0, - 0,0,3582,3583,1,0,0,0,3583,3584,3,558,279,0,3584,3585,5,333,0,0, - 3585,3586,5,342,0,0,3586,3587,3,1464,732,0,3587,293,1,0,0,0,3588, - 3590,5,46,0,0,3589,3591,3,190,95,0,3590,3589,1,0,0,0,3590,3591,1, - 0,0,0,3591,3592,1,0,0,0,3592,3594,5,92,0,0,3593,3595,3,516,258,0, - 3594,3593,1,0,0,0,3594,3595,1,0,0,0,3595,3596,1,0,0,0,3596,3597, - 3,296,148,0,3597,3598,5,36,0,0,3598,3600,3,1000,500,0,3599,3601, - 3,298,149,0,3600,3599,1,0,0,0,3600,3601,1,0,0,0,3601,295,1,0,0,0, - 3602,3604,3,1404,702,0,3603,3605,3,242,121,0,3604,3603,1,0,0,0,3604, - 3605,1,0,0,0,3605,3607,1,0,0,0,3606,3608,3,276,138,0,3607,3606,1, - 0,0,0,3607,3608,1,0,0,0,3608,3610,1,0,0,0,3609,3611,3,278,139,0, - 3610,3609,1,0,0,0,3610,3611,1,0,0,0,3611,3613,1,0,0,0,3612,3614, - 3,280,140,0,3613,3612,1,0,0,0,3613,3614,1,0,0,0,3614,3616,1,0,0, - 0,3615,3617,3,282,141,0,3616,3615,1,0,0,0,3616,3617,1,0,0,0,3617, - 297,1,0,0,0,3618,3622,5,105,0,0,3619,3623,5,174,0,0,3620,3621,5, - 269,0,0,3621,3623,5,174,0,0,3622,3619,1,0,0,0,3622,3620,1,0,0,0, - 3623,299,1,0,0,0,3624,3626,5,46,0,0,3625,3627,3,304,152,0,3626,3625, - 1,0,0,0,3626,3627,1,0,0,0,3627,3628,1,0,0,0,3628,3629,5,259,0,0, - 3629,3631,5,376,0,0,3630,3632,3,516,258,0,3631,3630,1,0,0,0,3631, - 3632,1,0,0,0,3632,3633,1,0,0,0,3633,3634,3,302,151,0,3634,3635,5, - 36,0,0,3635,3637,3,1000,500,0,3636,3638,3,298,149,0,3637,3636,1, - 0,0,0,3637,3638,1,0,0,0,3638,301,1,0,0,0,3639,3641,3,1408,704,0, - 3640,3642,3,242,121,0,3641,3640,1,0,0,0,3641,3642,1,0,0,0,3642,3644, - 1,0,0,0,3643,3645,3,276,138,0,3644,3643,1,0,0,0,3644,3645,1,0,0, - 0,3645,3647,1,0,0,0,3646,3648,3,134,67,0,3647,3646,1,0,0,0,3647, - 3648,1,0,0,0,3648,3650,1,0,0,0,3649,3651,3,282,141,0,3650,3649,1, - 0,0,0,3650,3651,1,0,0,0,3651,303,1,0,0,0,3652,3653,5,367,0,0,3653, - 305,1,0,0,0,3654,3655,5,305,0,0,3655,3656,5,259,0,0,3656,3658,5, - 376,0,0,3657,3659,3,630,315,0,3658,3657,1,0,0,0,3658,3659,1,0,0, - 0,3659,3660,1,0,0,0,3660,3662,3,1410,705,0,3661,3663,3,298,149,0, - 3662,3661,1,0,0,0,3662,3663,1,0,0,0,3663,307,1,0,0,0,3664,3666,5, - 46,0,0,3665,3667,3,190,95,0,3666,3665,1,0,0,0,3666,3667,1,0,0,0, - 3667,3668,1,0,0,0,3668,3670,5,328,0,0,3669,3671,3,516,258,0,3670, - 3669,1,0,0,0,3670,3671,1,0,0,0,3671,3672,1,0,0,0,3672,3674,3,1412, - 706,0,3673,3675,3,312,156,0,3674,3673,1,0,0,0,3674,3675,1,0,0,0, - 3675,309,1,0,0,0,3676,3677,5,138,0,0,3677,3679,5,328,0,0,3678,3680, - 3,748,374,0,3679,3678,1,0,0,0,3679,3680,1,0,0,0,3680,3681,1,0,0, - 0,3681,3682,3,1412,706,0,3682,3683,3,316,158,0,3683,311,1,0,0,0, - 3684,3685,3,316,158,0,3685,313,1,0,0,0,3686,3687,5,2,0,0,3687,3688, - 3,316,158,0,3688,3689,5,3,0,0,3689,315,1,0,0,0,3690,3692,3,318,159, - 0,3691,3690,1,0,0,0,3692,3693,1,0,0,0,3693,3691,1,0,0,0,3693,3694, - 1,0,0,0,3694,317,1,0,0,0,3695,3696,5,36,0,0,3696,3730,3,1172,586, - 0,3697,3698,5,148,0,0,3698,3730,3,322,161,0,3699,3730,5,173,0,0, - 3700,3702,5,225,0,0,3701,3703,3,320,160,0,3702,3701,1,0,0,0,3702, - 3703,1,0,0,0,3703,3704,1,0,0,0,3704,3730,3,322,161,0,3705,3706,5, - 260,0,0,3706,3730,3,322,161,0,3707,3708,5,262,0,0,3708,3730,3,322, - 161,0,3709,3710,5,269,0,0,3710,3730,7,30,0,0,3711,3712,5,281,0,0, - 3712,3713,5,147,0,0,3713,3730,3,1432,716,0,3714,3715,5,328,0,0,3715, - 3716,5,266,0,0,3716,3730,3,558,279,0,3717,3719,5,340,0,0,3718,3720, - 3,14,7,0,3719,3718,1,0,0,0,3719,3720,1,0,0,0,3720,3721,1,0,0,0,3721, - 3730,3,322,161,0,3722,3724,5,314,0,0,3723,3725,3,14,7,0,3724,3723, - 1,0,0,0,3724,3725,1,0,0,0,3725,3727,1,0,0,0,3726,3728,3,322,161, - 0,3727,3726,1,0,0,0,3727,3728,1,0,0,0,3728,3730,1,0,0,0,3729,3695, - 1,0,0,0,3729,3697,1,0,0,0,3729,3699,1,0,0,0,3729,3700,1,0,0,0,3729, - 3705,1,0,0,0,3729,3707,1,0,0,0,3729,3709,1,0,0,0,3729,3711,1,0,0, - 0,3729,3714,1,0,0,0,3729,3717,1,0,0,0,3729,3722,1,0,0,0,3730,319, - 1,0,0,0,3731,3732,5,147,0,0,3732,321,1,0,0,0,3733,3740,3,1454,727, - 0,3734,3735,5,12,0,0,3735,3740,3,1454,727,0,3736,3737,5,13,0,0,3737, - 3740,3,1454,727,0,3738,3740,3,1464,732,0,3739,3733,1,0,0,0,3739, - 3734,1,0,0,0,3739,3736,1,0,0,0,3739,3738,1,0,0,0,3740,323,1,0,0, - 0,3741,3746,3,322,161,0,3742,3743,5,6,0,0,3743,3745,3,322,161,0, - 3744,3742,1,0,0,0,3745,3748,1,0,0,0,3746,3744,1,0,0,0,3746,3747, - 1,0,0,0,3747,325,1,0,0,0,3748,3746,1,0,0,0,3749,3751,5,46,0,0,3750, - 3752,3,658,329,0,3751,3750,1,0,0,0,3751,3752,1,0,0,0,3752,3754,1, - 0,0,0,3753,3755,3,328,164,0,3754,3753,1,0,0,0,3754,3755,1,0,0,0, - 3755,3757,1,0,0,0,3756,3758,3,338,169,0,3757,3756,1,0,0,0,3757,3758, - 1,0,0,0,3758,3759,1,0,0,0,3759,3760,5,247,0,0,3760,3769,3,1436,718, - 0,3761,3762,5,215,0,0,3762,3764,3,330,165,0,3763,3765,3,332,166, - 0,3764,3763,1,0,0,0,3764,3765,1,0,0,0,3765,3767,1,0,0,0,3766,3768, - 3,336,168,0,3767,3766,1,0,0,0,3767,3768,1,0,0,0,3768,3770,1,0,0, - 0,3769,3761,1,0,0,0,3769,3770,1,0,0,0,3770,327,1,0,0,0,3771,3772, - 5,359,0,0,3772,329,1,0,0,0,3773,3775,3,1436,718,0,3774,3776,3,560, - 280,0,3775,3774,1,0,0,0,3775,3776,1,0,0,0,3776,331,1,0,0,0,3777, - 3778,5,239,0,0,3778,3779,3,330,165,0,3779,333,1,0,0,0,3780,3781, - 5,373,0,0,3781,3785,3,330,165,0,3782,3783,5,269,0,0,3783,3785,5, - 373,0,0,3784,3780,1,0,0,0,3784,3782,1,0,0,0,3785,335,1,0,0,0,3786, - 3787,3,334,167,0,3787,337,1,0,0,0,3788,3789,5,295,0,0,3789,339,1, - 0,0,0,3790,3791,5,46,0,0,3791,3792,5,351,0,0,3792,3794,3,1402,701, - 0,3793,3795,3,342,171,0,3794,3793,1,0,0,0,3794,3795,1,0,0,0,3795, - 3796,1,0,0,0,3796,3797,5,255,0,0,3797,3799,3,1458,729,0,3798,3800, - 3,134,67,0,3799,3798,1,0,0,0,3799,3800,1,0,0,0,3800,341,1,0,0,0, - 3801,3802,5,282,0,0,3802,3803,3,1470,735,0,3803,343,1,0,0,0,3804, - 3805,5,46,0,0,3805,3807,5,204,0,0,3806,3808,3,516,258,0,3807,3806, - 1,0,0,0,3807,3808,1,0,0,0,3808,3809,1,0,0,0,3809,3811,3,1436,718, - 0,3810,3812,3,14,7,0,3811,3810,1,0,0,0,3811,3812,1,0,0,0,3812,3813, - 1,0,0,0,3813,3814,3,346,173,0,3814,345,1,0,0,0,3815,3817,3,348,174, - 0,3816,3815,1,0,0,0,3817,3820,1,0,0,0,3818,3816,1,0,0,0,3818,3819, - 1,0,0,0,3819,347,1,0,0,0,3820,3818,1,0,0,0,3821,3822,5,323,0,0,3822, - 3829,3,1422,711,0,3823,3824,5,375,0,0,3824,3829,3,80,40,0,3825,3826, - 5,64,0,0,3826,3829,3,80,40,0,3827,3829,5,150,0,0,3828,3821,1,0,0, - 0,3828,3823,1,0,0,0,3828,3825,1,0,0,0,3828,3827,1,0,0,0,3829,349, - 1,0,0,0,3830,3831,5,138,0,0,3831,3832,5,204,0,0,3832,3833,3,1436, - 718,0,3833,3834,5,369,0,0,3834,3835,3,352,176,0,3835,351,1,0,0,0, - 3836,3838,3,354,177,0,3837,3836,1,0,0,0,3838,3841,1,0,0,0,3839,3837, - 1,0,0,0,3839,3840,1,0,0,0,3840,353,1,0,0,0,3841,3839,1,0,0,0,3842, - 3843,5,94,0,0,3843,3844,3,80,40,0,3844,355,1,0,0,0,3845,3846,5,138, - 0,0,3846,3847,5,204,0,0,3847,3848,3,1436,718,0,3848,3849,3,44,22, - 0,3849,3850,3,548,274,0,3850,3948,1,0,0,0,3851,3852,5,138,0,0,3852, - 3853,5,204,0,0,3853,3854,3,1436,718,0,3854,3855,3,44,22,0,3855,3856, - 3,546,273,0,3856,3948,1,0,0,0,3857,3858,5,138,0,0,3858,3859,5,204, - 0,0,3859,3860,3,1436,718,0,3860,3861,3,44,22,0,3861,3862,5,136,0, - 0,3862,3863,3,698,349,0,3863,3948,1,0,0,0,3864,3865,5,138,0,0,3865, - 3866,5,204,0,0,3866,3867,3,1436,718,0,3867,3868,3,44,22,0,3868,3869, - 5,41,0,0,3869,3870,5,2,0,0,3870,3871,3,1168,584,0,3871,3872,5,36, - 0,0,3872,3873,3,1168,584,0,3873,3874,5,3,0,0,3874,3948,1,0,0,0,3875, - 3876,5,138,0,0,3876,3877,5,204,0,0,3877,3878,3,1436,718,0,3878,3879, - 3,44,22,0,3879,3880,5,189,0,0,3880,3881,3,1168,584,0,3881,3948,1, - 0,0,0,3882,3883,5,138,0,0,3883,3884,5,204,0,0,3884,3885,3,1436,718, - 0,3885,3886,3,44,22,0,3886,3887,5,211,0,0,3887,3888,3,674,337,0, - 3888,3948,1,0,0,0,3889,3890,5,138,0,0,3890,3891,5,204,0,0,3891,3892, - 3,1436,718,0,3892,3893,3,44,22,0,3893,3894,5,278,0,0,3894,3895,3, - 736,368,0,3895,3948,1,0,0,0,3896,3897,5,138,0,0,3897,3898,5,204, - 0,0,3898,3899,3,1436,718,0,3899,3900,3,44,22,0,3900,3901,5,278,0, - 0,3901,3902,5,156,0,0,3902,3903,3,558,279,0,3903,3904,5,100,0,0, - 3904,3905,3,1436,718,0,3905,3948,1,0,0,0,3906,3907,5,138,0,0,3907, - 3908,5,204,0,0,3908,3909,3,1436,718,0,3909,3910,3,44,22,0,3910,3911, - 5,278,0,0,3911,3912,5,206,0,0,3912,3913,3,558,279,0,3913,3914,5, - 100,0,0,3914,3915,3,1436,718,0,3915,3948,1,0,0,0,3916,3917,5,138, - 0,0,3917,3918,5,204,0,0,3918,3919,3,1436,718,0,3919,3920,3,44,22, - 0,3920,3921,5,296,0,0,3921,3922,3,670,335,0,3922,3948,1,0,0,0,3923, - 3924,5,138,0,0,3924,3925,5,204,0,0,3925,3926,3,1436,718,0,3926,3927, - 3,44,22,0,3927,3928,5,442,0,0,3928,3929,3,666,333,0,3929,3948,1, - 0,0,0,3930,3931,5,138,0,0,3931,3932,5,204,0,0,3932,3933,3,1436,718, - 0,3933,3934,3,44,22,0,3934,3935,5,443,0,0,3935,3936,5,62,0,0,3936, - 3937,3,1168,584,0,3937,3938,5,247,0,0,3938,3939,3,1436,718,0,3939, - 3948,1,0,0,0,3940,3941,5,138,0,0,3941,3942,5,204,0,0,3942,3943,3, - 1436,718,0,3943,3944,3,44,22,0,3944,3945,5,360,0,0,3945,3946,3,1168, - 584,0,3946,3948,1,0,0,0,3947,3845,1,0,0,0,3947,3851,1,0,0,0,3947, - 3857,1,0,0,0,3947,3864,1,0,0,0,3947,3875,1,0,0,0,3947,3882,1,0,0, - 0,3947,3889,1,0,0,0,3947,3896,1,0,0,0,3947,3906,1,0,0,0,3947,3916, - 1,0,0,0,3947,3923,1,0,0,0,3947,3930,1,0,0,0,3947,3940,1,0,0,0,3948, - 357,1,0,0,0,3949,3950,5,46,0,0,3950,3951,5,63,0,0,3951,3952,5,174, - 0,0,3952,3953,5,381,0,0,3953,3955,3,1436,718,0,3954,3956,3,364,182, - 0,3955,3954,1,0,0,0,3955,3956,1,0,0,0,3956,3958,1,0,0,0,3957,3959, - 3,368,184,0,3958,3957,1,0,0,0,3958,3959,1,0,0,0,3959,359,1,0,0,0, - 3960,3961,5,215,0,0,3961,3969,3,330,165,0,3962,3963,5,269,0,0,3963, - 3969,5,215,0,0,3964,3965,5,373,0,0,3965,3969,3,330,165,0,3966,3967, - 5,269,0,0,3967,3969,5,373,0,0,3968,3960,1,0,0,0,3968,3962,1,0,0, - 0,3968,3964,1,0,0,0,3968,3966,1,0,0,0,3969,361,1,0,0,0,3970,3972, - 3,360,180,0,3971,3970,1,0,0,0,3972,3973,1,0,0,0,3973,3971,1,0,0, - 0,3973,3974,1,0,0,0,3974,363,1,0,0,0,3975,3976,3,362,181,0,3976, - 365,1,0,0,0,3977,3978,5,138,0,0,3978,3979,5,63,0,0,3979,3980,5,174, - 0,0,3980,3981,5,381,0,0,3981,3983,3,1436,718,0,3982,3984,3,364,182, - 0,3983,3982,1,0,0,0,3983,3984,1,0,0,0,3984,3985,1,0,0,0,3985,3986, - 3,372,186,0,3986,3995,1,0,0,0,3987,3988,5,138,0,0,3988,3989,5,63, - 0,0,3989,3990,5,174,0,0,3990,3991,5,381,0,0,3991,3992,3,1436,718, - 0,3992,3993,3,362,181,0,3993,3995,1,0,0,0,3994,3977,1,0,0,0,3994, - 3987,1,0,0,0,3995,367,1,0,0,0,3996,3997,5,280,0,0,3997,3998,5,2, - 0,0,3998,3999,3,370,185,0,3999,4000,5,3,0,0,4000,369,1,0,0,0,4001, - 4006,3,378,189,0,4002,4003,5,6,0,0,4003,4005,3,378,189,0,4004,4002, - 1,0,0,0,4005,4008,1,0,0,0,4006,4004,1,0,0,0,4006,4007,1,0,0,0,4007, - 371,1,0,0,0,4008,4006,1,0,0,0,4009,4010,5,280,0,0,4010,4011,5,2, - 0,0,4011,4012,3,374,187,0,4012,4013,5,3,0,0,4013,373,1,0,0,0,4014, - 4019,3,376,188,0,4015,4016,5,6,0,0,4016,4018,3,376,188,0,4017,4015, - 1,0,0,0,4018,4021,1,0,0,0,4019,4017,1,0,0,0,4019,4020,1,0,0,0,4020, - 375,1,0,0,0,4021,4019,1,0,0,0,4022,4030,3,378,189,0,4023,4024,5, - 333,0,0,4024,4030,3,378,189,0,4025,4026,5,133,0,0,4026,4030,3,378, - 189,0,4027,4028,5,191,0,0,4028,4030,3,378,189,0,4029,4022,1,0,0, - 0,4029,4023,1,0,0,0,4029,4025,1,0,0,0,4029,4027,1,0,0,0,4030,377, - 1,0,0,0,4031,4032,3,380,190,0,4032,4033,3,382,191,0,4033,379,1,0, - 0,0,4034,4035,3,1490,745,0,4035,381,1,0,0,0,4036,4037,3,1458,729, - 0,4037,383,1,0,0,0,4038,4039,5,46,0,0,4039,4041,5,331,0,0,4040,4042, - 3,516,258,0,4041,4040,1,0,0,0,4041,4042,1,0,0,0,4042,4043,1,0,0, - 0,4043,4045,3,1436,718,0,4044,4046,3,386,193,0,4045,4044,1,0,0,0, - 4045,4046,1,0,0,0,4046,4048,1,0,0,0,4047,4049,3,390,195,0,4048,4047, - 1,0,0,0,4048,4049,1,0,0,0,4049,4050,1,0,0,0,4050,4051,5,63,0,0,4051, - 4052,5,174,0,0,4052,4053,5,381,0,0,4053,4055,3,1436,718,0,4054,4056, - 3,368,184,0,4055,4054,1,0,0,0,4055,4056,1,0,0,0,4056,385,1,0,0,0, - 4057,4058,5,360,0,0,4058,4059,3,1458,729,0,4059,387,1,0,0,0,4060, - 4063,5,375,0,0,4061,4064,3,1458,729,0,4062,4064,5,78,0,0,4063,4061, - 1,0,0,0,4063,4062,1,0,0,0,4064,389,1,0,0,0,4065,4066,3,388,194,0, - 4066,391,1,0,0,0,4067,4068,5,138,0,0,4068,4069,5,331,0,0,4069,4075, - 3,1436,718,0,4070,4076,3,372,186,0,4071,4073,3,388,194,0,4072,4074, - 3,372,186,0,4073,4072,1,0,0,0,4073,4074,1,0,0,0,4074,4076,1,0,0, - 0,4075,4070,1,0,0,0,4075,4071,1,0,0,0,4076,393,1,0,0,0,4077,4078, - 5,46,0,0,4078,4079,5,63,0,0,4079,4081,5,92,0,0,4080,4082,3,516,258, - 0,4081,4080,1,0,0,0,4081,4082,1,0,0,0,4082,4083,1,0,0,0,4083,4084, - 3,1404,702,0,4084,4086,5,2,0,0,4085,4087,3,194,97,0,4086,4085,1, - 0,0,0,4086,4087,1,0,0,0,4087,4088,1,0,0,0,4088,4090,5,3,0,0,4089, - 4091,3,266,133,0,4090,4089,1,0,0,0,4090,4091,1,0,0,0,4091,4092,1, - 0,0,0,4092,4093,5,331,0,0,4093,4095,3,1436,718,0,4094,4096,3,368, - 184,0,4095,4094,1,0,0,0,4095,4096,1,0,0,0,4096,4117,1,0,0,0,4097, - 4098,5,46,0,0,4098,4099,5,63,0,0,4099,4101,5,92,0,0,4100,4102,3, - 516,258,0,4101,4100,1,0,0,0,4101,4102,1,0,0,0,4102,4103,1,0,0,0, - 4103,4104,3,1404,702,0,4104,4105,5,285,0,0,4105,4106,5,275,0,0,4106, - 4108,3,1406,703,0,4107,4109,3,196,98,0,4108,4107,1,0,0,0,4108,4109, - 1,0,0,0,4109,4110,1,0,0,0,4110,4111,3,144,72,0,4111,4112,5,331,0, - 0,4112,4114,3,1436,718,0,4113,4115,3,368,184,0,4114,4113,1,0,0,0, - 4114,4115,1,0,0,0,4115,4117,1,0,0,0,4116,4077,1,0,0,0,4116,4097, - 1,0,0,0,4117,395,1,0,0,0,4118,4119,5,444,0,0,4119,4120,5,63,0,0, - 4120,4121,5,323,0,0,4121,4123,3,1422,711,0,4122,4124,3,400,200,0, - 4123,4122,1,0,0,0,4123,4124,1,0,0,0,4124,4125,1,0,0,0,4125,4126, - 5,64,0,0,4126,4127,5,331,0,0,4127,4128,3,1436,718,0,4128,4129,5, - 71,0,0,4129,4131,3,1436,718,0,4130,4132,3,368,184,0,4131,4130,1, - 0,0,0,4131,4132,1,0,0,0,4132,397,1,0,0,0,4133,4134,5,74,0,0,4134, - 4137,5,94,0,0,4135,4137,5,59,0,0,4136,4133,1,0,0,0,4136,4135,1,0, - 0,0,4137,399,1,0,0,0,4138,4139,3,398,199,0,4139,4140,5,2,0,0,4140, - 4141,3,1124,562,0,4141,4142,5,3,0,0,4142,401,1,0,0,0,4143,4144,5, - 46,0,0,4144,4145,5,99,0,0,4145,4147,5,257,0,0,4146,4148,3,516,258, - 0,4147,4146,1,0,0,0,4147,4148,1,0,0,0,4148,4149,1,0,0,0,4149,4150, - 5,62,0,0,4150,4151,3,404,202,0,4151,4152,5,331,0,0,4152,4154,3,1436, - 718,0,4153,4155,3,368,184,0,4154,4153,1,0,0,0,4154,4155,1,0,0,0, - 4155,403,1,0,0,0,4156,4159,3,1470,735,0,4157,4159,5,99,0,0,4158, - 4156,1,0,0,0,4158,4157,1,0,0,0,4159,405,1,0,0,0,4160,4161,5,138, - 0,0,4161,4162,5,99,0,0,4162,4163,5,257,0,0,4163,4164,5,62,0,0,4164, - 4165,3,404,202,0,4165,4166,5,331,0,0,4166,4167,3,1436,718,0,4167, - 4168,3,372,186,0,4168,407,1,0,0,0,4169,4170,5,46,0,0,4170,4171,5, - 445,0,0,4171,4172,3,1436,718,0,4172,4173,5,80,0,0,4173,4175,3,1412, - 706,0,4174,4176,3,426,213,0,4175,4174,1,0,0,0,4175,4176,1,0,0,0, - 4176,4178,1,0,0,0,4177,4179,3,428,214,0,4178,4177,1,0,0,0,4178,4179, - 1,0,0,0,4179,4181,1,0,0,0,4180,4182,3,422,211,0,4181,4180,1,0,0, - 0,4181,4182,1,0,0,0,4182,4184,1,0,0,0,4183,4185,3,418,209,0,4184, - 4183,1,0,0,0,4184,4185,1,0,0,0,4185,4187,1,0,0,0,4186,4188,3,420, - 210,0,4187,4186,1,0,0,0,4187,4188,1,0,0,0,4188,409,1,0,0,0,4189, - 4190,5,138,0,0,4190,4191,5,445,0,0,4191,4192,3,1436,718,0,4192,4193, - 5,80,0,0,4193,4195,3,1412,706,0,4194,4196,3,424,212,0,4195,4194, - 1,0,0,0,4195,4196,1,0,0,0,4196,4198,1,0,0,0,4197,4199,3,418,209, - 0,4198,4197,1,0,0,0,4198,4199,1,0,0,0,4199,4201,1,0,0,0,4200,4202, - 3,420,210,0,4201,4200,1,0,0,0,4201,4202,1,0,0,0,4202,411,1,0,0,0, - 4203,4204,5,138,0,0,4204,4205,5,296,0,0,4205,4207,3,1428,714,0,4206, - 4208,3,660,330,0,4207,4206,1,0,0,0,4207,4208,1,0,0,0,4208,4209,1, - 0,0,0,4209,4210,3,414,207,0,4210,413,1,0,0,0,4211,4215,3,416,208, - 0,4212,4214,3,416,208,0,4213,4212,1,0,0,0,4214,4217,1,0,0,0,4215, - 4213,1,0,0,0,4215,4216,1,0,0,0,4216,4219,1,0,0,0,4217,4215,1,0,0, - 0,4218,4220,5,315,0,0,4219,4218,1,0,0,0,4219,4220,1,0,0,0,4220,4238, - 1,0,0,0,4221,4222,5,309,0,0,4222,4223,5,94,0,0,4223,4238,3,1430, - 715,0,4224,4225,5,282,0,0,4225,4226,5,94,0,0,4226,4238,3,1470,735, - 0,4227,4228,5,333,0,0,4228,4229,5,323,0,0,4229,4238,3,48,24,0,4230, - 4232,5,269,0,0,4231,4230,1,0,0,0,4231,4232,1,0,0,0,4232,4233,1,0, - 0,0,4233,4234,5,462,0,0,4234,4235,5,80,0,0,4235,4236,5,204,0,0,4236, - 4238,3,1436,718,0,4237,4211,1,0,0,0,4237,4221,1,0,0,0,4237,4224, - 1,0,0,0,4237,4227,1,0,0,0,4237,4231,1,0,0,0,4238,415,1,0,0,0,4239, - 4241,5,205,0,0,4240,4239,1,0,0,0,4240,4241,1,0,0,0,4241,4242,1,0, - 0,0,4242,4243,5,327,0,0,4243,4250,5,243,0,0,4244,4246,5,205,0,0, - 4245,4244,1,0,0,0,4245,4246,1,0,0,0,4246,4247,1,0,0,0,4247,4248, - 5,327,0,0,4248,4250,5,181,0,0,4249,4240,1,0,0,0,4249,4245,1,0,0, - 0,4250,4268,1,0,0,0,4251,4252,5,333,0,0,4252,4253,3,1436,718,0,4253, - 4256,7,31,0,0,4254,4257,3,1436,718,0,4255,4257,5,53,0,0,4256,4254, - 1,0,0,0,4256,4255,1,0,0,0,4257,4268,1,0,0,0,4258,4259,5,333,0,0, - 4259,4260,3,1436,718,0,4260,4261,5,64,0,0,4261,4262,5,434,0,0,4262, - 4268,1,0,0,0,4263,4264,5,313,0,0,4264,4268,3,1436,718,0,4265,4266, - 5,313,0,0,4266,4268,5,30,0,0,4267,4249,1,0,0,0,4267,4251,1,0,0,0, - 4267,4258,1,0,0,0,4267,4263,1,0,0,0,4267,4265,1,0,0,0,4268,417,1, - 0,0,0,4269,4270,5,100,0,0,4270,4271,5,2,0,0,4271,4272,3,1212,606, - 0,4272,4273,5,3,0,0,4273,419,1,0,0,0,4274,4275,5,105,0,0,4275,4276, - 5,42,0,0,4276,4277,5,2,0,0,4277,4278,3,1212,606,0,4278,4279,5,3, - 0,0,4279,421,1,0,0,0,4280,4281,5,94,0,0,4281,4282,3,1472,736,0,4282, - 423,1,0,0,0,4283,4284,5,94,0,0,4284,4285,3,1472,736,0,4285,425,1, - 0,0,0,4286,4290,5,36,0,0,4287,4291,5,541,0,0,4288,4291,5,542,0,0, - 4289,4291,3,1492,746,0,4290,4287,1,0,0,0,4290,4288,1,0,0,0,4290, - 4289,1,0,0,0,4291,427,1,0,0,0,4292,4293,5,62,0,0,4293,4294,3,430, - 215,0,4294,429,1,0,0,0,4295,4296,7,32,0,0,4296,431,1,0,0,0,4297, - 4298,5,46,0,0,4298,4299,5,131,0,0,4299,4300,5,446,0,0,4300,4301, - 3,1436,718,0,4301,4302,5,360,0,0,4302,4303,3,434,217,0,4303,4304, - 5,215,0,0,4304,4305,3,330,165,0,4305,433,1,0,0,0,4306,4307,7,33, - 0,0,4307,435,1,0,0,0,4308,4310,5,46,0,0,4309,4311,3,658,329,0,4310, - 4309,1,0,0,0,4310,4311,1,0,0,0,4311,4312,1,0,0,0,4312,4313,5,357, - 0,0,4313,4314,3,1436,718,0,4314,4315,3,438,219,0,4315,4316,3,444, - 222,0,4316,4317,5,80,0,0,4317,4319,3,1406,703,0,4318,4320,3,448, - 224,0,4319,4318,1,0,0,0,4319,4320,1,0,0,0,4320,4322,1,0,0,0,4321, - 4323,3,460,230,0,4322,4321,1,0,0,0,4322,4323,1,0,0,0,4323,4325,1, - 0,0,0,4324,4326,3,466,233,0,4325,4324,1,0,0,0,4325,4326,1,0,0,0, - 4326,4327,1,0,0,0,4327,4328,5,202,0,0,4328,4329,3,468,234,0,4329, - 4330,5,2,0,0,4330,4331,3,470,235,0,4331,4332,5,3,0,0,4332,4363,1, - 0,0,0,4333,4335,5,46,0,0,4334,4336,3,658,329,0,4335,4334,1,0,0,0, - 4335,4336,1,0,0,0,4336,4338,1,0,0,0,4337,4339,5,45,0,0,4338,4337, - 1,0,0,0,4338,4339,1,0,0,0,4339,4340,1,0,0,0,4340,4341,5,357,0,0, - 4341,4342,3,1436,718,0,4342,4343,3,438,219,0,4343,4344,3,444,222, - 0,4344,4345,5,80,0,0,4345,4347,3,1406,703,0,4346,4348,3,474,237, - 0,4347,4346,1,0,0,0,4347,4348,1,0,0,0,4348,4349,1,0,0,0,4349,4351, - 3,476,238,0,4350,4352,3,440,220,0,4351,4350,1,0,0,0,4351,4352,1, - 0,0,0,4352,4354,1,0,0,0,4353,4355,3,466,233,0,4354,4353,1,0,0,0, - 4354,4355,1,0,0,0,4355,4356,1,0,0,0,4356,4357,5,202,0,0,4357,4358, - 3,468,234,0,4358,4359,5,2,0,0,4359,4360,3,470,235,0,4360,4361,5, - 3,0,0,4361,4363,1,0,0,0,4362,4308,1,0,0,0,4362,4333,1,0,0,0,4363, - 437,1,0,0,0,4364,4369,5,145,0,0,4365,4369,5,135,0,0,4366,4367,5, - 242,0,0,4367,4369,5,275,0,0,4368,4364,1,0,0,0,4368,4365,1,0,0,0, - 4368,4366,1,0,0,0,4369,439,1,0,0,0,4370,4372,5,62,0,0,4371,4373, - 5,192,0,0,4372,4371,1,0,0,0,4372,4373,1,0,0,0,4373,4374,1,0,0,0, - 4374,4375,3,442,221,0,4375,441,1,0,0,0,4376,4377,7,34,0,0,4377,443, - 1,0,0,0,4378,4383,3,446,223,0,4379,4380,5,82,0,0,4380,4382,3,446, - 223,0,4381,4379,1,0,0,0,4382,4385,1,0,0,0,4383,4381,1,0,0,0,4383, - 4384,1,0,0,0,4384,445,1,0,0,0,4385,4383,1,0,0,0,4386,4394,5,241, - 0,0,4387,4394,5,182,0,0,4388,4394,5,369,0,0,4389,4390,5,369,0,0, - 4390,4391,5,275,0,0,4391,4394,3,244,122,0,4392,4394,5,358,0,0,4393, - 4386,1,0,0,0,4393,4387,1,0,0,0,4393,4388,1,0,0,0,4393,4389,1,0,0, - 0,4393,4392,1,0,0,0,4394,447,1,0,0,0,4395,4396,5,447,0,0,4396,4397, - 3,450,225,0,4397,449,1,0,0,0,4398,4400,3,452,226,0,4399,4398,1,0, - 0,0,4400,4401,1,0,0,0,4401,4399,1,0,0,0,4401,4402,1,0,0,0,4402,451, - 1,0,0,0,4403,4404,3,454,227,0,4404,4406,3,456,228,0,4405,4407,3, - 872,436,0,4406,4405,1,0,0,0,4406,4407,1,0,0,0,4407,4408,1,0,0,0, - 4408,4409,3,458,229,0,4409,453,1,0,0,0,4410,4411,7,35,0,0,4411,455, - 1,0,0,0,4412,4413,7,36,0,0,4413,457,1,0,0,0,4414,4415,3,1474,737, - 0,4415,459,1,0,0,0,4416,4418,5,62,0,0,4417,4419,3,462,231,0,4418, - 4417,1,0,0,0,4418,4419,1,0,0,0,4419,4420,1,0,0,0,4420,4421,3,464, - 232,0,4421,461,1,0,0,0,4422,4423,5,192,0,0,4423,463,1,0,0,0,4424, - 4425,7,34,0,0,4425,465,1,0,0,0,4426,4427,5,102,0,0,4427,4428,5,2, - 0,0,4428,4429,3,1212,606,0,4429,4430,5,3,0,0,4430,467,1,0,0,0,4431, - 4432,5,211,0,0,4432,4436,3,1444,722,0,4433,4434,5,296,0,0,4434,4436, - 3,1428,714,0,4435,4431,1,0,0,0,4435,4433,1,0,0,0,4436,469,1,0,0, - 0,4437,4440,3,472,236,0,4438,4440,1,0,0,0,4439,4437,1,0,0,0,4439, - 4438,1,0,0,0,4440,4445,1,0,0,0,4441,4442,5,6,0,0,4442,4444,3,472, - 236,0,4443,4441,1,0,0,0,4444,4447,1,0,0,0,4445,4443,1,0,0,0,4445, - 4446,1,0,0,0,4446,471,1,0,0,0,4447,4445,1,0,0,0,4448,4453,3,1456, - 728,0,4449,4453,3,1454,727,0,4450,4453,3,1458,729,0,4451,4453,3, - 1490,745,0,4452,4448,1,0,0,0,4452,4449,1,0,0,0,4452,4450,1,0,0,0, - 4452,4451,1,0,0,0,4453,473,1,0,0,0,4454,4455,5,64,0,0,4455,4456, - 3,1412,706,0,4456,475,1,0,0,0,4457,4459,3,478,239,0,4458,4457,1, - 0,0,0,4459,4462,1,0,0,0,4460,4458,1,0,0,0,4460,4461,1,0,0,0,4461, - 477,1,0,0,0,4462,4460,1,0,0,0,4463,4464,5,77,0,0,4464,4475,5,54, - 0,0,4465,4475,5,54,0,0,4466,4467,5,69,0,0,4467,4475,5,221,0,0,4468, - 4469,5,69,0,0,4469,4475,5,180,0,0,4470,4471,5,77,0,0,4471,4475,5, - 371,0,0,4472,4473,5,269,0,0,4473,4475,5,228,0,0,4474,4463,1,0,0, - 0,4474,4465,1,0,0,0,4474,4466,1,0,0,0,4474,4468,1,0,0,0,4474,4470, - 1,0,0,0,4474,4472,1,0,0,0,4475,479,1,0,0,0,4476,4477,5,46,0,0,4477, - 4478,5,198,0,0,4478,4479,5,357,0,0,4479,4480,3,1436,718,0,4480,4481, - 5,80,0,0,4481,4482,3,1490,745,0,4482,4483,5,202,0,0,4483,4484,3, - 468,234,0,4484,4485,5,2,0,0,4485,4486,5,3,0,0,4486,4501,1,0,0,0, - 4487,4488,5,46,0,0,4488,4489,5,198,0,0,4489,4490,5,357,0,0,4490, - 4491,3,1436,718,0,4491,4492,5,80,0,0,4492,4493,3,1490,745,0,4493, - 4494,5,102,0,0,4494,4495,3,482,241,0,4495,4496,5,202,0,0,4496,4497, - 3,468,234,0,4497,4498,5,2,0,0,4498,4499,5,3,0,0,4499,4501,1,0,0, - 0,4500,4476,1,0,0,0,4500,4487,1,0,0,0,4501,481,1,0,0,0,4502,4507, - 3,484,242,0,4503,4504,5,33,0,0,4504,4506,3,484,242,0,4505,4503,1, - 0,0,0,4506,4509,1,0,0,0,4507,4505,1,0,0,0,4507,4508,1,0,0,0,4508, - 483,1,0,0,0,4509,4507,1,0,0,0,4510,4511,3,1474,737,0,4511,4512,5, - 68,0,0,4512,4513,5,2,0,0,4513,4514,3,486,243,0,4514,4515,5,3,0,0, - 4515,485,1,0,0,0,4516,4521,3,1458,729,0,4517,4518,5,6,0,0,4518,4520, - 3,1458,729,0,4519,4517,1,0,0,0,4520,4523,1,0,0,0,4521,4519,1,0,0, - 0,4521,4522,1,0,0,0,4522,487,1,0,0,0,4523,4521,1,0,0,0,4524,4525, - 5,138,0,0,4525,4526,5,198,0,0,4526,4527,5,357,0,0,4527,4528,3,1436, - 718,0,4528,4529,3,490,245,0,4529,489,1,0,0,0,4530,4532,5,193,0,0, - 4531,4533,7,20,0,0,4532,4531,1,0,0,0,4532,4533,1,0,0,0,4533,4536, - 1,0,0,0,4534,4536,5,186,0,0,4535,4530,1,0,0,0,4535,4534,1,0,0,0, - 4536,491,1,0,0,0,4537,4538,5,46,0,0,4538,4539,5,140,0,0,4539,4540, - 3,558,279,0,4540,4541,5,42,0,0,4541,4542,5,2,0,0,4542,4543,3,1212, - 606,0,4543,4544,5,3,0,0,4544,4545,3,476,238,0,4545,493,1,0,0,0,4546, - 4548,5,46,0,0,4547,4549,3,658,329,0,4548,4547,1,0,0,0,4548,4549, - 1,0,0,0,4549,4550,1,0,0,0,4550,4551,5,136,0,0,4551,4552,3,1444,722, - 0,4552,4553,3,694,347,0,4553,4554,3,496,248,0,4554,4650,1,0,0,0, - 4555,4557,5,46,0,0,4556,4558,3,658,329,0,4557,4556,1,0,0,0,4557, - 4558,1,0,0,0,4558,4559,1,0,0,0,4559,4560,5,136,0,0,4560,4561,3,1444, - 722,0,4561,4562,3,504,252,0,4562,4650,1,0,0,0,4563,4564,5,46,0,0, - 4564,4565,5,278,0,0,4565,4566,3,732,366,0,4566,4567,3,496,248,0, - 4567,4650,1,0,0,0,4568,4569,5,46,0,0,4569,4570,5,360,0,0,4570,4571, - 3,558,279,0,4571,4572,3,496,248,0,4572,4650,1,0,0,0,4573,4574,5, - 46,0,0,4574,4575,5,360,0,0,4575,4650,3,558,279,0,4576,4577,5,46, - 0,0,4577,4578,5,360,0,0,4578,4579,3,558,279,0,4579,4580,5,36,0,0, - 4580,4582,5,2,0,0,4581,4583,3,1148,574,0,4582,4581,1,0,0,0,4582, - 4583,1,0,0,0,4583,4584,1,0,0,0,4584,4585,5,3,0,0,4585,4650,1,0,0, - 0,4586,4587,5,46,0,0,4587,4588,5,360,0,0,4588,4589,3,558,279,0,4589, - 4590,5,36,0,0,4590,4591,5,196,0,0,4591,4593,5,2,0,0,4592,4594,3, - 510,255,0,4593,4592,1,0,0,0,4593,4594,1,0,0,0,4594,4595,1,0,0,0, - 4595,4596,5,3,0,0,4596,4650,1,0,0,0,4597,4598,5,46,0,0,4598,4599, - 5,360,0,0,4599,4600,3,558,279,0,4600,4601,5,36,0,0,4601,4602,5,299, - 0,0,4602,4603,3,496,248,0,4603,4650,1,0,0,0,4604,4605,5,46,0,0,4605, - 4606,5,355,0,0,4606,4607,5,325,0,0,4607,4608,5,283,0,0,4608,4609, - 3,558,279,0,4609,4610,3,496,248,0,4610,4650,1,0,0,0,4611,4612,5, - 46,0,0,4612,4613,5,355,0,0,4613,4614,5,325,0,0,4614,4615,5,185,0, - 0,4615,4616,3,558,279,0,4616,4617,3,496,248,0,4617,4650,1,0,0,0, - 4618,4619,5,46,0,0,4619,4620,5,355,0,0,4620,4621,5,325,0,0,4621, - 4622,5,353,0,0,4622,4623,3,558,279,0,4623,4624,3,496,248,0,4624, - 4650,1,0,0,0,4625,4626,5,46,0,0,4626,4627,5,355,0,0,4627,4628,5, - 325,0,0,4628,4629,5,163,0,0,4629,4630,3,558,279,0,4630,4631,3,496, - 248,0,4631,4650,1,0,0,0,4632,4633,5,46,0,0,4633,4635,5,108,0,0,4634, - 4636,3,516,258,0,4635,4634,1,0,0,0,4635,4636,1,0,0,0,4636,4637,1, - 0,0,0,4637,4638,3,558,279,0,4638,4639,3,496,248,0,4639,4650,1,0, - 0,0,4640,4641,5,46,0,0,4641,4643,5,108,0,0,4642,4644,3,516,258,0, - 4643,4642,1,0,0,0,4643,4644,1,0,0,0,4644,4645,1,0,0,0,4645,4646, - 3,558,279,0,4646,4647,5,64,0,0,4647,4648,3,558,279,0,4648,4650,1, - 0,0,0,4649,4546,1,0,0,0,4649,4555,1,0,0,0,4649,4563,1,0,0,0,4649, - 4568,1,0,0,0,4649,4573,1,0,0,0,4649,4576,1,0,0,0,4649,4586,1,0,0, - 0,4649,4597,1,0,0,0,4649,4604,1,0,0,0,4649,4611,1,0,0,0,4649,4618, - 1,0,0,0,4649,4625,1,0,0,0,4649,4632,1,0,0,0,4649,4640,1,0,0,0,4650, - 495,1,0,0,0,4651,4652,5,2,0,0,4652,4653,3,498,249,0,4653,4654,5, - 3,0,0,4654,497,1,0,0,0,4655,4660,3,500,250,0,4656,4657,5,6,0,0,4657, - 4659,3,500,250,0,4658,4656,1,0,0,0,4659,4662,1,0,0,0,4660,4658,1, - 0,0,0,4660,4661,1,0,0,0,4661,499,1,0,0,0,4662,4660,1,0,0,0,4663, - 4666,3,1490,745,0,4664,4665,5,10,0,0,4665,4667,3,502,251,0,4666, - 4664,1,0,0,0,4666,4667,1,0,0,0,4667,501,1,0,0,0,4668,4675,3,688, - 344,0,4669,4675,3,1502,751,0,4670,4675,3,1324,662,0,4671,4675,3, - 322,161,0,4672,4675,3,1458,729,0,4673,4675,5,407,0,0,4674,4668,1, - 0,0,0,4674,4669,1,0,0,0,4674,4670,1,0,0,0,4674,4671,1,0,0,0,4674, - 4672,1,0,0,0,4674,4673,1,0,0,0,4675,503,1,0,0,0,4676,4677,5,2,0, - 0,4677,4678,3,506,253,0,4678,4679,5,3,0,0,4679,505,1,0,0,0,4680, - 4685,3,508,254,0,4681,4682,5,6,0,0,4682,4684,3,508,254,0,4683,4681, - 1,0,0,0,4684,4687,1,0,0,0,4685,4683,1,0,0,0,4685,4686,1,0,0,0,4686, - 507,1,0,0,0,4687,4685,1,0,0,0,4688,4689,3,1492,746,0,4689,4690,5, - 10,0,0,4690,4691,3,502,251,0,4691,509,1,0,0,0,4692,4693,3,512,256, - 0,4693,511,1,0,0,0,4694,4699,3,1458,729,0,4695,4696,5,6,0,0,4696, - 4698,3,1458,729,0,4697,4695,1,0,0,0,4698,4701,1,0,0,0,4699,4697, - 1,0,0,0,4699,4700,1,0,0,0,4700,513,1,0,0,0,4701,4699,1,0,0,0,4702, - 4703,5,138,0,0,4703,4704,5,360,0,0,4704,4705,3,558,279,0,4705,4706, - 5,133,0,0,4706,4708,5,450,0,0,4707,4709,3,516,258,0,4708,4707,1, - 0,0,0,4708,4709,1,0,0,0,4709,4710,1,0,0,0,4710,4713,3,1458,729,0, - 4711,4712,7,37,0,0,4712,4714,3,1458,729,0,4713,4711,1,0,0,0,4713, - 4714,1,0,0,0,4714,4725,1,0,0,0,4715,4716,5,138,0,0,4716,4717,5,360, - 0,0,4717,4718,3,558,279,0,4718,4719,5,309,0,0,4719,4720,5,450,0, - 0,4720,4721,3,1458,729,0,4721,4722,5,94,0,0,4722,4723,3,1458,729, - 0,4723,4725,1,0,0,0,4724,4702,1,0,0,0,4724,4715,1,0,0,0,4725,515, - 1,0,0,0,4726,4727,5,220,0,0,4727,4728,5,77,0,0,4728,4729,5,396,0, - 0,4729,517,1,0,0,0,4730,4731,5,46,0,0,4731,4732,5,278,0,0,4732,4733, - 5,156,0,0,4733,4735,3,558,279,0,4734,4736,3,524,262,0,4735,4734, - 1,0,0,0,4735,4736,1,0,0,0,4736,4737,1,0,0,0,4737,4738,5,62,0,0,4738, - 4739,5,360,0,0,4739,4740,3,1168,584,0,4740,4741,5,100,0,0,4741,4743, - 3,1436,718,0,4742,4744,3,526,263,0,4743,4742,1,0,0,0,4743,4744,1, - 0,0,0,4744,4745,1,0,0,0,4745,4746,5,36,0,0,4746,4747,3,520,260,0, - 4747,519,1,0,0,0,4748,4753,3,522,261,0,4749,4750,5,6,0,0,4750,4752, - 3,522,261,0,4751,4749,1,0,0,0,4752,4755,1,0,0,0,4753,4751,1,0,0, - 0,4753,4754,1,0,0,0,4754,521,1,0,0,0,4755,4753,1,0,0,0,4756,4757, - 5,278,0,0,4757,4758,3,1456,728,0,4758,4760,3,732,366,0,4759,4761, - 3,528,264,0,4760,4759,1,0,0,0,4760,4761,1,0,0,0,4761,4763,1,0,0, - 0,4762,4764,3,530,265,0,4763,4762,1,0,0,0,4763,4764,1,0,0,0,4764, - 4788,1,0,0,0,4765,4766,5,278,0,0,4766,4767,3,1456,728,0,4767,4769, - 3,736,368,0,4768,4770,3,528,264,0,4769,4768,1,0,0,0,4769,4770,1, - 0,0,0,4770,4772,1,0,0,0,4771,4773,3,530,265,0,4772,4771,1,0,0,0, - 4772,4773,1,0,0,0,4773,4788,1,0,0,0,4774,4775,5,211,0,0,4775,4776, - 3,1456,728,0,4776,4777,3,674,337,0,4777,4788,1,0,0,0,4778,4779,5, - 211,0,0,4779,4780,3,1456,728,0,4780,4781,5,2,0,0,4781,4782,3,1342, - 671,0,4782,4783,5,3,0,0,4783,4784,3,674,337,0,4784,4788,1,0,0,0, - 4785,4786,5,345,0,0,4786,4788,3,1168,584,0,4787,4756,1,0,0,0,4787, - 4765,1,0,0,0,4787,4774,1,0,0,0,4787,4778,1,0,0,0,4787,4785,1,0,0, - 0,4788,523,1,0,0,0,4789,4790,5,53,0,0,4790,525,1,0,0,0,4791,4792, - 5,206,0,0,4792,4793,3,558,279,0,4793,527,1,0,0,0,4794,4795,5,62, - 0,0,4795,4801,5,325,0,0,4796,4797,5,62,0,0,4797,4798,5,83,0,0,4798, - 4799,5,147,0,0,4799,4801,3,558,279,0,4800,4794,1,0,0,0,4800,4796, - 1,0,0,0,4801,529,1,0,0,0,4802,4803,5,302,0,0,4803,531,1,0,0,0,4804, - 4805,5,46,0,0,4805,4806,5,278,0,0,4806,4807,5,206,0,0,4807,4808, - 3,558,279,0,4808,4809,5,100,0,0,4809,4810,3,1436,718,0,4810,533, - 1,0,0,0,4811,4812,5,138,0,0,4812,4813,5,278,0,0,4813,4814,5,206, - 0,0,4814,4815,3,558,279,0,4815,4816,5,100,0,0,4816,4817,3,1436,718, - 0,4817,4818,5,133,0,0,4818,4819,3,520,260,0,4819,4830,1,0,0,0,4820, - 4821,5,138,0,0,4821,4822,5,278,0,0,4822,4823,5,206,0,0,4823,4824, - 3,558,279,0,4824,4825,5,100,0,0,4825,4826,3,1436,718,0,4826,4827, - 5,191,0,0,4827,4828,3,536,268,0,4828,4830,1,0,0,0,4829,4811,1,0, - 0,0,4829,4820,1,0,0,0,4830,535,1,0,0,0,4831,4836,3,538,269,0,4832, - 4833,5,6,0,0,4833,4835,3,538,269,0,4834,4832,1,0,0,0,4835,4838,1, - 0,0,0,4836,4834,1,0,0,0,4836,4837,1,0,0,0,4837,537,1,0,0,0,4838, - 4836,1,0,0,0,4839,4840,5,278,0,0,4840,4841,3,1456,728,0,4841,4842, - 5,2,0,0,4842,4843,3,1342,671,0,4843,4844,5,3,0,0,4844,4852,1,0,0, - 0,4845,4846,5,211,0,0,4846,4847,3,1456,728,0,4847,4848,5,2,0,0,4848, - 4849,3,1342,671,0,4849,4850,5,3,0,0,4850,4852,1,0,0,0,4851,4839, - 1,0,0,0,4851,4845,1,0,0,0,4852,539,1,0,0,0,4853,4854,5,301,0,0,4854, - 4855,5,281,0,0,4855,4856,5,147,0,0,4856,4857,3,1472,736,0,4857,4858, - 5,94,0,0,4858,4859,3,1470,735,0,4859,541,1,0,0,0,4860,4861,5,191, - 0,0,4861,4863,5,92,0,0,4862,4864,3,748,374,0,4863,4862,1,0,0,0,4863, - 4864,1,0,0,0,4864,4865,1,0,0,0,4865,4867,3,1392,696,0,4866,4868, - 3,124,62,0,4867,4866,1,0,0,0,4867,4868,1,0,0,0,4868,5240,1,0,0,0, - 4869,4870,5,191,0,0,4870,4872,5,328,0,0,4871,4873,3,748,374,0,4872, - 4871,1,0,0,0,4872,4873,1,0,0,0,4873,4874,1,0,0,0,4874,4876,3,1416, - 708,0,4875,4877,3,124,62,0,4876,4875,1,0,0,0,4876,4877,1,0,0,0,4877, - 5240,1,0,0,0,4878,4879,5,191,0,0,4879,4881,5,376,0,0,4880,4882,3, - 748,374,0,4881,4880,1,0,0,0,4881,4882,1,0,0,0,4882,4883,1,0,0,0, - 4883,4885,3,544,272,0,4884,4886,3,124,62,0,4885,4884,1,0,0,0,4885, - 4886,1,0,0,0,4886,5240,1,0,0,0,4887,4888,5,191,0,0,4888,4889,5,259, - 0,0,4889,4891,5,376,0,0,4890,4892,3,748,374,0,4891,4890,1,0,0,0, - 4891,4892,1,0,0,0,4892,4893,1,0,0,0,4893,4895,3,544,272,0,4894,4896, - 3,124,62,0,4895,4894,1,0,0,0,4895,4896,1,0,0,0,4896,5240,1,0,0,0, - 4897,4898,5,191,0,0,4898,4900,5,226,0,0,4899,4901,3,748,374,0,4900, - 4899,1,0,0,0,4900,4901,1,0,0,0,4901,4902,1,0,0,0,4902,4904,3,1416, - 708,0,4903,4905,3,124,62,0,4904,4903,1,0,0,0,4904,4905,1,0,0,0,4905, - 5240,1,0,0,0,4906,4907,5,191,0,0,4907,4908,5,63,0,0,4908,4910,5, - 92,0,0,4909,4911,3,748,374,0,4910,4909,1,0,0,0,4910,4911,1,0,0,0, - 4911,4912,1,0,0,0,4912,4914,3,1392,696,0,4913,4915,3,124,62,0,4914, - 4913,1,0,0,0,4914,4915,1,0,0,0,4915,5240,1,0,0,0,4916,4917,5,191, - 0,0,4917,4919,5,108,0,0,4918,4920,3,748,374,0,4919,4918,1,0,0,0, - 4919,4920,1,0,0,0,4920,4921,1,0,0,0,4921,4923,3,1416,708,0,4922, - 4924,3,124,62,0,4923,4922,1,0,0,0,4923,4924,1,0,0,0,4924,5240,1, - 0,0,0,4925,4926,5,191,0,0,4926,4928,5,168,0,0,4927,4929,3,748,374, - 0,4928,4927,1,0,0,0,4928,4929,1,0,0,0,4929,4930,1,0,0,0,4930,4932, - 3,1416,708,0,4931,4933,3,124,62,0,4932,4931,1,0,0,0,4932,4933,1, - 0,0,0,4933,5240,1,0,0,0,4934,4935,5,191,0,0,4935,4937,5,342,0,0, - 4936,4938,3,748,374,0,4937,4936,1,0,0,0,4937,4938,1,0,0,0,4938,4939, - 1,0,0,0,4939,4941,3,1416,708,0,4940,4942,3,124,62,0,4941,4940,1, - 0,0,0,4941,4942,1,0,0,0,4942,5240,1,0,0,0,4943,4944,5,191,0,0,4944, - 4945,5,355,0,0,4945,4946,5,325,0,0,4946,4948,5,283,0,0,4947,4949, - 3,748,374,0,4948,4947,1,0,0,0,4948,4949,1,0,0,0,4949,4950,1,0,0, - 0,4950,4952,3,1416,708,0,4951,4953,3,124,62,0,4952,4951,1,0,0,0, - 4952,4953,1,0,0,0,4953,5240,1,0,0,0,4954,4955,5,191,0,0,4955,4956, - 5,355,0,0,4956,4957,5,325,0,0,4957,4959,5,185,0,0,4958,4960,3,748, - 374,0,4959,4958,1,0,0,0,4959,4960,1,0,0,0,4960,4961,1,0,0,0,4961, - 4963,3,1416,708,0,4962,4964,3,124,62,0,4963,4962,1,0,0,0,4963,4964, - 1,0,0,0,4964,5240,1,0,0,0,4965,4966,5,191,0,0,4966,4967,5,355,0, - 0,4967,4968,5,325,0,0,4968,4970,5,353,0,0,4969,4971,3,748,374,0, - 4970,4969,1,0,0,0,4970,4971,1,0,0,0,4971,4972,1,0,0,0,4972,4974, - 3,1416,708,0,4973,4975,3,124,62,0,4974,4973,1,0,0,0,4974,4975,1, - 0,0,0,4975,5240,1,0,0,0,4976,4977,5,191,0,0,4977,4978,5,355,0,0, - 4978,4979,5,325,0,0,4979,4981,5,163,0,0,4980,4982,3,748,374,0,4981, - 4980,1,0,0,0,4981,4982,1,0,0,0,4982,4983,1,0,0,0,4983,4985,3,1416, - 708,0,4984,4986,3,124,62,0,4985,4984,1,0,0,0,4985,4986,1,0,0,0,4986, - 5240,1,0,0,0,4987,4988,5,191,0,0,4988,4989,5,131,0,0,4989,4991,5, - 446,0,0,4990,4992,3,748,374,0,4991,4990,1,0,0,0,4991,4992,1,0,0, - 0,4992,4993,1,0,0,0,4993,4995,3,1416,708,0,4994,4996,3,124,62,0, - 4995,4994,1,0,0,0,4995,4996,1,0,0,0,4996,5240,1,0,0,0,4997,4998, - 5,191,0,0,4998,4999,5,198,0,0,4999,5001,5,357,0,0,5000,5002,3,748, - 374,0,5001,5000,1,0,0,0,5001,5002,1,0,0,0,5002,5003,1,0,0,0,5003, - 5005,3,1416,708,0,5004,5006,3,124,62,0,5005,5004,1,0,0,0,5005,5006, - 1,0,0,0,5006,5240,1,0,0,0,5007,5008,5,191,0,0,5008,5010,5,204,0, - 0,5009,5011,3,748,374,0,5010,5009,1,0,0,0,5010,5011,1,0,0,0,5011, - 5012,1,0,0,0,5012,5014,3,1416,708,0,5013,5015,3,124,62,0,5014,5013, - 1,0,0,0,5014,5015,1,0,0,0,5015,5240,1,0,0,0,5016,5017,5,191,0,0, - 5017,5018,5,63,0,0,5018,5019,5,174,0,0,5019,5021,5,381,0,0,5020, - 5022,3,748,374,0,5021,5020,1,0,0,0,5021,5022,1,0,0,0,5022,5023,1, - 0,0,0,5023,5025,3,1416,708,0,5024,5026,3,124,62,0,5025,5024,1,0, - 0,0,5025,5026,1,0,0,0,5026,5240,1,0,0,0,5027,5029,5,191,0,0,5028, - 5030,3,338,169,0,5029,5028,1,0,0,0,5029,5030,1,0,0,0,5030,5031,1, - 0,0,0,5031,5033,5,247,0,0,5032,5034,3,748,374,0,5033,5032,1,0,0, - 0,5033,5034,1,0,0,0,5034,5035,1,0,0,0,5035,5037,3,1416,708,0,5036, - 5038,3,124,62,0,5037,5036,1,0,0,0,5037,5038,1,0,0,0,5038,5240,1, - 0,0,0,5039,5040,5,191,0,0,5040,5042,5,452,0,0,5041,5043,3,748,374, - 0,5042,5041,1,0,0,0,5042,5043,1,0,0,0,5043,5044,1,0,0,0,5044,5046, - 3,1416,708,0,5045,5047,3,124,62,0,5046,5045,1,0,0,0,5046,5047,1, - 0,0,0,5047,5240,1,0,0,0,5048,5049,5,191,0,0,5049,5051,5,331,0,0, - 5050,5052,3,748,374,0,5051,5050,1,0,0,0,5051,5052,1,0,0,0,5052,5053, - 1,0,0,0,5053,5055,3,1416,708,0,5054,5056,3,124,62,0,5055,5054,1, - 0,0,0,5055,5056,1,0,0,0,5056,5240,1,0,0,0,5057,5058,5,191,0,0,5058, - 5060,5,323,0,0,5059,5061,3,748,374,0,5060,5059,1,0,0,0,5060,5061, - 1,0,0,0,5061,5062,1,0,0,0,5062,5064,3,1394,697,0,5063,5065,3,124, - 62,0,5064,5063,1,0,0,0,5064,5065,1,0,0,0,5065,5240,1,0,0,0,5066, - 5067,5,191,0,0,5067,5069,5,445,0,0,5068,5070,3,748,374,0,5069,5068, - 1,0,0,0,5069,5070,1,0,0,0,5070,5071,1,0,0,0,5071,5072,3,1436,718, - 0,5072,5073,5,80,0,0,5073,5075,3,558,279,0,5074,5076,3,124,62,0, - 5075,5074,1,0,0,0,5075,5076,1,0,0,0,5076,5240,1,0,0,0,5077,5078, - 5,191,0,0,5078,5080,5,321,0,0,5079,5081,3,748,374,0,5080,5079,1, - 0,0,0,5080,5081,1,0,0,0,5081,5082,1,0,0,0,5082,5083,3,1436,718,0, - 5083,5084,5,80,0,0,5084,5086,3,558,279,0,5085,5087,3,124,62,0,5086, - 5085,1,0,0,0,5086,5087,1,0,0,0,5087,5240,1,0,0,0,5088,5089,5,191, - 0,0,5089,5091,5,357,0,0,5090,5092,3,748,374,0,5091,5090,1,0,0,0, - 5091,5092,1,0,0,0,5092,5093,1,0,0,0,5093,5094,3,1436,718,0,5094, - 5095,5,80,0,0,5095,5097,3,558,279,0,5096,5098,3,124,62,0,5097,5096, - 1,0,0,0,5097,5098,1,0,0,0,5098,5240,1,0,0,0,5099,5100,5,191,0,0, - 5100,5102,5,360,0,0,5101,5103,3,748,374,0,5102,5101,1,0,0,0,5102, - 5103,1,0,0,0,5103,5104,1,0,0,0,5104,5106,3,562,281,0,5105,5107,3, - 124,62,0,5106,5105,1,0,0,0,5106,5107,1,0,0,0,5107,5240,1,0,0,0,5108, - 5109,5,191,0,0,5109,5111,5,189,0,0,5110,5112,3,748,374,0,5111,5110, - 1,0,0,0,5111,5112,1,0,0,0,5112,5113,1,0,0,0,5113,5115,3,562,281, - 0,5114,5116,3,124,62,0,5115,5114,1,0,0,0,5115,5116,1,0,0,0,5116, - 5240,1,0,0,0,5117,5118,5,191,0,0,5118,5119,5,226,0,0,5119,5121,5, - 109,0,0,5120,5122,3,748,374,0,5121,5120,1,0,0,0,5121,5122,1,0,0, - 0,5122,5123,1,0,0,0,5123,5125,3,552,276,0,5124,5126,3,124,62,0,5125, - 5124,1,0,0,0,5125,5126,1,0,0,0,5126,5240,1,0,0,0,5127,5128,5,191, - 0,0,5128,5130,5,41,0,0,5129,5131,3,748,374,0,5130,5129,1,0,0,0,5130, - 5131,1,0,0,0,5131,5132,1,0,0,0,5132,5133,5,2,0,0,5133,5134,3,1168, - 584,0,5134,5135,5,36,0,0,5135,5136,3,1168,584,0,5136,5138,5,3,0, - 0,5137,5139,3,124,62,0,5138,5137,1,0,0,0,5138,5139,1,0,0,0,5139, - 5240,1,0,0,0,5140,5141,5,191,0,0,5141,5142,5,278,0,0,5142,5144,5, - 156,0,0,5143,5145,3,748,374,0,5144,5143,1,0,0,0,5144,5145,1,0,0, - 0,5145,5146,1,0,0,0,5146,5147,3,558,279,0,5147,5148,5,100,0,0,5148, - 5150,3,1436,718,0,5149,5151,3,124,62,0,5150,5149,1,0,0,0,5150,5151, - 1,0,0,0,5151,5240,1,0,0,0,5152,5153,5,191,0,0,5153,5154,5,278,0, - 0,5154,5156,5,206,0,0,5155,5157,3,748,374,0,5156,5155,1,0,0,0,5156, - 5157,1,0,0,0,5157,5158,1,0,0,0,5158,5159,3,558,279,0,5159,5160,5, - 100,0,0,5160,5162,3,1436,718,0,5161,5163,3,124,62,0,5162,5161,1, - 0,0,0,5162,5163,1,0,0,0,5163,5240,1,0,0,0,5164,5165,5,191,0,0,5165, - 5166,5,281,0,0,5166,5167,5,147,0,0,5167,5169,3,1472,736,0,5168,5170, - 3,124,62,0,5169,5168,1,0,0,0,5169,5170,1,0,0,0,5170,5240,1,0,0,0, - 5171,5172,5,191,0,0,5172,5174,5,376,0,0,5173,5175,3,748,374,0,5174, - 5173,1,0,0,0,5174,5175,1,0,0,0,5175,5176,1,0,0,0,5176,5178,3,544, - 272,0,5177,5179,3,124,62,0,5178,5177,1,0,0,0,5178,5179,1,0,0,0,5179, - 5240,1,0,0,0,5180,5181,5,191,0,0,5181,5183,5,451,0,0,5182,5184,3, - 748,374,0,5183,5182,1,0,0,0,5183,5184,1,0,0,0,5184,5185,1,0,0,0, - 5185,5187,3,1436,718,0,5186,5188,3,124,62,0,5187,5186,1,0,0,0,5187, - 5188,1,0,0,0,5188,5240,1,0,0,0,5189,5190,5,191,0,0,5190,5192,5,351, - 0,0,5191,5193,3,748,374,0,5192,5191,1,0,0,0,5192,5193,1,0,0,0,5193, - 5194,1,0,0,0,5194,5240,3,1402,701,0,5195,5196,5,191,0,0,5196,5198, - 5,443,0,0,5197,5199,3,748,374,0,5198,5197,1,0,0,0,5198,5199,1,0, - 0,0,5199,5200,1,0,0,0,5200,5201,5,62,0,0,5201,5202,3,1168,584,0, - 5202,5203,5,247,0,0,5203,5205,3,1436,718,0,5204,5206,3,124,62,0, - 5205,5204,1,0,0,0,5205,5206,1,0,0,0,5206,5240,1,0,0,0,5207,5208, - 5,191,0,0,5208,5210,7,38,0,0,5209,5211,3,748,374,0,5210,5209,1,0, - 0,0,5210,5211,1,0,0,0,5211,5212,1,0,0,0,5212,5240,3,1472,736,0,5213, - 5214,5,191,0,0,5214,5215,5,99,0,0,5215,5217,5,257,0,0,5216,5218, - 3,748,374,0,5217,5216,1,0,0,0,5217,5218,1,0,0,0,5218,5219,1,0,0, - 0,5219,5220,5,62,0,0,5220,5221,3,404,202,0,5221,5222,5,331,0,0,5222, - 5223,3,1436,718,0,5223,5240,1,0,0,0,5224,5225,5,191,0,0,5225,5227, - 5,175,0,0,5226,5228,3,748,374,0,5227,5226,1,0,0,0,5227,5228,1,0, - 0,0,5228,5229,1,0,0,0,5229,5237,3,1420,710,0,5230,5232,3,14,7,0, - 5231,5230,1,0,0,0,5231,5232,1,0,0,0,5232,5233,1,0,0,0,5233,5234, - 5,2,0,0,5234,5235,3,860,430,0,5235,5236,5,3,0,0,5236,5238,1,0,0, - 0,5237,5231,1,0,0,0,5237,5238,1,0,0,0,5238,5240,1,0,0,0,5239,4860, - 1,0,0,0,5239,4869,1,0,0,0,5239,4878,1,0,0,0,5239,4887,1,0,0,0,5239, - 4897,1,0,0,0,5239,4906,1,0,0,0,5239,4916,1,0,0,0,5239,4925,1,0,0, - 0,5239,4934,1,0,0,0,5239,4943,1,0,0,0,5239,4954,1,0,0,0,5239,4965, - 1,0,0,0,5239,4976,1,0,0,0,5239,4987,1,0,0,0,5239,4997,1,0,0,0,5239, - 5007,1,0,0,0,5239,5016,1,0,0,0,5239,5027,1,0,0,0,5239,5039,1,0,0, - 0,5239,5048,1,0,0,0,5239,5057,1,0,0,0,5239,5066,1,0,0,0,5239,5077, - 1,0,0,0,5239,5088,1,0,0,0,5239,5099,1,0,0,0,5239,5108,1,0,0,0,5239, - 5117,1,0,0,0,5239,5127,1,0,0,0,5239,5140,1,0,0,0,5239,5152,1,0,0, - 0,5239,5164,1,0,0,0,5239,5171,1,0,0,0,5239,5180,1,0,0,0,5239,5189, - 1,0,0,0,5239,5195,1,0,0,0,5239,5207,1,0,0,0,5239,5213,1,0,0,0,5239, - 5224,1,0,0,0,5240,543,1,0,0,0,5241,5246,3,1410,705,0,5242,5243,5, - 6,0,0,5243,5245,3,1410,705,0,5244,5242,1,0,0,0,5245,5248,1,0,0,0, - 5246,5244,1,0,0,0,5246,5247,1,0,0,0,5247,545,1,0,0,0,5248,5246,1, - 0,0,0,5249,5251,5,63,0,0,5250,5249,1,0,0,0,5250,5251,1,0,0,0,5251, - 5252,1,0,0,0,5252,5253,5,92,0,0,5253,5274,3,1406,703,0,5254,5256, - 5,259,0,0,5255,5254,1,0,0,0,5255,5256,1,0,0,0,5256,5257,1,0,0,0, - 5257,5258,5,376,0,0,5258,5274,3,1410,705,0,5259,5260,5,226,0,0,5260, - 5274,3,558,279,0,5261,5262,5,108,0,0,5262,5274,3,558,279,0,5263, - 5264,5,168,0,0,5264,5274,3,558,279,0,5265,5266,5,342,0,0,5266,5274, - 3,558,279,0,5267,5268,5,328,0,0,5268,5274,3,558,279,0,5269,5270, - 5,355,0,0,5270,5271,5,325,0,0,5271,5272,7,39,0,0,5272,5274,3,558, - 279,0,5273,5250,1,0,0,0,5273,5255,1,0,0,0,5273,5259,1,0,0,0,5273, - 5261,1,0,0,0,5273,5263,1,0,0,0,5273,5265,1,0,0,0,5273,5267,1,0,0, - 0,5273,5269,1,0,0,0,5274,547,1,0,0,0,5275,5276,5,131,0,0,5276,5277, - 5,446,0,0,5277,5307,3,1436,718,0,5278,5279,5,198,0,0,5279,5280,5, - 357,0,0,5280,5307,3,1436,718,0,5281,5282,5,204,0,0,5282,5307,3,1436, - 718,0,5283,5284,5,63,0,0,5284,5285,5,174,0,0,5285,5286,5,381,0,0, - 5286,5307,3,1436,718,0,5287,5289,3,338,169,0,5288,5287,1,0,0,0,5288, - 5289,1,0,0,0,5289,5290,1,0,0,0,5290,5291,5,247,0,0,5291,5307,3,1436, - 718,0,5292,5293,5,452,0,0,5293,5307,3,1436,718,0,5294,5295,5,323, - 0,0,5295,5307,3,1422,711,0,5296,5297,5,331,0,0,5297,5307,3,1436, - 718,0,5298,5299,5,175,0,0,5299,5307,3,1420,710,0,5300,5301,5,318, - 0,0,5301,5307,3,1436,718,0,5302,5303,5,451,0,0,5303,5307,3,1436, - 718,0,5304,5305,5,351,0,0,5305,5307,3,1402,701,0,5306,5275,1,0,0, - 0,5306,5278,1,0,0,0,5306,5281,1,0,0,0,5306,5283,1,0,0,0,5306,5288, - 1,0,0,0,5306,5292,1,0,0,0,5306,5294,1,0,0,0,5306,5296,1,0,0,0,5306, - 5298,1,0,0,0,5306,5300,1,0,0,0,5306,5302,1,0,0,0,5306,5304,1,0,0, - 0,5307,549,1,0,0,0,5308,5309,7,40,0,0,5309,551,1,0,0,0,5310,5315, - 3,558,279,0,5311,5312,5,6,0,0,5312,5314,3,558,279,0,5313,5311,1, - 0,0,0,5314,5317,1,0,0,0,5315,5313,1,0,0,0,5315,5316,1,0,0,0,5316, - 553,1,0,0,0,5317,5315,1,0,0,0,5318,5319,3,556,278,0,5319,5320,5, - 11,0,0,5320,5321,3,1432,716,0,5321,555,1,0,0,0,5322,5324,3,1474, - 737,0,5323,5325,3,560,280,0,5324,5323,1,0,0,0,5324,5325,1,0,0,0, - 5325,557,1,0,0,0,5326,5328,3,1474,737,0,5327,5329,3,560,280,0,5328, - 5327,1,0,0,0,5328,5329,1,0,0,0,5329,559,1,0,0,0,5330,5331,5,11,0, - 0,5331,5333,3,1438,719,0,5332,5330,1,0,0,0,5333,5334,1,0,0,0,5334, - 5332,1,0,0,0,5334,5335,1,0,0,0,5335,561,1,0,0,0,5336,5341,3,1168, - 584,0,5337,5338,5,6,0,0,5338,5340,3,1168,584,0,5339,5337,1,0,0,0, - 5340,5343,1,0,0,0,5341,5339,1,0,0,0,5341,5342,1,0,0,0,5342,563,1, - 0,0,0,5343,5341,1,0,0,0,5344,5346,5,358,0,0,5345,5347,5,92,0,0,5346, - 5345,1,0,0,0,5346,5347,1,0,0,0,5347,5348,1,0,0,0,5348,5353,3,566, - 283,0,5349,5350,5,6,0,0,5350,5352,3,566,283,0,5351,5349,1,0,0,0, - 5352,5355,1,0,0,0,5353,5351,1,0,0,0,5353,5354,1,0,0,0,5354,5358, - 1,0,0,0,5355,5353,1,0,0,0,5356,5357,7,41,0,0,5357,5359,5,219,0,0, - 5358,5356,1,0,0,0,5358,5359,1,0,0,0,5359,5361,1,0,0,0,5360,5362, - 3,124,62,0,5361,5360,1,0,0,0,5361,5362,1,0,0,0,5362,565,1,0,0,0, - 5363,5365,5,81,0,0,5364,5363,1,0,0,0,5364,5365,1,0,0,0,5365,5366, - 1,0,0,0,5366,5368,3,1406,703,0,5367,5369,5,9,0,0,5368,5367,1,0,0, - 0,5368,5369,1,0,0,0,5369,567,1,0,0,0,5370,5371,5,159,0,0,5371,5372, - 5,80,0,0,5372,5373,3,546,273,0,5373,5374,5,116,0,0,5374,5375,3,570, - 285,0,5375,5536,1,0,0,0,5376,5377,5,159,0,0,5377,5378,5,80,0,0,5378, - 5379,5,44,0,0,5379,5380,3,554,277,0,5380,5381,5,116,0,0,5381,5382, - 3,570,285,0,5382,5536,1,0,0,0,5383,5384,5,159,0,0,5384,5385,5,80, - 0,0,5385,5386,3,548,274,0,5386,5387,5,116,0,0,5387,5388,3,570,285, - 0,5388,5536,1,0,0,0,5389,5390,5,159,0,0,5390,5391,5,80,0,0,5391, - 5392,5,360,0,0,5392,5393,3,1168,584,0,5393,5394,5,116,0,0,5394,5395, - 3,570,285,0,5395,5536,1,0,0,0,5396,5397,5,159,0,0,5397,5398,5,80, - 0,0,5398,5399,5,189,0,0,5399,5400,3,1168,584,0,5400,5401,5,116,0, - 0,5401,5402,3,570,285,0,5402,5536,1,0,0,0,5403,5404,5,159,0,0,5404, - 5405,5,80,0,0,5405,5406,5,136,0,0,5406,5407,3,698,349,0,5407,5408, - 5,116,0,0,5408,5409,3,570,285,0,5409,5536,1,0,0,0,5410,5411,5,159, - 0,0,5411,5412,5,80,0,0,5412,5413,5,211,0,0,5413,5414,3,674,337,0, - 5414,5415,5,116,0,0,5415,5416,3,570,285,0,5416,5536,1,0,0,0,5417, - 5418,5,159,0,0,5418,5419,5,80,0,0,5419,5420,5,278,0,0,5420,5421, - 3,736,368,0,5421,5422,5,116,0,0,5422,5423,3,570,285,0,5423,5536, - 1,0,0,0,5424,5425,5,159,0,0,5425,5426,5,80,0,0,5426,5427,5,45,0, - 0,5427,5428,3,1436,718,0,5428,5429,5,80,0,0,5429,5430,3,1406,703, - 0,5430,5431,5,116,0,0,5431,5432,3,570,285,0,5432,5536,1,0,0,0,5433, - 5434,5,159,0,0,5434,5435,5,80,0,0,5435,5436,5,45,0,0,5436,5437,3, - 1436,718,0,5437,5439,5,80,0,0,5438,5440,5,189,0,0,5439,5438,1,0, - 0,0,5439,5440,1,0,0,0,5440,5441,1,0,0,0,5441,5442,3,558,279,0,5442, - 5443,5,116,0,0,5443,5444,3,570,285,0,5444,5536,1,0,0,0,5445,5446, - 5,159,0,0,5446,5447,5,80,0,0,5447,5448,5,445,0,0,5448,5449,3,1436, - 718,0,5449,5450,5,80,0,0,5450,5451,3,558,279,0,5451,5452,5,116,0, - 0,5452,5453,3,570,285,0,5453,5536,1,0,0,0,5454,5455,5,159,0,0,5455, - 5456,5,80,0,0,5456,5457,5,321,0,0,5457,5458,3,1436,718,0,5458,5459, - 5,80,0,0,5459,5460,3,558,279,0,5460,5461,5,116,0,0,5461,5462,3,570, - 285,0,5462,5536,1,0,0,0,5463,5464,5,159,0,0,5464,5465,5,80,0,0,5465, - 5466,5,357,0,0,5466,5467,3,1436,718,0,5467,5468,5,80,0,0,5468,5469, - 3,558,279,0,5469,5470,5,116,0,0,5470,5471,3,570,285,0,5471,5536, - 1,0,0,0,5472,5473,5,159,0,0,5473,5474,5,80,0,0,5474,5475,5,296,0, - 0,5475,5476,3,670,335,0,5476,5477,5,116,0,0,5477,5478,3,570,285, - 0,5478,5536,1,0,0,0,5479,5480,5,159,0,0,5480,5481,5,80,0,0,5481, - 5482,5,442,0,0,5482,5483,3,666,333,0,5483,5484,5,116,0,0,5484,5485, - 3,570,285,0,5485,5536,1,0,0,0,5486,5487,5,159,0,0,5487,5488,5,80, - 0,0,5488,5489,5,443,0,0,5489,5490,5,62,0,0,5490,5491,3,1168,584, - 0,5491,5492,5,247,0,0,5492,5493,3,1436,718,0,5493,5494,5,116,0,0, - 5494,5495,3,570,285,0,5495,5536,1,0,0,0,5496,5497,5,159,0,0,5497, - 5498,5,80,0,0,5498,5499,5,278,0,0,5499,5500,5,156,0,0,5500,5501, - 3,558,279,0,5501,5502,5,100,0,0,5502,5503,3,1436,718,0,5503,5504, - 5,116,0,0,5504,5505,3,570,285,0,5505,5536,1,0,0,0,5506,5507,5,159, - 0,0,5507,5508,5,80,0,0,5508,5509,5,278,0,0,5509,5510,5,206,0,0,5510, - 5511,3,558,279,0,5511,5512,5,100,0,0,5512,5513,3,1436,718,0,5513, - 5514,5,116,0,0,5514,5515,3,570,285,0,5515,5536,1,0,0,0,5516,5517, - 5,159,0,0,5517,5518,5,80,0,0,5518,5519,5,248,0,0,5519,5520,5,274, - 0,0,5520,5521,3,322,161,0,5521,5522,5,116,0,0,5522,5523,3,570,285, - 0,5523,5536,1,0,0,0,5524,5525,5,159,0,0,5525,5526,5,80,0,0,5526, - 5527,5,41,0,0,5527,5528,5,2,0,0,5528,5529,3,1168,584,0,5529,5530, - 5,36,0,0,5530,5531,3,1168,584,0,5531,5532,5,3,0,0,5532,5533,5,116, - 0,0,5533,5534,3,570,285,0,5534,5536,1,0,0,0,5535,5370,1,0,0,0,5535, - 5376,1,0,0,0,5535,5383,1,0,0,0,5535,5389,1,0,0,0,5535,5396,1,0,0, - 0,5535,5403,1,0,0,0,5535,5410,1,0,0,0,5535,5417,1,0,0,0,5535,5424, - 1,0,0,0,5535,5433,1,0,0,0,5535,5445,1,0,0,0,5535,5454,1,0,0,0,5535, - 5463,1,0,0,0,5535,5472,1,0,0,0,5535,5479,1,0,0,0,5535,5486,1,0,0, - 0,5535,5496,1,0,0,0,5535,5506,1,0,0,0,5535,5516,1,0,0,0,5535,5524, - 1,0,0,0,5536,569,1,0,0,0,5537,5540,3,1458,729,0,5538,5540,5,78,0, - 0,5539,5537,1,0,0,0,5539,5538,1,0,0,0,5540,571,1,0,0,0,5541,5542, - 5,327,0,0,5542,5544,5,246,0,0,5543,5545,3,574,287,0,5544,5543,1, - 0,0,0,5544,5545,1,0,0,0,5545,5546,1,0,0,0,5546,5547,5,80,0,0,5547, - 5548,5,44,0,0,5548,5549,3,1432,716,0,5549,5550,5,116,0,0,5550,5551, - 3,576,288,0,5551,5651,1,0,0,0,5552,5553,5,327,0,0,5553,5555,5,246, - 0,0,5554,5556,3,574,287,0,5555,5554,1,0,0,0,5555,5556,1,0,0,0,5556, - 5557,1,0,0,0,5557,5558,5,80,0,0,5558,5559,5,360,0,0,5559,5560,3, - 1168,584,0,5560,5561,5,116,0,0,5561,5562,3,576,288,0,5562,5651,1, - 0,0,0,5563,5564,5,327,0,0,5564,5566,5,246,0,0,5565,5567,3,574,287, - 0,5566,5565,1,0,0,0,5566,5567,1,0,0,0,5567,5568,1,0,0,0,5568,5569, - 5,80,0,0,5569,5570,5,189,0,0,5570,5571,3,1168,584,0,5571,5572,5, - 116,0,0,5572,5573,3,576,288,0,5573,5651,1,0,0,0,5574,5575,5,327, - 0,0,5575,5577,5,246,0,0,5576,5578,3,574,287,0,5577,5576,1,0,0,0, - 5577,5578,1,0,0,0,5578,5579,1,0,0,0,5579,5580,5,80,0,0,5580,5581, - 5,136,0,0,5581,5582,3,698,349,0,5582,5583,5,116,0,0,5583,5584,3, - 576,288,0,5584,5651,1,0,0,0,5585,5586,5,327,0,0,5586,5588,5,246, - 0,0,5587,5589,3,574,287,0,5588,5587,1,0,0,0,5588,5589,1,0,0,0,5589, - 5590,1,0,0,0,5590,5591,5,80,0,0,5591,5592,5,211,0,0,5592,5593,3, - 674,337,0,5593,5594,5,116,0,0,5594,5595,3,576,288,0,5595,5651,1, - 0,0,0,5596,5597,5,327,0,0,5597,5599,5,246,0,0,5598,5600,3,574,287, - 0,5599,5598,1,0,0,0,5599,5600,1,0,0,0,5600,5601,1,0,0,0,5601,5602, - 5,80,0,0,5602,5603,5,248,0,0,5603,5604,5,274,0,0,5604,5605,3,322, - 161,0,5605,5606,5,116,0,0,5606,5607,3,576,288,0,5607,5651,1,0,0, - 0,5608,5609,5,327,0,0,5609,5611,5,246,0,0,5610,5612,3,574,287,0, - 5611,5610,1,0,0,0,5611,5612,1,0,0,0,5612,5613,1,0,0,0,5613,5614, - 5,80,0,0,5614,5615,5,296,0,0,5615,5616,3,670,335,0,5616,5617,5,116, - 0,0,5617,5618,3,576,288,0,5618,5651,1,0,0,0,5619,5620,5,327,0,0, - 5620,5622,5,246,0,0,5621,5623,3,574,287,0,5622,5621,1,0,0,0,5622, - 5623,1,0,0,0,5623,5624,1,0,0,0,5624,5625,5,80,0,0,5625,5626,5,442, - 0,0,5626,5627,3,666,333,0,5627,5628,5,116,0,0,5628,5629,3,576,288, - 0,5629,5651,1,0,0,0,5630,5631,5,327,0,0,5631,5633,5,246,0,0,5632, - 5634,3,574,287,0,5633,5632,1,0,0,0,5633,5634,1,0,0,0,5634,5635,1, - 0,0,0,5635,5636,5,80,0,0,5636,5637,3,546,273,0,5637,5638,5,116,0, - 0,5638,5639,3,576,288,0,5639,5651,1,0,0,0,5640,5641,5,327,0,0,5641, - 5643,5,246,0,0,5642,5644,3,574,287,0,5643,5642,1,0,0,0,5643,5644, - 1,0,0,0,5644,5645,1,0,0,0,5645,5646,5,80,0,0,5646,5647,3,548,274, - 0,5647,5648,5,116,0,0,5648,5649,3,576,288,0,5649,5651,1,0,0,0,5650, - 5541,1,0,0,0,5650,5552,1,0,0,0,5650,5563,1,0,0,0,5650,5574,1,0,0, - 0,5650,5585,1,0,0,0,5650,5596,1,0,0,0,5650,5608,1,0,0,0,5650,5619, - 1,0,0,0,5650,5630,1,0,0,0,5650,5640,1,0,0,0,5651,573,1,0,0,0,5652, - 5653,5,62,0,0,5653,5654,3,80,40,0,5654,575,1,0,0,0,5655,5658,3,1458, - 729,0,5656,5658,5,78,0,0,5657,5655,1,0,0,0,5657,5656,1,0,0,0,5658, - 577,1,0,0,0,5659,5660,5,61,0,0,5660,5664,3,580,290,0,5661,5662,5, - 265,0,0,5662,5664,3,580,290,0,5663,5659,1,0,0,0,5663,5661,1,0,0, - 0,5664,579,1,0,0,0,5665,5751,3,994,497,0,5666,5667,3,582,291,0,5667, - 5668,3,994,497,0,5668,5751,1,0,0,0,5669,5671,5,268,0,0,5670,5672, - 3,584,292,0,5671,5670,1,0,0,0,5671,5672,1,0,0,0,5672,5673,1,0,0, - 0,5673,5751,3,994,497,0,5674,5676,5,293,0,0,5675,5677,3,584,292, - 0,5676,5675,1,0,0,0,5676,5677,1,0,0,0,5677,5678,1,0,0,0,5678,5751, - 3,994,497,0,5679,5681,5,207,0,0,5680,5682,3,584,292,0,5681,5680, - 1,0,0,0,5681,5682,1,0,0,0,5682,5683,1,0,0,0,5683,5751,3,994,497, - 0,5684,5686,5,249,0,0,5685,5687,3,584,292,0,5686,5685,1,0,0,0,5686, - 5687,1,0,0,0,5687,5688,1,0,0,0,5688,5751,3,994,497,0,5689,5690,5, - 130,0,0,5690,5692,3,1464,732,0,5691,5693,3,584,292,0,5692,5691,1, - 0,0,0,5692,5693,1,0,0,0,5693,5694,1,0,0,0,5694,5695,3,994,497,0, - 5695,5751,1,0,0,0,5696,5697,5,307,0,0,5697,5699,3,1464,732,0,5698, - 5700,3,584,292,0,5699,5698,1,0,0,0,5699,5700,1,0,0,0,5700,5701,1, - 0,0,0,5701,5702,3,994,497,0,5702,5751,1,0,0,0,5703,5705,3,1464,732, - 0,5704,5706,3,584,292,0,5705,5704,1,0,0,0,5705,5706,1,0,0,0,5706, - 5707,1,0,0,0,5707,5708,3,994,497,0,5708,5751,1,0,0,0,5709,5711,5, - 30,0,0,5710,5712,3,584,292,0,5711,5710,1,0,0,0,5711,5712,1,0,0,0, - 5712,5713,1,0,0,0,5713,5751,3,994,497,0,5714,5716,5,210,0,0,5715, - 5717,3,584,292,0,5716,5715,1,0,0,0,5716,5717,1,0,0,0,5717,5718,1, - 0,0,0,5718,5751,3,994,497,0,5719,5720,5,210,0,0,5720,5722,3,1464, - 732,0,5721,5723,3,584,292,0,5722,5721,1,0,0,0,5722,5723,1,0,0,0, - 5723,5724,1,0,0,0,5724,5725,3,994,497,0,5725,5751,1,0,0,0,5726,5727, - 5,210,0,0,5727,5729,5,30,0,0,5728,5730,3,584,292,0,5729,5728,1,0, - 0,0,5729,5730,1,0,0,0,5730,5731,1,0,0,0,5731,5751,3,994,497,0,5732, - 5734,5,144,0,0,5733,5735,3,584,292,0,5734,5733,1,0,0,0,5734,5735, - 1,0,0,0,5735,5736,1,0,0,0,5736,5751,3,994,497,0,5737,5738,5,144, - 0,0,5738,5740,3,1464,732,0,5739,5741,3,584,292,0,5740,5739,1,0,0, - 0,5740,5741,1,0,0,0,5741,5742,1,0,0,0,5742,5743,3,994,497,0,5743, - 5751,1,0,0,0,5744,5745,5,144,0,0,5745,5747,5,30,0,0,5746,5748,3, - 584,292,0,5747,5746,1,0,0,0,5747,5748,1,0,0,0,5748,5749,1,0,0,0, - 5749,5751,3,994,497,0,5750,5665,1,0,0,0,5750,5666,1,0,0,0,5750,5669, - 1,0,0,0,5750,5674,1,0,0,0,5750,5679,1,0,0,0,5750,5684,1,0,0,0,5750, - 5689,1,0,0,0,5750,5696,1,0,0,0,5750,5703,1,0,0,0,5750,5709,1,0,0, - 0,5750,5714,1,0,0,0,5750,5719,1,0,0,0,5750,5726,1,0,0,0,5750,5732, - 1,0,0,0,5750,5737,1,0,0,0,5750,5744,1,0,0,0,5751,581,1,0,0,0,5752, - 5753,7,42,0,0,5753,583,1,0,0,0,5754,5755,3,582,291,0,5755,585,1, - 0,0,0,5756,5757,5,65,0,0,5757,5758,3,590,295,0,5758,5759,5,80,0, - 0,5759,5760,3,600,300,0,5760,5761,5,94,0,0,5761,5763,3,602,301,0, - 5762,5764,3,606,303,0,5763,5762,1,0,0,0,5763,5764,1,0,0,0,5764,587, - 1,0,0,0,5765,5766,5,317,0,0,5766,5767,3,590,295,0,5767,5768,5,80, - 0,0,5768,5769,3,600,300,0,5769,5770,5,64,0,0,5770,5772,3,602,301, - 0,5771,5773,3,124,62,0,5772,5771,1,0,0,0,5772,5773,1,0,0,0,5773, - 5787,1,0,0,0,5774,5775,5,317,0,0,5775,5776,5,65,0,0,5776,5777,5, - 279,0,0,5777,5778,5,62,0,0,5778,5779,3,590,295,0,5779,5780,5,80, - 0,0,5780,5781,3,600,300,0,5781,5782,5,64,0,0,5782,5784,3,602,301, - 0,5783,5785,3,124,62,0,5784,5783,1,0,0,0,5784,5785,1,0,0,0,5785, - 5787,1,0,0,0,5786,5765,1,0,0,0,5786,5774,1,0,0,0,5787,589,1,0,0, - 0,5788,5805,3,596,298,0,5789,5805,5,30,0,0,5790,5791,5,30,0,0,5791, - 5805,5,294,0,0,5792,5793,5,30,0,0,5793,5794,5,2,0,0,5794,5795,3, - 244,122,0,5795,5796,5,3,0,0,5796,5805,1,0,0,0,5797,5798,5,30,0,0, - 5798,5799,5,294,0,0,5799,5800,5,2,0,0,5800,5801,3,244,122,0,5801, - 5802,5,3,0,0,5802,5805,1,0,0,0,5803,5805,3,592,296,0,5804,5788,1, - 0,0,0,5804,5789,1,0,0,0,5804,5790,1,0,0,0,5804,5792,1,0,0,0,5804, - 5797,1,0,0,0,5804,5803,1,0,0,0,5805,591,1,0,0,0,5806,5811,3,594, - 297,0,5807,5808,5,6,0,0,5808,5810,3,594,297,0,5809,5807,1,0,0,0, - 5810,5813,1,0,0,0,5811,5809,1,0,0,0,5811,5812,1,0,0,0,5812,593,1, - 0,0,0,5813,5811,1,0,0,0,5814,5815,7,43,0,0,5815,595,1,0,0,0,5816, - 5821,3,598,299,0,5817,5818,5,6,0,0,5818,5820,3,598,299,0,5819,5817, - 1,0,0,0,5820,5823,1,0,0,0,5821,5819,1,0,0,0,5821,5822,1,0,0,0,5822, - 597,1,0,0,0,5823,5821,1,0,0,0,5824,5826,5,88,0,0,5825,5827,3,240, - 120,0,5826,5825,1,0,0,0,5826,5827,1,0,0,0,5827,5841,1,0,0,0,5828, - 5830,5,86,0,0,5829,5831,3,240,120,0,5830,5829,1,0,0,0,5830,5831, - 1,0,0,0,5831,5841,1,0,0,0,5832,5834,5,46,0,0,5833,5835,3,240,120, - 0,5834,5833,1,0,0,0,5834,5835,1,0,0,0,5835,5841,1,0,0,0,5836,5838, - 3,1474,737,0,5837,5839,3,240,120,0,5838,5837,1,0,0,0,5838,5839,1, - 0,0,0,5839,5841,1,0,0,0,5840,5824,1,0,0,0,5840,5828,1,0,0,0,5840, - 5832,1,0,0,0,5840,5836,1,0,0,0,5841,599,1,0,0,0,5842,5901,3,1390, - 695,0,5843,5844,5,92,0,0,5844,5901,3,1392,696,0,5845,5846,5,328, - 0,0,5846,5901,3,1390,695,0,5847,5848,5,63,0,0,5848,5849,5,174,0, - 0,5849,5850,5,381,0,0,5850,5901,3,1416,708,0,5851,5852,5,63,0,0, - 5852,5853,5,331,0,0,5853,5901,3,1416,708,0,5854,5855,5,211,0,0,5855, - 5901,3,672,336,0,5856,5857,5,296,0,0,5857,5901,3,668,334,0,5858, - 5859,5,442,0,0,5859,5901,3,664,332,0,5860,5861,5,175,0,0,5861,5901, - 3,1396,698,0,5862,5863,5,189,0,0,5863,5901,3,552,276,0,5864,5865, - 5,247,0,0,5865,5901,3,1416,708,0,5866,5867,5,248,0,0,5867,5868,5, - 274,0,0,5868,5901,3,324,162,0,5869,5870,5,323,0,0,5870,5901,3,1394, - 697,0,5871,5872,5,351,0,0,5872,5901,3,1414,707,0,5873,5874,5,360, - 0,0,5874,5901,3,552,276,0,5875,5876,5,30,0,0,5876,5877,5,350,0,0, - 5877,5878,5,68,0,0,5878,5879,5,323,0,0,5879,5901,3,1394,697,0,5880, - 5881,5,30,0,0,5881,5882,5,329,0,0,5882,5883,5,68,0,0,5883,5884,5, - 323,0,0,5884,5901,3,1394,697,0,5885,5886,5,30,0,0,5886,5887,5,212, - 0,0,5887,5888,5,68,0,0,5888,5889,5,323,0,0,5889,5901,3,1394,697, - 0,5890,5891,5,30,0,0,5891,5892,5,457,0,0,5892,5893,5,68,0,0,5893, - 5894,5,323,0,0,5894,5901,3,1394,697,0,5895,5896,5,30,0,0,5896,5897, - 5,455,0,0,5897,5898,5,68,0,0,5898,5899,5,323,0,0,5899,5901,3,1394, - 697,0,5900,5842,1,0,0,0,5900,5843,1,0,0,0,5900,5845,1,0,0,0,5900, - 5847,1,0,0,0,5900,5851,1,0,0,0,5900,5854,1,0,0,0,5900,5856,1,0,0, - 0,5900,5858,1,0,0,0,5900,5860,1,0,0,0,5900,5862,1,0,0,0,5900,5864, - 1,0,0,0,5900,5866,1,0,0,0,5900,5869,1,0,0,0,5900,5871,1,0,0,0,5900, - 5873,1,0,0,0,5900,5875,1,0,0,0,5900,5880,1,0,0,0,5900,5885,1,0,0, - 0,5900,5890,1,0,0,0,5900,5895,1,0,0,0,5901,601,1,0,0,0,5902,5907, - 3,604,302,0,5903,5904,5,6,0,0,5904,5906,3,604,302,0,5905,5903,1, - 0,0,0,5906,5909,1,0,0,0,5907,5905,1,0,0,0,5907,5908,1,0,0,0,5908, - 603,1,0,0,0,5909,5907,1,0,0,0,5910,5914,3,1470,735,0,5911,5912,5, - 66,0,0,5912,5914,3,1470,735,0,5913,5910,1,0,0,0,5913,5911,1,0,0, - 0,5914,605,1,0,0,0,5915,5916,5,105,0,0,5916,5917,5,65,0,0,5917,5918, - 5,279,0,0,5918,607,1,0,0,0,5919,5920,5,65,0,0,5920,5921,3,596,298, - 0,5921,5922,5,94,0,0,5922,5924,3,1472,736,0,5923,5925,3,612,306, - 0,5924,5923,1,0,0,0,5924,5925,1,0,0,0,5925,5927,1,0,0,0,5926,5928, - 3,614,307,0,5927,5926,1,0,0,0,5927,5928,1,0,0,0,5928,609,1,0,0,0, - 5929,5930,5,317,0,0,5930,5931,3,596,298,0,5931,5932,5,64,0,0,5932, - 5934,3,1472,736,0,5933,5935,3,614,307,0,5934,5933,1,0,0,0,5934,5935, - 1,0,0,0,5935,5937,1,0,0,0,5936,5938,3,124,62,0,5937,5936,1,0,0,0, - 5937,5938,1,0,0,0,5938,5953,1,0,0,0,5939,5940,5,317,0,0,5940,5941, - 5,134,0,0,5941,5942,5,279,0,0,5942,5943,5,62,0,0,5943,5944,3,596, - 298,0,5944,5945,5,64,0,0,5945,5947,3,1472,736,0,5946,5948,3,614, - 307,0,5947,5946,1,0,0,0,5947,5948,1,0,0,0,5948,5950,1,0,0,0,5949, - 5951,3,124,62,0,5950,5949,1,0,0,0,5950,5951,1,0,0,0,5951,5953,1, - 0,0,0,5952,5929,1,0,0,0,5952,5939,1,0,0,0,5953,611,1,0,0,0,5954, - 5955,5,105,0,0,5955,5956,5,134,0,0,5956,5957,5,279,0,0,5957,613, - 1,0,0,0,5958,5959,5,214,0,0,5959,5960,5,147,0,0,5960,5961,3,1470, - 735,0,5961,615,1,0,0,0,5962,5963,5,138,0,0,5963,5964,5,53,0,0,5964, - 5965,5,294,0,0,5965,5966,3,618,309,0,5966,5967,3,622,311,0,5967, - 617,1,0,0,0,5968,5970,3,620,310,0,5969,5968,1,0,0,0,5970,5973,1, - 0,0,0,5971,5969,1,0,0,0,5971,5972,1,0,0,0,5972,619,1,0,0,0,5973, - 5971,1,0,0,0,5974,5975,5,68,0,0,5975,5976,5,323,0,0,5976,5984,3, - 1394,697,0,5977,5978,5,62,0,0,5978,5979,5,318,0,0,5979,5984,3,1472, - 736,0,5980,5981,5,62,0,0,5981,5982,5,99,0,0,5982,5984,3,1472,736, - 0,5983,5974,1,0,0,0,5983,5977,1,0,0,0,5983,5980,1,0,0,0,5984,621, - 1,0,0,0,5985,5986,5,65,0,0,5986,5987,3,590,295,0,5987,5988,5,80, - 0,0,5988,5989,3,624,312,0,5989,5990,5,94,0,0,5990,5992,3,602,301, - 0,5991,5993,3,606,303,0,5992,5991,1,0,0,0,5992,5993,1,0,0,0,5993, - 6016,1,0,0,0,5994,5995,5,317,0,0,5995,5996,3,590,295,0,5996,5997, - 5,80,0,0,5997,5998,3,624,312,0,5998,5999,5,64,0,0,5999,6001,3,602, - 301,0,6000,6002,3,124,62,0,6001,6000,1,0,0,0,6001,6002,1,0,0,0,6002, - 6016,1,0,0,0,6003,6004,5,317,0,0,6004,6005,5,65,0,0,6005,6006,5, - 279,0,0,6006,6007,5,62,0,0,6007,6008,3,590,295,0,6008,6009,5,80, - 0,0,6009,6010,3,624,312,0,6010,6011,5,64,0,0,6011,6013,3,602,301, - 0,6012,6014,3,124,62,0,6013,6012,1,0,0,0,6013,6014,1,0,0,0,6014, - 6016,1,0,0,0,6015,5985,1,0,0,0,6015,5994,1,0,0,0,6015,6003,1,0,0, - 0,6016,623,1,0,0,0,6017,6018,7,44,0,0,6018,625,1,0,0,0,6019,6021, - 5,46,0,0,6020,6022,3,628,314,0,6021,6020,1,0,0,0,6021,6022,1,0,0, - 0,6022,6023,1,0,0,0,6023,6025,5,226,0,0,6024,6026,3,630,315,0,6025, - 6024,1,0,0,0,6025,6026,1,0,0,0,6026,6028,1,0,0,0,6027,6029,3,516, - 258,0,6028,6027,1,0,0,0,6028,6029,1,0,0,0,6029,6031,1,0,0,0,6030, - 6032,3,632,316,0,6031,6030,1,0,0,0,6031,6032,1,0,0,0,6032,6033,1, - 0,0,0,6033,6034,5,80,0,0,6034,6036,3,1118,559,0,6035,6037,3,634, - 317,0,6036,6035,1,0,0,0,6036,6037,1,0,0,0,6037,6038,1,0,0,0,6038, - 6039,5,2,0,0,6039,6040,3,636,318,0,6040,6042,5,3,0,0,6041,6043,3, - 642,321,0,6042,6041,1,0,0,0,6042,6043,1,0,0,0,6043,6045,1,0,0,0, - 6044,6046,3,220,110,0,6045,6044,1,0,0,0,6045,6046,1,0,0,0,6046,6048, - 1,0,0,0,6047,6049,3,134,67,0,6048,6047,1,0,0,0,6048,6049,1,0,0,0, - 6049,6051,1,0,0,0,6050,6052,3,282,141,0,6051,6050,1,0,0,0,6051,6052, - 1,0,0,0,6052,6054,1,0,0,0,6053,6055,3,1144,572,0,6054,6053,1,0,0, - 0,6054,6055,1,0,0,0,6055,627,1,0,0,0,6056,6057,5,98,0,0,6057,629, - 1,0,0,0,6058,6059,5,109,0,0,6059,631,1,0,0,0,6060,6061,3,1436,718, - 0,6061,633,1,0,0,0,6062,6063,5,100,0,0,6063,6064,3,1436,718,0,6064, - 635,1,0,0,0,6065,6070,3,640,320,0,6066,6067,5,6,0,0,6067,6069,3, - 640,320,0,6068,6066,1,0,0,0,6069,6072,1,0,0,0,6070,6068,1,0,0,0, - 6070,6071,1,0,0,0,6071,637,1,0,0,0,6072,6070,1,0,0,0,6073,6075,3, - 646,323,0,6074,6073,1,0,0,0,6074,6075,1,0,0,0,6075,6077,1,0,0,0, - 6076,6078,3,648,324,0,6077,6076,1,0,0,0,6077,6078,1,0,0,0,6078,6080, - 1,0,0,0,6079,6081,3,650,325,0,6080,6079,1,0,0,0,6080,6081,1,0,0, - 0,6081,6083,1,0,0,0,6082,6084,3,652,326,0,6083,6082,1,0,0,0,6083, - 6084,1,0,0,0,6084,6097,1,0,0,0,6085,6087,3,646,323,0,6086,6085,1, - 0,0,0,6086,6087,1,0,0,0,6087,6088,1,0,0,0,6088,6089,3,558,279,0, - 6089,6091,3,132,66,0,6090,6092,3,650,325,0,6091,6090,1,0,0,0,6091, - 6092,1,0,0,0,6092,6094,1,0,0,0,6093,6095,3,652,326,0,6094,6093,1, - 0,0,0,6094,6095,1,0,0,0,6095,6097,1,0,0,0,6096,6074,1,0,0,0,6096, - 6086,1,0,0,0,6097,639,1,0,0,0,6098,6099,3,1432,716,0,6099,6100,3, - 638,319,0,6100,6110,1,0,0,0,6101,6102,3,1262,631,0,6102,6103,3,638, - 319,0,6103,6110,1,0,0,0,6104,6105,5,2,0,0,6105,6106,3,1212,606,0, - 6106,6107,5,3,0,0,6107,6108,3,638,319,0,6108,6110,1,0,0,0,6109,6098, - 1,0,0,0,6109,6101,1,0,0,0,6109,6104,1,0,0,0,6110,641,1,0,0,0,6111, - 6112,5,441,0,0,6112,6113,5,2,0,0,6113,6114,3,644,322,0,6114,6115, - 5,3,0,0,6115,643,1,0,0,0,6116,6121,3,640,320,0,6117,6118,5,6,0,0, - 6118,6120,3,640,320,0,6119,6117,1,0,0,0,6120,6123,1,0,0,0,6121,6119, - 1,0,0,0,6121,6122,1,0,0,0,6122,645,1,0,0,0,6123,6121,1,0,0,0,6124, - 6125,5,43,0,0,6125,6126,3,558,279,0,6126,647,1,0,0,0,6127,6128,3, - 558,279,0,6128,649,1,0,0,0,6129,6130,7,45,0,0,6130,651,1,0,0,0,6131, - 6132,5,273,0,0,6132,6136,5,207,0,0,6133,6134,5,273,0,0,6134,6136, - 5,249,0,0,6135,6131,1,0,0,0,6135,6133,1,0,0,0,6136,653,1,0,0,0,6137, - 6139,5,46,0,0,6138,6140,3,658,329,0,6139,6138,1,0,0,0,6139,6140, - 1,0,0,0,6140,6145,1,0,0,0,6141,6142,5,211,0,0,6142,6146,3,1442,721, - 0,6143,6144,5,296,0,0,6144,6146,3,1430,715,0,6145,6141,1,0,0,0,6145, - 6143,1,0,0,0,6146,6147,1,0,0,0,6147,6157,3,676,338,0,6148,6155,5, - 316,0,0,6149,6156,3,686,343,0,6150,6151,5,92,0,0,6151,6152,5,2,0, - 0,6152,6153,3,714,357,0,6153,6154,5,3,0,0,6154,6156,1,0,0,0,6155, - 6149,1,0,0,0,6155,6150,1,0,0,0,6156,6158,1,0,0,0,6157,6148,1,0,0, - 0,6157,6158,1,0,0,0,6158,6159,1,0,0,0,6159,6162,3,702,351,0,6160, - 6161,5,105,0,0,6161,6163,3,656,328,0,6162,6160,1,0,0,0,6162,6163, - 1,0,0,0,6163,655,1,0,0,0,6164,6165,5,2,0,0,6165,6170,3,1474,737, - 0,6166,6167,5,6,0,0,6167,6169,3,1474,737,0,6168,6166,1,0,0,0,6169, - 6172,1,0,0,0,6170,6168,1,0,0,0,6170,6171,1,0,0,0,6171,6173,1,0,0, - 0,6172,6170,1,0,0,0,6173,6174,5,3,0,0,6174,657,1,0,0,0,6175,6176, - 5,82,0,0,6176,6177,5,311,0,0,6177,659,1,0,0,0,6178,6180,5,2,0,0, - 6179,6181,3,662,331,0,6180,6179,1,0,0,0,6180,6181,1,0,0,0,6181,6182, - 1,0,0,0,6182,6183,5,3,0,0,6183,661,1,0,0,0,6184,6189,3,680,340,0, - 6185,6186,5,6,0,0,6186,6188,3,680,340,0,6187,6185,1,0,0,0,6188,6191, - 1,0,0,0,6189,6187,1,0,0,0,6189,6190,1,0,0,0,6190,663,1,0,0,0,6191, - 6189,1,0,0,0,6192,6197,3,666,333,0,6193,6194,5,6,0,0,6194,6196,3, - 666,333,0,6195,6193,1,0,0,0,6196,6199,1,0,0,0,6197,6195,1,0,0,0, - 6197,6198,1,0,0,0,6198,665,1,0,0,0,6199,6197,1,0,0,0,6200,6201,3, - 1426,713,0,6201,6202,3,660,330,0,6202,6209,1,0,0,0,6203,6209,3,1500, - 750,0,6204,6206,3,1474,737,0,6205,6207,3,1380,690,0,6206,6205,1, - 0,0,0,6206,6207,1,0,0,0,6207,6209,1,0,0,0,6208,6200,1,0,0,0,6208, - 6203,1,0,0,0,6208,6204,1,0,0,0,6209,667,1,0,0,0,6210,6215,3,670, - 335,0,6211,6212,5,6,0,0,6212,6214,3,670,335,0,6213,6211,1,0,0,0, - 6214,6217,1,0,0,0,6215,6213,1,0,0,0,6215,6216,1,0,0,0,6216,669,1, - 0,0,0,6217,6215,1,0,0,0,6218,6219,3,1428,714,0,6219,6220,3,660,330, - 0,6220,6227,1,0,0,0,6221,6227,3,1500,750,0,6222,6224,3,1474,737, - 0,6223,6225,3,1380,690,0,6224,6223,1,0,0,0,6224,6225,1,0,0,0,6225, - 6227,1,0,0,0,6226,6218,1,0,0,0,6226,6221,1,0,0,0,6226,6222,1,0,0, - 0,6227,671,1,0,0,0,6228,6233,3,674,337,0,6229,6230,5,6,0,0,6230, - 6232,3,674,337,0,6231,6229,1,0,0,0,6232,6235,1,0,0,0,6233,6231,1, - 0,0,0,6233,6234,1,0,0,0,6234,673,1,0,0,0,6235,6233,1,0,0,0,6236, - 6237,3,1444,722,0,6237,6238,3,660,330,0,6238,6245,1,0,0,0,6239,6245, - 3,1500,750,0,6240,6242,3,1474,737,0,6241,6243,3,1380,690,0,6242, - 6241,1,0,0,0,6242,6243,1,0,0,0,6243,6245,1,0,0,0,6244,6236,1,0,0, - 0,6244,6239,1,0,0,0,6244,6240,1,0,0,0,6245,675,1,0,0,0,6246,6248, - 5,2,0,0,6247,6249,3,678,339,0,6248,6247,1,0,0,0,6248,6249,1,0,0, - 0,6249,6250,1,0,0,0,6250,6251,5,3,0,0,6251,677,1,0,0,0,6252,6257, - 3,690,345,0,6253,6254,5,6,0,0,6254,6256,3,690,345,0,6255,6253,1, - 0,0,0,6256,6259,1,0,0,0,6257,6255,1,0,0,0,6257,6258,1,0,0,0,6258, - 679,1,0,0,0,6259,6257,1,0,0,0,6260,6262,3,682,341,0,6261,6263,3, - 684,342,0,6262,6261,1,0,0,0,6262,6263,1,0,0,0,6263,6264,1,0,0,0, - 6264,6265,3,688,344,0,6265,6274,1,0,0,0,6266,6268,3,684,342,0,6267, - 6269,3,682,341,0,6268,6267,1,0,0,0,6268,6269,1,0,0,0,6269,6270,1, - 0,0,0,6270,6271,3,688,344,0,6271,6274,1,0,0,0,6272,6274,3,688,344, - 0,6273,6260,1,0,0,0,6273,6266,1,0,0,0,6273,6272,1,0,0,0,6274,681, - 1,0,0,0,6275,6277,5,68,0,0,6276,6278,5,453,0,0,6277,6276,1,0,0,0, - 6277,6278,1,0,0,0,6278,6283,1,0,0,0,6279,6283,5,453,0,0,6280,6283, - 5,400,0,0,6281,6283,5,101,0,0,6282,6275,1,0,0,0,6282,6279,1,0,0, - 0,6282,6280,1,0,0,0,6282,6281,1,0,0,0,6283,683,1,0,0,0,6284,6285, - 3,1482,741,0,6285,685,1,0,0,0,6286,6287,3,688,344,0,6287,687,1,0, - 0,0,6288,6301,3,1168,584,0,6289,6290,3,1482,741,0,6290,6291,3,560, - 280,0,6291,6292,5,27,0,0,6292,6293,5,360,0,0,6293,6301,1,0,0,0,6294, - 6295,5,415,0,0,6295,6296,3,1482,741,0,6296,6297,3,560,280,0,6297, - 6298,5,27,0,0,6298,6299,5,360,0,0,6299,6301,1,0,0,0,6300,6288,1, - 0,0,0,6300,6289,1,0,0,0,6300,6294,1,0,0,0,6301,689,1,0,0,0,6302, - 6305,3,680,340,0,6303,6304,7,46,0,0,6304,6306,3,1212,606,0,6305, - 6303,1,0,0,0,6305,6306,1,0,0,0,6306,691,1,0,0,0,6307,6308,3,680, - 340,0,6308,693,1,0,0,0,6309,6320,5,2,0,0,6310,6321,5,9,0,0,6311, - 6321,3,696,348,0,6312,6313,5,83,0,0,6313,6314,5,147,0,0,6314,6321, - 3,696,348,0,6315,6316,3,696,348,0,6316,6317,5,83,0,0,6317,6318,5, - 147,0,0,6318,6319,3,696,348,0,6319,6321,1,0,0,0,6320,6310,1,0,0, - 0,6320,6311,1,0,0,0,6320,6312,1,0,0,0,6320,6315,1,0,0,0,6321,6322, - 1,0,0,0,6322,6323,5,3,0,0,6323,695,1,0,0,0,6324,6329,3,692,346,0, - 6325,6326,5,6,0,0,6326,6328,3,692,346,0,6327,6325,1,0,0,0,6328,6331, - 1,0,0,0,6329,6327,1,0,0,0,6329,6330,1,0,0,0,6330,697,1,0,0,0,6331, - 6329,1,0,0,0,6332,6333,3,1444,722,0,6333,6334,3,694,347,0,6334,699, - 1,0,0,0,6335,6340,3,698,349,0,6336,6337,5,6,0,0,6337,6339,3,698, - 349,0,6338,6336,1,0,0,0,6339,6342,1,0,0,0,6340,6338,1,0,0,0,6340, - 6341,1,0,0,0,6341,701,1,0,0,0,6342,6340,1,0,0,0,6343,6345,3,706, - 353,0,6344,6343,1,0,0,0,6345,6346,1,0,0,0,6346,6344,1,0,0,0,6346, - 6347,1,0,0,0,6347,703,1,0,0,0,6348,6349,5,149,0,0,6349,6350,5,80, - 0,0,6350,6351,5,78,0,0,6351,6384,5,458,0,0,6352,6353,5,316,0,0,6353, - 6354,5,78,0,0,6354,6355,5,80,0,0,6355,6356,5,78,0,0,6356,6384,5, - 458,0,0,6357,6384,5,346,0,0,6358,6384,5,222,0,0,6359,6384,5,338, - 0,0,6360,6384,5,377,0,0,6361,6362,5,205,0,0,6362,6363,5,327,0,0, - 6363,6384,5,181,0,0,6364,6365,5,205,0,0,6365,6366,5,327,0,0,6366, - 6384,5,243,0,0,6367,6368,5,327,0,0,6368,6384,5,181,0,0,6369,6370, - 5,327,0,0,6370,6384,5,243,0,0,6371,6384,5,250,0,0,6372,6373,5,77, - 0,0,6373,6384,5,250,0,0,6374,6375,5,170,0,0,6375,6384,3,322,161, - 0,6376,6377,5,320,0,0,6377,6384,3,322,161,0,6378,6379,5,459,0,0, - 6379,6384,3,558,279,0,6380,6384,3,90,45,0,6381,6382,5,460,0,0,6382, - 6384,3,1474,737,0,6383,6348,1,0,0,0,6383,6352,1,0,0,0,6383,6357, - 1,0,0,0,6383,6358,1,0,0,0,6383,6359,1,0,0,0,6383,6360,1,0,0,0,6383, - 6361,1,0,0,0,6383,6364,1,0,0,0,6383,6367,1,0,0,0,6383,6369,1,0,0, - 0,6383,6371,1,0,0,0,6383,6372,1,0,0,0,6383,6374,1,0,0,0,6383,6376, - 1,0,0,0,6383,6378,1,0,0,0,6383,6380,1,0,0,0,6383,6381,1,0,0,0,6384, - 705,1,0,0,0,6385,6386,5,36,0,0,6386,6387,3,1458,729,0,6387,6388, - 5,6,0,0,6388,6389,3,1458,729,0,6389,6411,1,0,0,0,6390,6391,5,247, - 0,0,6391,6411,3,80,40,0,6392,6393,5,443,0,0,6393,6411,3,708,354, - 0,6394,6411,5,104,0,0,6395,6396,5,333,0,0,6396,6403,3,1474,737,0, - 6397,6398,5,94,0,0,6398,6404,3,1474,737,0,6399,6400,5,10,0,0,6400, - 6404,3,1474,737,0,6401,6402,5,64,0,0,6402,6404,5,434,0,0,6403,6397, - 1,0,0,0,6403,6399,1,0,0,0,6403,6401,1,0,0,0,6404,6411,1,0,0,0,6405, - 6406,5,36,0,0,6406,6411,3,1474,737,0,6407,6411,3,6,3,0,6408,6411, - 3,704,352,0,6409,6411,3,1474,737,0,6410,6385,1,0,0,0,6410,6390,1, - 0,0,0,6410,6392,1,0,0,0,6410,6394,1,0,0,0,6410,6395,1,0,0,0,6410, - 6405,1,0,0,0,6410,6407,1,0,0,0,6410,6408,1,0,0,0,6410,6409,1,0,0, - 0,6411,707,1,0,0,0,6412,6413,5,62,0,0,6413,6414,5,360,0,0,6414,6421, - 3,1168,584,0,6415,6416,5,6,0,0,6416,6417,5,62,0,0,6417,6418,5,360, - 0,0,6418,6420,3,1168,584,0,6419,6415,1,0,0,0,6420,6423,1,0,0,0,6421, - 6419,1,0,0,0,6421,6422,1,0,0,0,6422,709,1,0,0,0,6423,6421,1,0,0, - 0,6424,6425,5,105,0,0,6425,6426,3,496,248,0,6426,711,1,0,0,0,6427, - 6428,3,1432,716,0,6428,6429,3,688,344,0,6429,713,1,0,0,0,6430,6435, - 3,712,356,0,6431,6432,5,6,0,0,6432,6434,3,712,356,0,6433,6431,1, - 0,0,0,6434,6437,1,0,0,0,6435,6433,1,0,0,0,6435,6436,1,0,0,0,6436, - 715,1,0,0,0,6437,6435,1,0,0,0,6438,6439,5,138,0,0,6439,6440,3,718, - 359,0,6440,6442,3,720,360,0,6441,6443,3,722,361,0,6442,6441,1,0, - 0,0,6442,6443,1,0,0,0,6443,717,1,0,0,0,6444,6445,5,211,0,0,6445, - 6451,3,674,337,0,6446,6447,5,296,0,0,6447,6451,3,670,335,0,6448, - 6449,5,442,0,0,6449,6451,3,666,333,0,6450,6444,1,0,0,0,6450,6446, - 1,0,0,0,6450,6448,1,0,0,0,6451,719,1,0,0,0,6452,6454,3,704,352,0, - 6453,6452,1,0,0,0,6454,6455,1,0,0,0,6455,6453,1,0,0,0,6455,6456, - 1,0,0,0,6456,721,1,0,0,0,6457,6458,5,315,0,0,6458,723,1,0,0,0,6459, - 6460,5,191,0,0,6460,6462,5,211,0,0,6461,6463,3,748,374,0,6462,6461, - 1,0,0,0,6462,6463,1,0,0,0,6463,6464,1,0,0,0,6464,6466,3,672,336, - 0,6465,6467,3,124,62,0,6466,6465,1,0,0,0,6466,6467,1,0,0,0,6467, - 6487,1,0,0,0,6468,6469,5,191,0,0,6469,6471,5,296,0,0,6470,6472,3, - 748,374,0,6471,6470,1,0,0,0,6471,6472,1,0,0,0,6472,6473,1,0,0,0, - 6473,6475,3,668,334,0,6474,6476,3,124,62,0,6475,6474,1,0,0,0,6475, - 6476,1,0,0,0,6476,6487,1,0,0,0,6477,6478,5,191,0,0,6478,6480,5,442, - 0,0,6479,6481,3,748,374,0,6480,6479,1,0,0,0,6480,6481,1,0,0,0,6481, - 6482,1,0,0,0,6482,6484,3,664,332,0,6483,6485,3,124,62,0,6484,6483, - 1,0,0,0,6484,6485,1,0,0,0,6485,6487,1,0,0,0,6486,6459,1,0,0,0,6486, - 6468,1,0,0,0,6486,6477,1,0,0,0,6487,725,1,0,0,0,6488,6489,5,191, - 0,0,6489,6491,5,136,0,0,6490,6492,3,748,374,0,6491,6490,1,0,0,0, - 6491,6492,1,0,0,0,6492,6493,1,0,0,0,6493,6495,3,700,350,0,6494,6496, - 3,124,62,0,6495,6494,1,0,0,0,6495,6496,1,0,0,0,6496,727,1,0,0,0, - 6497,6498,5,191,0,0,6498,6500,5,278,0,0,6499,6501,3,748,374,0,6500, - 6499,1,0,0,0,6500,6501,1,0,0,0,6501,6502,1,0,0,0,6502,6504,3,734, - 367,0,6503,6505,3,124,62,0,6504,6503,1,0,0,0,6504,6505,1,0,0,0,6505, - 729,1,0,0,0,6506,6507,5,2,0,0,6507,6508,3,1168,584,0,6508,6509,5, - 3,0,0,6509,6529,1,0,0,0,6510,6511,5,2,0,0,6511,6512,3,1168,584,0, - 6512,6513,5,6,0,0,6513,6514,3,1168,584,0,6514,6515,5,3,0,0,6515, - 6529,1,0,0,0,6516,6517,5,2,0,0,6517,6518,5,407,0,0,6518,6519,5,6, - 0,0,6519,6520,3,1168,584,0,6520,6521,5,3,0,0,6521,6529,1,0,0,0,6522, - 6523,5,2,0,0,6523,6524,3,1168,584,0,6524,6525,5,6,0,0,6525,6526, - 5,407,0,0,6526,6527,5,3,0,0,6527,6529,1,0,0,0,6528,6506,1,0,0,0, - 6528,6510,1,0,0,0,6528,6516,1,0,0,0,6528,6522,1,0,0,0,6529,731,1, - 0,0,0,6530,6531,3,1474,737,0,6531,6532,5,11,0,0,6532,6534,1,0,0, - 0,6533,6530,1,0,0,0,6534,6537,1,0,0,0,6535,6533,1,0,0,0,6535,6536, - 1,0,0,0,6536,6538,1,0,0,0,6537,6535,1,0,0,0,6538,6539,3,1318,659, - 0,6539,733,1,0,0,0,6540,6545,3,736,368,0,6541,6542,5,6,0,0,6542, - 6544,3,736,368,0,6543,6541,1,0,0,0,6544,6547,1,0,0,0,6545,6543,1, - 0,0,0,6545,6546,1,0,0,0,6546,735,1,0,0,0,6547,6545,1,0,0,0,6548, - 6549,3,732,366,0,6549,6550,3,730,365,0,6550,737,1,0,0,0,6551,6552, - 5,57,0,0,6552,6553,3,740,370,0,6553,739,1,0,0,0,6554,6556,3,742, - 371,0,6555,6554,1,0,0,0,6556,6557,1,0,0,0,6557,6555,1,0,0,0,6557, - 6558,1,0,0,0,6558,741,1,0,0,0,6559,6563,3,1458,729,0,6560,6561,5, - 247,0,0,6561,6563,3,80,40,0,6562,6559,1,0,0,0,6562,6560,1,0,0,0, - 6563,743,1,0,0,0,6564,6565,5,46,0,0,6565,6566,5,41,0,0,6566,6567, - 5,2,0,0,6567,6568,3,1168,584,0,6568,6569,5,36,0,0,6569,6570,3,1168, - 584,0,6570,6571,5,3,0,0,6571,6572,5,105,0,0,6572,6573,5,211,0,0, - 6573,6575,3,674,337,0,6574,6576,3,746,373,0,6575,6574,1,0,0,0,6575, - 6576,1,0,0,0,6576,6602,1,0,0,0,6577,6578,5,46,0,0,6578,6579,5,41, - 0,0,6579,6580,5,2,0,0,6580,6581,3,1168,584,0,6581,6582,5,36,0,0, - 6582,6583,3,1168,584,0,6583,6584,5,3,0,0,6584,6585,5,379,0,0,6585, - 6587,5,211,0,0,6586,6588,3,746,373,0,6587,6586,1,0,0,0,6587,6588, - 1,0,0,0,6588,6602,1,0,0,0,6589,6590,5,46,0,0,6590,6591,5,41,0,0, - 6591,6592,5,2,0,0,6592,6593,3,1168,584,0,6593,6594,5,36,0,0,6594, - 6595,3,1168,584,0,6595,6596,5,3,0,0,6596,6597,5,105,0,0,6597,6599, - 5,400,0,0,6598,6600,3,746,373,0,6599,6598,1,0,0,0,6599,6600,1,0, - 0,0,6600,6602,1,0,0,0,6601,6564,1,0,0,0,6601,6577,1,0,0,0,6601,6589, - 1,0,0,0,6602,745,1,0,0,0,6603,6604,5,36,0,0,6604,6608,5,223,0,0, - 6605,6606,5,36,0,0,6606,6608,5,141,0,0,6607,6603,1,0,0,0,6607,6605, - 1,0,0,0,6608,747,1,0,0,0,6609,6610,5,220,0,0,6610,6611,5,396,0,0, - 6611,749,1,0,0,0,6612,6614,5,46,0,0,6613,6615,3,658,329,0,6614,6613, - 1,0,0,0,6614,6615,1,0,0,0,6615,6616,1,0,0,0,6616,6617,5,443,0,0, - 6617,6618,5,62,0,0,6618,6619,3,1168,584,0,6619,6620,5,247,0,0,6620, - 6621,3,1436,718,0,6621,6622,5,2,0,0,6622,6623,3,752,376,0,6623,6624, - 5,3,0,0,6624,751,1,0,0,0,6625,6626,5,64,0,0,6626,6627,5,461,0,0, - 6627,6628,5,105,0,0,6628,6629,5,211,0,0,6629,6630,3,674,337,0,6630, - 6631,5,6,0,0,6631,6632,5,94,0,0,6632,6633,5,461,0,0,6633,6634,5, - 105,0,0,6634,6635,5,211,0,0,6635,6636,3,674,337,0,6636,6660,1,0, - 0,0,6637,6638,5,94,0,0,6638,6639,5,461,0,0,6639,6640,5,105,0,0,6640, - 6641,5,211,0,0,6641,6642,3,674,337,0,6642,6643,5,6,0,0,6643,6644, - 5,64,0,0,6644,6645,5,461,0,0,6645,6646,5,105,0,0,6646,6647,5,211, - 0,0,6647,6648,3,674,337,0,6648,6660,1,0,0,0,6649,6650,5,64,0,0,6650, - 6651,5,461,0,0,6651,6652,5,105,0,0,6652,6653,5,211,0,0,6653,6660, - 3,674,337,0,6654,6655,5,94,0,0,6655,6656,5,461,0,0,6656,6657,5,105, - 0,0,6657,6658,5,211,0,0,6658,6660,3,674,337,0,6659,6625,1,0,0,0, - 6659,6637,1,0,0,0,6659,6649,1,0,0,0,6659,6654,1,0,0,0,6660,753,1, - 0,0,0,6661,6662,5,306,0,0,6662,6678,3,756,378,0,6663,6664,5,306, - 0,0,6664,6678,3,758,379,0,6665,6666,5,306,0,0,6666,6667,5,2,0,0, - 6667,6668,3,760,380,0,6668,6669,5,3,0,0,6669,6670,3,756,378,0,6670, - 6678,1,0,0,0,6671,6672,5,306,0,0,6672,6673,5,2,0,0,6673,6674,3,760, - 380,0,6674,6675,5,3,0,0,6675,6676,3,758,379,0,6676,6678,1,0,0,0, - 6677,6661,1,0,0,0,6677,6663,1,0,0,0,6677,6665,1,0,0,0,6677,6671, - 1,0,0,0,6678,755,1,0,0,0,6679,6681,5,226,0,0,6680,6682,3,630,315, - 0,6681,6680,1,0,0,0,6681,6682,1,0,0,0,6682,6683,1,0,0,0,6683,6690, - 3,1412,706,0,6684,6686,5,92,0,0,6685,6687,3,630,315,0,6686,6685, - 1,0,0,0,6686,6687,1,0,0,0,6687,6688,1,0,0,0,6688,6690,3,1406,703, - 0,6689,6679,1,0,0,0,6689,6684,1,0,0,0,6690,757,1,0,0,0,6691,6693, - 5,323,0,0,6692,6694,3,630,315,0,6693,6692,1,0,0,0,6693,6694,1,0, - 0,0,6694,6695,1,0,0,0,6695,6707,3,1422,711,0,6696,6698,5,349,0,0, - 6697,6699,3,630,315,0,6698,6697,1,0,0,0,6698,6699,1,0,0,0,6699,6700, - 1,0,0,0,6700,6707,3,1436,718,0,6701,6703,5,175,0,0,6702,6704,3,630, - 315,0,6703,6702,1,0,0,0,6703,6704,1,0,0,0,6704,6705,1,0,0,0,6705, - 6707,3,1420,710,0,6706,6691,1,0,0,0,6706,6696,1,0,0,0,6706,6701, - 1,0,0,0,6707,759,1,0,0,0,6708,6713,3,762,381,0,6709,6710,5,6,0,0, - 6710,6712,3,762,381,0,6711,6709,1,0,0,0,6712,6715,1,0,0,0,6713,6711, - 1,0,0,0,6713,6714,1,0,0,0,6714,761,1,0,0,0,6715,6713,1,0,0,0,6716, - 6717,5,128,0,0,6717,763,1,0,0,0,6718,6719,5,138,0,0,6719,6720,5, - 351,0,0,6720,6721,3,1402,701,0,6721,6722,5,333,0,0,6722,6723,3,132, - 66,0,6723,6731,1,0,0,0,6724,6725,5,138,0,0,6725,6726,5,351,0,0,6726, - 6727,3,1402,701,0,6727,6728,5,313,0,0,6728,6729,3,132,66,0,6729, - 6731,1,0,0,0,6730,6718,1,0,0,0,6730,6724,1,0,0,0,6731,765,1,0,0, - 0,6732,6733,5,138,0,0,6733,6734,5,136,0,0,6734,6735,3,698,349,0, - 6735,6736,5,309,0,0,6736,6737,5,94,0,0,6737,6738,3,1436,718,0,6738, - 7124,1,0,0,0,6739,6740,5,138,0,0,6740,6741,5,108,0,0,6741,6742,3, - 558,279,0,6742,6743,5,309,0,0,6743,6744,5,94,0,0,6744,6745,3,1436, - 718,0,6745,7124,1,0,0,0,6746,6747,5,138,0,0,6747,6748,5,168,0,0, - 6748,6749,3,558,279,0,6749,6750,5,309,0,0,6750,6751,5,94,0,0,6751, - 6752,3,1436,718,0,6752,7124,1,0,0,0,6753,6754,5,138,0,0,6754,6755, - 5,175,0,0,6755,6756,3,1420,710,0,6756,6757,5,309,0,0,6757,6758,5, - 94,0,0,6758,6759,3,1418,709,0,6759,7124,1,0,0,0,6760,6761,5,138, - 0,0,6761,6762,5,189,0,0,6762,6763,3,558,279,0,6763,6764,5,309,0, - 0,6764,6765,5,94,0,0,6765,6766,3,1436,718,0,6766,7124,1,0,0,0,6767, - 6768,5,138,0,0,6768,6769,5,189,0,0,6769,6770,3,558,279,0,6770,6771, - 5,309,0,0,6771,6772,5,45,0,0,6772,6773,3,1436,718,0,6773,6774,5, - 94,0,0,6774,6775,3,1436,718,0,6775,7124,1,0,0,0,6776,6777,5,138, - 0,0,6777,6778,5,63,0,0,6778,6779,5,174,0,0,6779,6780,5,381,0,0,6780, - 6781,3,1436,718,0,6781,6782,5,309,0,0,6782,6783,5,94,0,0,6783,6784, - 3,1436,718,0,6784,7124,1,0,0,0,6785,6786,5,138,0,0,6786,6787,5,211, - 0,0,6787,6788,3,674,337,0,6788,6789,5,309,0,0,6789,6790,5,94,0,0, - 6790,6791,3,1442,721,0,6791,7124,1,0,0,0,6792,6793,5,138,0,0,6793, - 6794,5,66,0,0,6794,6795,3,1468,734,0,6795,6796,5,309,0,0,6796,6797, - 5,94,0,0,6797,6798,3,1468,734,0,6798,7124,1,0,0,0,6799,6801,5,138, - 0,0,6800,6802,3,338,169,0,6801,6800,1,0,0,0,6801,6802,1,0,0,0,6802, - 6803,1,0,0,0,6803,6804,5,247,0,0,6804,6805,3,1436,718,0,6805,6806, - 5,309,0,0,6806,6807,5,94,0,0,6807,6808,3,1436,718,0,6808,7124,1, - 0,0,0,6809,6810,5,138,0,0,6810,6811,5,278,0,0,6811,6812,5,156,0, - 0,6812,6813,3,558,279,0,6813,6814,5,100,0,0,6814,6815,3,1436,718, - 0,6815,6816,5,309,0,0,6816,6817,5,94,0,0,6817,6818,3,1436,718,0, - 6818,7124,1,0,0,0,6819,6820,5,138,0,0,6820,6821,5,278,0,0,6821,6822, - 5,206,0,0,6822,6823,3,558,279,0,6823,6824,5,100,0,0,6824,6825,3, - 1436,718,0,6825,6826,5,309,0,0,6826,6827,5,94,0,0,6827,6828,3,1436, - 718,0,6828,7124,1,0,0,0,6829,6830,5,138,0,0,6830,6832,5,445,0,0, - 6831,6833,3,748,374,0,6832,6831,1,0,0,0,6832,6833,1,0,0,0,6833,6834, - 1,0,0,0,6834,6835,3,1436,718,0,6835,6836,5,80,0,0,6836,6837,3,1412, - 706,0,6837,6838,5,309,0,0,6838,6839,5,94,0,0,6839,6840,3,1436,718, - 0,6840,7124,1,0,0,0,6841,6842,5,138,0,0,6842,6843,5,296,0,0,6843, - 6844,3,670,335,0,6844,6845,5,309,0,0,6845,6846,5,94,0,0,6846,6847, - 3,1430,715,0,6847,7124,1,0,0,0,6848,6849,5,138,0,0,6849,6850,5,452, - 0,0,6850,6851,3,1436,718,0,6851,6852,5,309,0,0,6852,6853,5,94,0, - 0,6853,6854,3,1436,718,0,6854,7124,1,0,0,0,6855,6856,5,138,0,0,6856, - 6857,5,442,0,0,6857,6858,3,666,333,0,6858,6859,5,309,0,0,6859,6860, - 5,94,0,0,6860,6861,3,1436,718,0,6861,7124,1,0,0,0,6862,6863,5,138, - 0,0,6863,6864,5,323,0,0,6864,6865,3,1422,711,0,6865,6866,5,309,0, - 0,6866,6867,5,94,0,0,6867,6868,3,48,24,0,6868,7124,1,0,0,0,6869, - 6870,5,138,0,0,6870,6871,5,331,0,0,6871,6872,3,1436,718,0,6872,6873, - 5,309,0,0,6873,6874,5,94,0,0,6874,6875,3,1436,718,0,6875,7124,1, - 0,0,0,6876,6877,5,138,0,0,6877,6878,5,451,0,0,6878,6879,3,1436,718, - 0,6879,6880,5,309,0,0,6880,6881,5,94,0,0,6881,6882,3,1436,718,0, - 6882,7124,1,0,0,0,6883,6884,5,138,0,0,6884,6886,5,92,0,0,6885,6887, - 3,748,374,0,6886,6885,1,0,0,0,6886,6887,1,0,0,0,6887,6888,1,0,0, - 0,6888,6889,3,1118,559,0,6889,6890,5,309,0,0,6890,6891,5,94,0,0, - 6891,6892,3,1404,702,0,6892,7124,1,0,0,0,6893,6894,5,138,0,0,6894, - 6896,5,328,0,0,6895,6897,3,748,374,0,6896,6895,1,0,0,0,6896,6897, - 1,0,0,0,6897,6898,1,0,0,0,6898,6899,3,1412,706,0,6899,6900,5,309, - 0,0,6900,6901,5,94,0,0,6901,6902,3,1436,718,0,6902,7124,1,0,0,0, - 6903,6904,5,138,0,0,6904,6906,5,376,0,0,6905,6907,3,748,374,0,6906, - 6905,1,0,0,0,6906,6907,1,0,0,0,6907,6908,1,0,0,0,6908,6909,3,1410, - 705,0,6909,6910,5,309,0,0,6910,6911,5,94,0,0,6911,6912,3,1408,704, - 0,6912,7124,1,0,0,0,6913,6914,5,138,0,0,6914,6915,5,259,0,0,6915, - 6917,5,376,0,0,6916,6918,3,748,374,0,6917,6916,1,0,0,0,6917,6918, - 1,0,0,0,6918,6919,1,0,0,0,6919,6920,3,1410,705,0,6920,6921,5,309, - 0,0,6921,6922,5,94,0,0,6922,6923,3,1408,704,0,6923,7124,1,0,0,0, - 6924,6925,5,138,0,0,6925,6927,5,226,0,0,6926,6928,3,748,374,0,6927, - 6926,1,0,0,0,6927,6928,1,0,0,0,6928,6929,1,0,0,0,6929,6930,3,1412, - 706,0,6930,6931,5,309,0,0,6931,6932,5,94,0,0,6932,6933,3,1436,718, - 0,6933,7124,1,0,0,0,6934,6935,5,138,0,0,6935,6936,5,63,0,0,6936, - 6938,5,92,0,0,6937,6939,3,748,374,0,6938,6937,1,0,0,0,6938,6939, - 1,0,0,0,6939,6940,1,0,0,0,6940,6941,3,1118,559,0,6941,6942,5,309, - 0,0,6942,6943,5,94,0,0,6943,6944,3,1404,702,0,6944,7124,1,0,0,0, - 6945,6946,5,138,0,0,6946,6948,5,92,0,0,6947,6949,3,748,374,0,6948, - 6947,1,0,0,0,6948,6949,1,0,0,0,6949,6950,1,0,0,0,6950,6951,3,1118, - 559,0,6951,6953,5,309,0,0,6952,6954,5,44,0,0,6953,6952,1,0,0,0,6953, - 6954,1,0,0,0,6954,6955,1,0,0,0,6955,6956,3,1432,716,0,6956,6957, - 5,94,0,0,6957,6958,3,1434,717,0,6958,7124,1,0,0,0,6959,6960,5,138, - 0,0,6960,6962,5,376,0,0,6961,6963,3,748,374,0,6962,6961,1,0,0,0, - 6962,6963,1,0,0,0,6963,6964,1,0,0,0,6964,6965,3,1410,705,0,6965, - 6967,5,309,0,0,6966,6968,5,44,0,0,6967,6966,1,0,0,0,6967,6968,1, - 0,0,0,6968,6969,1,0,0,0,6969,6970,3,1432,716,0,6970,6971,5,94,0, - 0,6971,6972,3,1434,717,0,6972,7124,1,0,0,0,6973,6974,5,138,0,0,6974, - 6975,5,259,0,0,6975,6977,5,376,0,0,6976,6978,3,748,374,0,6977,6976, - 1,0,0,0,6977,6978,1,0,0,0,6978,6979,1,0,0,0,6979,6980,3,1410,705, - 0,6980,6982,5,309,0,0,6981,6983,5,44,0,0,6982,6981,1,0,0,0,6982, - 6983,1,0,0,0,6983,6984,1,0,0,0,6984,6985,3,1432,716,0,6985,6986, - 5,94,0,0,6986,6987,3,1434,717,0,6987,7124,1,0,0,0,6988,6989,5,138, - 0,0,6989,6991,5,92,0,0,6990,6992,3,748,374,0,6991,6990,1,0,0,0,6991, - 6992,1,0,0,0,6992,6993,1,0,0,0,6993,6994,3,1118,559,0,6994,6995, - 5,309,0,0,6995,6996,5,45,0,0,6996,6997,3,1436,718,0,6997,6998,5, - 94,0,0,6998,6999,3,1436,718,0,6999,7124,1,0,0,0,7000,7001,5,138, - 0,0,7001,7002,5,63,0,0,7002,7004,5,92,0,0,7003,7005,3,748,374,0, - 7004,7003,1,0,0,0,7004,7005,1,0,0,0,7005,7006,1,0,0,0,7006,7007, - 3,1118,559,0,7007,7009,5,309,0,0,7008,7010,5,44,0,0,7009,7008,1, - 0,0,0,7009,7010,1,0,0,0,7010,7011,1,0,0,0,7011,7012,3,1432,716,0, - 7012,7013,5,94,0,0,7013,7014,3,1434,717,0,7014,7124,1,0,0,0,7015, - 7016,5,138,0,0,7016,7017,5,321,0,0,7017,7018,3,1436,718,0,7018,7019, - 5,80,0,0,7019,7020,3,1412,706,0,7020,7021,5,309,0,0,7021,7022,5, - 94,0,0,7022,7023,3,1436,718,0,7023,7124,1,0,0,0,7024,7025,5,138, - 0,0,7025,7026,5,357,0,0,7026,7027,3,1436,718,0,7027,7028,5,80,0, - 0,7028,7029,3,1412,706,0,7029,7030,5,309,0,0,7030,7031,5,94,0,0, - 7031,7032,3,1436,718,0,7032,7124,1,0,0,0,7033,7034,5,138,0,0,7034, - 7035,5,198,0,0,7035,7036,5,357,0,0,7036,7037,3,1436,718,0,7037,7038, - 5,309,0,0,7038,7039,5,94,0,0,7039,7040,3,1436,718,0,7040,7124,1, - 0,0,0,7041,7042,5,138,0,0,7042,7043,5,318,0,0,7043,7044,3,1468,734, - 0,7044,7045,5,309,0,0,7045,7046,5,94,0,0,7046,7047,3,1468,734,0, - 7047,7124,1,0,0,0,7048,7049,5,138,0,0,7049,7050,5,99,0,0,7050,7051, - 3,1468,734,0,7051,7052,5,309,0,0,7052,7053,5,94,0,0,7053,7054,3, - 1468,734,0,7054,7124,1,0,0,0,7055,7056,5,138,0,0,7056,7057,5,351, - 0,0,7057,7058,3,1402,701,0,7058,7059,5,309,0,0,7059,7060,5,94,0, - 0,7060,7061,3,1400,700,0,7061,7124,1,0,0,0,7062,7063,5,138,0,0,7063, - 7064,5,342,0,0,7064,7065,3,558,279,0,7065,7066,5,309,0,0,7066,7067, - 5,94,0,0,7067,7068,3,1436,718,0,7068,7124,1,0,0,0,7069,7070,5,138, - 0,0,7070,7071,5,355,0,0,7071,7072,5,325,0,0,7072,7073,5,283,0,0, - 7073,7074,3,558,279,0,7074,7075,5,309,0,0,7075,7076,5,94,0,0,7076, - 7077,3,1436,718,0,7077,7124,1,0,0,0,7078,7079,5,138,0,0,7079,7080, - 5,355,0,0,7080,7081,5,325,0,0,7081,7082,5,185,0,0,7082,7083,3,558, - 279,0,7083,7084,5,309,0,0,7084,7085,5,94,0,0,7085,7086,3,1436,718, - 0,7086,7124,1,0,0,0,7087,7088,5,138,0,0,7088,7089,5,355,0,0,7089, - 7090,5,325,0,0,7090,7091,5,353,0,0,7091,7092,3,558,279,0,7092,7093, - 5,309,0,0,7093,7094,5,94,0,0,7094,7095,3,1436,718,0,7095,7124,1, - 0,0,0,7096,7097,5,138,0,0,7097,7098,5,355,0,0,7098,7099,5,325,0, - 0,7099,7100,5,163,0,0,7100,7101,3,558,279,0,7101,7102,5,309,0,0, - 7102,7103,5,94,0,0,7103,7104,3,1436,718,0,7104,7124,1,0,0,0,7105, - 7106,5,138,0,0,7106,7107,5,360,0,0,7107,7108,3,558,279,0,7108,7109, - 5,309,0,0,7109,7110,5,94,0,0,7110,7111,3,1436,718,0,7111,7124,1, - 0,0,0,7112,7113,5,138,0,0,7113,7114,5,360,0,0,7114,7115,3,558,279, - 0,7115,7116,5,309,0,0,7116,7117,5,143,0,0,7117,7118,3,1436,718,0, - 7118,7119,5,94,0,0,7119,7121,3,1436,718,0,7120,7122,3,124,62,0,7121, - 7120,1,0,0,0,7121,7122,1,0,0,0,7122,7124,1,0,0,0,7123,6732,1,0,0, - 0,7123,6739,1,0,0,0,7123,6746,1,0,0,0,7123,6753,1,0,0,0,7123,6760, - 1,0,0,0,7123,6767,1,0,0,0,7123,6776,1,0,0,0,7123,6785,1,0,0,0,7123, - 6792,1,0,0,0,7123,6799,1,0,0,0,7123,6809,1,0,0,0,7123,6819,1,0,0, - 0,7123,6829,1,0,0,0,7123,6841,1,0,0,0,7123,6848,1,0,0,0,7123,6855, - 1,0,0,0,7123,6862,1,0,0,0,7123,6869,1,0,0,0,7123,6876,1,0,0,0,7123, - 6883,1,0,0,0,7123,6893,1,0,0,0,7123,6903,1,0,0,0,7123,6913,1,0,0, - 0,7123,6924,1,0,0,0,7123,6934,1,0,0,0,7123,6945,1,0,0,0,7123,6959, - 1,0,0,0,7123,6973,1,0,0,0,7123,6988,1,0,0,0,7123,7000,1,0,0,0,7123, - 7015,1,0,0,0,7123,7024,1,0,0,0,7123,7033,1,0,0,0,7123,7041,1,0,0, - 0,7123,7048,1,0,0,0,7123,7055,1,0,0,0,7123,7062,1,0,0,0,7123,7069, - 1,0,0,0,7123,7078,1,0,0,0,7123,7087,1,0,0,0,7123,7096,1,0,0,0,7123, - 7105,1,0,0,0,7123,7112,1,0,0,0,7124,767,1,0,0,0,7125,7126,5,333, - 0,0,7126,7127,5,174,0,0,7127,769,1,0,0,0,7128,7129,5,138,0,0,7129, - 7130,5,211,0,0,7130,7132,3,674,337,0,7131,7133,3,772,386,0,7132, - 7131,1,0,0,0,7132,7133,1,0,0,0,7133,7134,1,0,0,0,7134,7135,5,462, - 0,0,7135,7136,5,80,0,0,7136,7137,5,204,0,0,7137,7138,3,1436,718, - 0,7138,7198,1,0,0,0,7139,7140,5,138,0,0,7140,7141,5,296,0,0,7141, - 7143,3,670,335,0,7142,7144,3,772,386,0,7143,7142,1,0,0,0,7143,7144, - 1,0,0,0,7144,7145,1,0,0,0,7145,7146,5,462,0,0,7146,7147,5,80,0,0, - 7147,7148,5,204,0,0,7148,7149,3,1436,718,0,7149,7198,1,0,0,0,7150, - 7151,5,138,0,0,7151,7152,5,442,0,0,7152,7154,3,666,333,0,7153,7155, - 3,772,386,0,7154,7153,1,0,0,0,7154,7155,1,0,0,0,7155,7156,1,0,0, - 0,7156,7157,5,462,0,0,7157,7158,5,80,0,0,7158,7159,5,204,0,0,7159, - 7160,3,1436,718,0,7160,7198,1,0,0,0,7161,7162,5,138,0,0,7162,7163, - 5,357,0,0,7163,7164,3,1436,718,0,7164,7165,5,80,0,0,7165,7167,3, - 1412,706,0,7166,7168,3,772,386,0,7167,7166,1,0,0,0,7167,7168,1,0, - 0,0,7168,7169,1,0,0,0,7169,7170,5,462,0,0,7170,7171,5,80,0,0,7171, - 7172,5,204,0,0,7172,7173,3,1436,718,0,7173,7198,1,0,0,0,7174,7175, - 5,138,0,0,7175,7176,5,259,0,0,7176,7177,5,376,0,0,7177,7179,3,1410, - 705,0,7178,7180,3,772,386,0,7179,7178,1,0,0,0,7179,7180,1,0,0,0, - 7180,7181,1,0,0,0,7181,7182,5,462,0,0,7182,7183,5,80,0,0,7183,7184, - 5,204,0,0,7184,7185,3,1436,718,0,7185,7198,1,0,0,0,7186,7187,5,138, - 0,0,7187,7188,5,226,0,0,7188,7190,3,1412,706,0,7189,7191,3,772,386, - 0,7190,7189,1,0,0,0,7190,7191,1,0,0,0,7191,7192,1,0,0,0,7192,7193, - 5,462,0,0,7193,7194,5,80,0,0,7194,7195,5,204,0,0,7195,7196,3,1436, - 718,0,7196,7198,1,0,0,0,7197,7128,1,0,0,0,7197,7139,1,0,0,0,7197, - 7150,1,0,0,0,7197,7161,1,0,0,0,7197,7174,1,0,0,0,7197,7186,1,0,0, - 0,7198,771,1,0,0,0,7199,7200,5,269,0,0,7200,773,1,0,0,0,7201,7202, - 5,138,0,0,7202,7203,5,136,0,0,7203,7204,3,698,349,0,7204,7205,5, - 333,0,0,7205,7206,5,323,0,0,7206,7207,3,1422,711,0,7207,7387,1,0, - 0,0,7208,7209,5,138,0,0,7209,7210,5,108,0,0,7210,7211,3,558,279, - 0,7211,7212,5,333,0,0,7212,7213,5,323,0,0,7213,7214,3,1422,711,0, - 7214,7387,1,0,0,0,7215,7216,5,138,0,0,7216,7217,5,168,0,0,7217,7218, - 3,558,279,0,7218,7219,5,333,0,0,7219,7220,5,323,0,0,7220,7221,3, - 1422,711,0,7221,7387,1,0,0,0,7222,7223,5,138,0,0,7223,7224,5,189, - 0,0,7224,7225,3,558,279,0,7225,7226,5,333,0,0,7226,7227,5,323,0, - 0,7227,7228,3,1422,711,0,7228,7387,1,0,0,0,7229,7230,5,138,0,0,7230, - 7231,5,204,0,0,7231,7232,3,1436,718,0,7232,7233,5,333,0,0,7233,7234, - 5,323,0,0,7234,7235,3,1422,711,0,7235,7387,1,0,0,0,7236,7237,5,138, - 0,0,7237,7238,5,211,0,0,7238,7239,3,674,337,0,7239,7240,5,333,0, - 0,7240,7241,5,323,0,0,7241,7242,3,1422,711,0,7242,7387,1,0,0,0,7243, - 7244,5,138,0,0,7244,7245,5,278,0,0,7245,7246,3,736,368,0,7246,7247, - 5,333,0,0,7247,7248,5,323,0,0,7248,7249,3,1422,711,0,7249,7387,1, - 0,0,0,7250,7251,5,138,0,0,7251,7252,5,278,0,0,7252,7253,5,156,0, - 0,7253,7254,3,558,279,0,7254,7255,5,100,0,0,7255,7256,3,1436,718, - 0,7256,7257,5,333,0,0,7257,7258,5,323,0,0,7258,7259,3,1422,711,0, - 7259,7387,1,0,0,0,7260,7261,5,138,0,0,7261,7262,5,278,0,0,7262,7263, - 5,206,0,0,7263,7264,3,558,279,0,7264,7265,5,100,0,0,7265,7266,3, - 1436,718,0,7266,7267,5,333,0,0,7267,7268,5,323,0,0,7268,7269,3,1422, - 711,0,7269,7387,1,0,0,0,7270,7271,5,138,0,0,7271,7272,5,296,0,0, - 7272,7273,3,670,335,0,7273,7274,5,333,0,0,7274,7275,5,323,0,0,7275, - 7276,3,1422,711,0,7276,7387,1,0,0,0,7277,7278,5,138,0,0,7278,7279, - 5,442,0,0,7279,7280,3,666,333,0,7280,7281,5,333,0,0,7281,7282,5, - 323,0,0,7282,7283,3,1422,711,0,7283,7387,1,0,0,0,7284,7285,5,138, - 0,0,7285,7287,5,92,0,0,7286,7288,3,748,374,0,7287,7286,1,0,0,0,7287, - 7288,1,0,0,0,7288,7289,1,0,0,0,7289,7290,3,1118,559,0,7290,7291, - 5,333,0,0,7291,7292,5,323,0,0,7292,7293,3,1422,711,0,7293,7387,1, - 0,0,0,7294,7295,5,138,0,0,7295,7296,5,342,0,0,7296,7297,3,558,279, - 0,7297,7298,5,333,0,0,7298,7299,5,323,0,0,7299,7300,3,1422,711,0, - 7300,7387,1,0,0,0,7301,7302,5,138,0,0,7302,7303,5,355,0,0,7303,7304, - 5,325,0,0,7304,7305,5,283,0,0,7305,7306,3,558,279,0,7306,7307,5, - 333,0,0,7307,7308,5,323,0,0,7308,7309,3,1422,711,0,7309,7387,1,0, - 0,0,7310,7311,5,138,0,0,7311,7312,5,355,0,0,7312,7313,5,325,0,0, - 7313,7314,5,185,0,0,7314,7315,3,558,279,0,7315,7316,5,333,0,0,7316, - 7317,5,323,0,0,7317,7318,3,1422,711,0,7318,7387,1,0,0,0,7319,7320, - 5,138,0,0,7320,7321,5,355,0,0,7321,7322,5,325,0,0,7322,7323,5,353, - 0,0,7323,7324,3,558,279,0,7324,7325,5,333,0,0,7325,7326,5,323,0, - 0,7326,7327,3,1422,711,0,7327,7387,1,0,0,0,7328,7329,5,138,0,0,7329, - 7330,5,355,0,0,7330,7331,5,325,0,0,7331,7332,5,163,0,0,7332,7333, - 3,558,279,0,7333,7334,5,333,0,0,7334,7335,5,323,0,0,7335,7336,3, - 1422,711,0,7336,7387,1,0,0,0,7337,7338,5,138,0,0,7338,7340,5,328, - 0,0,7339,7341,3,748,374,0,7340,7339,1,0,0,0,7340,7341,1,0,0,0,7341, - 7342,1,0,0,0,7342,7343,3,1412,706,0,7343,7344,5,333,0,0,7344,7345, - 5,323,0,0,7345,7346,3,1422,711,0,7346,7387,1,0,0,0,7347,7348,5,138, - 0,0,7348,7350,5,376,0,0,7349,7351,3,748,374,0,7350,7349,1,0,0,0, - 7350,7351,1,0,0,0,7351,7352,1,0,0,0,7352,7353,3,1410,705,0,7353, - 7354,5,333,0,0,7354,7355,5,323,0,0,7355,7356,3,1422,711,0,7356,7387, - 1,0,0,0,7357,7358,5,138,0,0,7358,7359,5,259,0,0,7359,7361,5,376, - 0,0,7360,7362,3,748,374,0,7361,7360,1,0,0,0,7361,7362,1,0,0,0,7362, - 7363,1,0,0,0,7363,7364,3,1410,705,0,7364,7365,5,333,0,0,7365,7366, - 5,323,0,0,7366,7367,3,1422,711,0,7367,7387,1,0,0,0,7368,7369,5,138, - 0,0,7369,7370,5,63,0,0,7370,7372,5,92,0,0,7371,7373,3,748,374,0, - 7372,7371,1,0,0,0,7372,7373,1,0,0,0,7373,7374,1,0,0,0,7374,7375, - 3,1118,559,0,7375,7376,5,333,0,0,7376,7377,5,323,0,0,7377,7378,3, - 1422,711,0,7378,7387,1,0,0,0,7379,7380,5,138,0,0,7380,7381,5,360, - 0,0,7381,7382,3,558,279,0,7382,7383,5,333,0,0,7383,7384,5,323,0, - 0,7384,7385,3,1422,711,0,7385,7387,1,0,0,0,7386,7201,1,0,0,0,7386, - 7208,1,0,0,0,7386,7215,1,0,0,0,7386,7222,1,0,0,0,7386,7229,1,0,0, - 0,7386,7236,1,0,0,0,7386,7243,1,0,0,0,7386,7250,1,0,0,0,7386,7260, - 1,0,0,0,7386,7270,1,0,0,0,7386,7277,1,0,0,0,7386,7284,1,0,0,0,7386, - 7294,1,0,0,0,7386,7301,1,0,0,0,7386,7310,1,0,0,0,7386,7319,1,0,0, - 0,7386,7328,1,0,0,0,7386,7337,1,0,0,0,7386,7347,1,0,0,0,7386,7357, - 1,0,0,0,7386,7368,1,0,0,0,7386,7379,1,0,0,0,7387,775,1,0,0,0,7388, - 7389,5,138,0,0,7389,7390,5,278,0,0,7390,7391,3,736,368,0,7391,7392, - 5,333,0,0,7392,7393,5,2,0,0,7393,7394,3,778,389,0,7394,7395,5,3, - 0,0,7395,777,1,0,0,0,7396,7401,3,780,390,0,7397,7398,5,6,0,0,7398, - 7400,3,780,390,0,7399,7397,1,0,0,0,7400,7403,1,0,0,0,7401,7399,1, - 0,0,0,7401,7402,1,0,0,0,7402,779,1,0,0,0,7403,7401,1,0,0,0,7404, - 7405,3,1490,745,0,7405,7406,5,10,0,0,7406,7407,5,407,0,0,7407,7413, - 1,0,0,0,7408,7409,3,1490,745,0,7409,7410,5,10,0,0,7410,7411,3,782, - 391,0,7411,7413,1,0,0,0,7412,7404,1,0,0,0,7412,7408,1,0,0,0,7413, - 781,1,0,0,0,7414,7420,3,688,344,0,7415,7420,3,1502,751,0,7416,7420, - 3,1324,662,0,7417,7420,3,322,161,0,7418,7420,3,1458,729,0,7419,7414, - 1,0,0,0,7419,7415,1,0,0,0,7419,7416,1,0,0,0,7419,7417,1,0,0,0,7419, - 7418,1,0,0,0,7420,783,1,0,0,0,7421,7422,5,138,0,0,7422,7423,5,360, - 0,0,7423,7424,3,558,279,0,7424,7425,5,333,0,0,7425,7426,5,2,0,0, - 7426,7427,3,778,389,0,7427,7428,5,3,0,0,7428,785,1,0,0,0,7429,7430, - 5,138,0,0,7430,7431,5,136,0,0,7431,7432,3,698,349,0,7432,7433,5, - 282,0,0,7433,7434,5,94,0,0,7434,7435,3,1470,735,0,7435,7615,1,0, - 0,0,7436,7437,5,138,0,0,7437,7438,5,108,0,0,7438,7439,3,558,279, - 0,7439,7440,5,282,0,0,7440,7441,5,94,0,0,7441,7442,3,1470,735,0, - 7442,7615,1,0,0,0,7443,7444,5,138,0,0,7444,7445,5,168,0,0,7445,7446, - 3,558,279,0,7446,7447,5,282,0,0,7447,7448,5,94,0,0,7448,7449,3,1470, - 735,0,7449,7615,1,0,0,0,7450,7451,5,138,0,0,7451,7452,5,175,0,0, - 7452,7453,3,1420,710,0,7453,7454,5,282,0,0,7454,7455,5,94,0,0,7455, - 7456,3,1470,735,0,7456,7615,1,0,0,0,7457,7458,5,138,0,0,7458,7459, - 5,189,0,0,7459,7460,3,558,279,0,7460,7461,5,282,0,0,7461,7462,5, - 94,0,0,7462,7463,3,1470,735,0,7463,7615,1,0,0,0,7464,7465,5,138, - 0,0,7465,7466,5,211,0,0,7466,7467,3,674,337,0,7467,7468,5,282,0, - 0,7468,7469,5,94,0,0,7469,7470,3,1470,735,0,7470,7615,1,0,0,0,7471, - 7473,5,138,0,0,7472,7474,3,338,169,0,7473,7472,1,0,0,0,7473,7474, - 1,0,0,0,7474,7475,1,0,0,0,7475,7476,5,247,0,0,7476,7477,3,1436,718, - 0,7477,7478,5,282,0,0,7478,7479,5,94,0,0,7479,7480,3,1470,735,0, - 7480,7615,1,0,0,0,7481,7482,5,138,0,0,7482,7483,5,248,0,0,7483,7484, - 5,274,0,0,7484,7485,3,322,161,0,7485,7486,5,282,0,0,7486,7487,5, - 94,0,0,7487,7488,3,1470,735,0,7488,7615,1,0,0,0,7489,7490,5,138, - 0,0,7490,7491,5,278,0,0,7491,7492,3,736,368,0,7492,7493,5,282,0, - 0,7493,7494,5,94,0,0,7494,7495,3,1470,735,0,7495,7615,1,0,0,0,7496, - 7497,5,138,0,0,7497,7498,5,278,0,0,7498,7499,5,156,0,0,7499,7500, - 3,558,279,0,7500,7501,5,100,0,0,7501,7502,3,1436,718,0,7502,7503, - 5,282,0,0,7503,7504,5,94,0,0,7504,7505,3,1470,735,0,7505,7615,1, - 0,0,0,7506,7507,5,138,0,0,7507,7508,5,278,0,0,7508,7509,5,206,0, - 0,7509,7510,3,558,279,0,7510,7511,5,100,0,0,7511,7512,3,1436,718, - 0,7512,7513,5,282,0,0,7513,7514,5,94,0,0,7514,7515,3,1470,735,0, - 7515,7615,1,0,0,0,7516,7517,5,138,0,0,7517,7518,5,296,0,0,7518,7519, - 3,670,335,0,7519,7520,5,282,0,0,7520,7521,5,94,0,0,7521,7522,3,1470, - 735,0,7522,7615,1,0,0,0,7523,7524,5,138,0,0,7524,7525,5,442,0,0, - 7525,7526,3,666,333,0,7526,7527,5,282,0,0,7527,7528,5,94,0,0,7528, - 7529,3,1470,735,0,7529,7615,1,0,0,0,7530,7531,5,138,0,0,7531,7532, - 5,323,0,0,7532,7533,3,1422,711,0,7533,7534,5,282,0,0,7534,7535,5, - 94,0,0,7535,7536,3,1470,735,0,7536,7615,1,0,0,0,7537,7538,5,138, - 0,0,7538,7539,5,360,0,0,7539,7540,3,558,279,0,7540,7541,5,282,0, - 0,7541,7542,5,94,0,0,7542,7543,3,1470,735,0,7543,7615,1,0,0,0,7544, - 7545,5,138,0,0,7545,7546,5,351,0,0,7546,7547,3,1402,701,0,7547,7548, - 5,282,0,0,7548,7549,5,94,0,0,7549,7550,3,1470,735,0,7550,7615,1, - 0,0,0,7551,7552,5,138,0,0,7552,7553,5,342,0,0,7553,7554,3,558,279, - 0,7554,7555,5,282,0,0,7555,7556,5,94,0,0,7556,7557,3,1470,735,0, - 7557,7615,1,0,0,0,7558,7559,5,138,0,0,7559,7560,5,355,0,0,7560,7561, - 5,325,0,0,7561,7562,5,185,0,0,7562,7563,3,558,279,0,7563,7564,5, - 282,0,0,7564,7565,5,94,0,0,7565,7566,3,1470,735,0,7566,7615,1,0, - 0,0,7567,7568,5,138,0,0,7568,7569,5,355,0,0,7569,7570,5,325,0,0, - 7570,7571,5,163,0,0,7571,7572,3,558,279,0,7572,7573,5,282,0,0,7573, - 7574,5,94,0,0,7574,7575,3,1470,735,0,7575,7615,1,0,0,0,7576,7577, - 5,138,0,0,7577,7578,5,63,0,0,7578,7579,5,174,0,0,7579,7580,5,381, - 0,0,7580,7581,3,1436,718,0,7581,7582,5,282,0,0,7582,7583,5,94,0, - 0,7583,7584,3,1470,735,0,7584,7615,1,0,0,0,7585,7586,5,138,0,0,7586, - 7587,5,331,0,0,7587,7588,3,1436,718,0,7588,7589,5,282,0,0,7589,7590, - 5,94,0,0,7590,7591,3,1470,735,0,7591,7615,1,0,0,0,7592,7593,5,138, - 0,0,7593,7594,5,198,0,0,7594,7595,5,357,0,0,7595,7596,3,1436,718, - 0,7596,7597,5,282,0,0,7597,7598,5,94,0,0,7598,7599,3,1470,735,0, - 7599,7615,1,0,0,0,7600,7601,5,138,0,0,7601,7602,5,452,0,0,7602,7603, - 3,1436,718,0,7603,7604,5,282,0,0,7604,7605,5,94,0,0,7605,7606,3, - 1470,735,0,7606,7615,1,0,0,0,7607,7608,5,138,0,0,7608,7609,5,451, - 0,0,7609,7610,3,1436,718,0,7610,7611,5,282,0,0,7611,7612,5,94,0, - 0,7612,7613,3,1470,735,0,7613,7615,1,0,0,0,7614,7429,1,0,0,0,7614, - 7436,1,0,0,0,7614,7443,1,0,0,0,7614,7450,1,0,0,0,7614,7457,1,0,0, - 0,7614,7464,1,0,0,0,7614,7471,1,0,0,0,7614,7481,1,0,0,0,7614,7489, - 1,0,0,0,7614,7496,1,0,0,0,7614,7506,1,0,0,0,7614,7516,1,0,0,0,7614, - 7523,1,0,0,0,7614,7530,1,0,0,0,7614,7537,1,0,0,0,7614,7544,1,0,0, - 0,7614,7551,1,0,0,0,7614,7558,1,0,0,0,7614,7567,1,0,0,0,7614,7576, - 1,0,0,0,7614,7585,1,0,0,0,7614,7592,1,0,0,0,7614,7600,1,0,0,0,7614, - 7607,1,0,0,0,7615,787,1,0,0,0,7616,7617,5,46,0,0,7617,7618,5,452, - 0,0,7618,7620,3,1436,718,0,7619,7621,3,790,395,0,7620,7619,1,0,0, - 0,7620,7621,1,0,0,0,7621,7623,1,0,0,0,7622,7624,3,710,355,0,7623, - 7622,1,0,0,0,7623,7624,1,0,0,0,7624,789,1,0,0,0,7625,7626,3,792, - 396,0,7626,791,1,0,0,0,7627,7628,5,62,0,0,7628,7629,5,92,0,0,7629, - 7634,3,1124,562,0,7630,7631,5,62,0,0,7631,7632,5,30,0,0,7632,7634, - 5,350,0,0,7633,7627,1,0,0,0,7633,7630,1,0,0,0,7634,793,1,0,0,0,7635, - 7636,5,138,0,0,7636,7637,5,452,0,0,7637,7638,3,1436,718,0,7638,7639, - 5,333,0,0,7639,7640,3,496,248,0,7640,7674,1,0,0,0,7641,7642,5,138, - 0,0,7642,7643,5,452,0,0,7643,7644,3,1436,718,0,7644,7645,5,133,0, - 0,7645,7646,3,1126,563,0,7646,7674,1,0,0,0,7647,7648,5,138,0,0,7648, - 7649,5,452,0,0,7649,7650,3,1436,718,0,7650,7651,5,333,0,0,7651,7652, - 3,1126,563,0,7652,7674,1,0,0,0,7653,7654,5,138,0,0,7654,7655,5,452, - 0,0,7655,7656,3,1436,718,0,7656,7657,5,191,0,0,7657,7658,3,1126, - 563,0,7658,7674,1,0,0,0,7659,7660,5,138,0,0,7660,7661,5,452,0,0, - 7661,7662,3,1436,718,0,7662,7663,5,282,0,0,7663,7664,5,94,0,0,7664, - 7665,3,1470,735,0,7665,7674,1,0,0,0,7666,7667,5,138,0,0,7667,7668, - 5,452,0,0,7668,7669,3,1436,718,0,7669,7670,5,309,0,0,7670,7671,5, - 94,0,0,7671,7672,3,1436,718,0,7672,7674,1,0,0,0,7673,7635,1,0,0, - 0,7673,7641,1,0,0,0,7673,7647,1,0,0,0,7673,7653,1,0,0,0,7673,7659, - 1,0,0,0,7673,7666,1,0,0,0,7674,795,1,0,0,0,7675,7676,5,46,0,0,7676, - 7677,5,451,0,0,7677,7678,3,1436,718,0,7678,7679,5,164,0,0,7679,7680, - 3,1458,729,0,7680,7681,5,452,0,0,7681,7683,3,798,399,0,7682,7684, - 3,710,355,0,7683,7682,1,0,0,0,7683,7684,1,0,0,0,7684,797,1,0,0,0, - 7685,7690,3,800,400,0,7686,7687,5,6,0,0,7687,7689,3,800,400,0,7688, - 7686,1,0,0,0,7689,7692,1,0,0,0,7690,7688,1,0,0,0,7690,7691,1,0,0, - 0,7691,799,1,0,0,0,7692,7690,1,0,0,0,7693,7694,3,1490,745,0,7694, - 801,1,0,0,0,7695,7696,5,138,0,0,7696,7697,5,451,0,0,7697,7698,3, - 1436,718,0,7698,7699,5,333,0,0,7699,7700,3,496,248,0,7700,7774,1, - 0,0,0,7701,7702,5,138,0,0,7702,7703,5,451,0,0,7703,7704,3,1436,718, - 0,7704,7705,5,164,0,0,7705,7706,3,1458,729,0,7706,7774,1,0,0,0,7707, - 7708,5,138,0,0,7708,7709,5,451,0,0,7709,7710,3,1436,718,0,7710,7711, - 5,305,0,0,7711,7713,5,452,0,0,7712,7714,3,710,355,0,7713,7712,1, - 0,0,0,7713,7714,1,0,0,0,7714,7774,1,0,0,0,7715,7716,5,138,0,0,7716, - 7717,5,451,0,0,7717,7718,3,1436,718,0,7718,7719,5,333,0,0,7719,7720, - 5,452,0,0,7720,7722,3,798,399,0,7721,7723,3,710,355,0,7722,7721, - 1,0,0,0,7722,7723,1,0,0,0,7723,7774,1,0,0,0,7724,7725,5,138,0,0, - 7725,7726,5,451,0,0,7726,7727,3,1436,718,0,7727,7728,5,133,0,0,7728, - 7729,5,452,0,0,7729,7731,3,798,399,0,7730,7732,3,710,355,0,7731, - 7730,1,0,0,0,7731,7732,1,0,0,0,7732,7774,1,0,0,0,7733,7734,5,138, - 0,0,7734,7735,5,451,0,0,7735,7736,3,1436,718,0,7736,7737,5,191,0, - 0,7737,7738,5,452,0,0,7738,7740,3,798,399,0,7739,7741,3,710,355, - 0,7740,7739,1,0,0,0,7740,7741,1,0,0,0,7741,7774,1,0,0,0,7742,7743, - 5,138,0,0,7743,7744,5,451,0,0,7744,7745,3,1436,718,0,7745,7746,5, - 193,0,0,7746,7774,1,0,0,0,7747,7748,5,138,0,0,7748,7749,5,451,0, - 0,7749,7750,3,1436,718,0,7750,7751,5,186,0,0,7751,7774,1,0,0,0,7752, - 7753,5,138,0,0,7753,7754,5,451,0,0,7754,7755,3,1436,718,0,7755,7756, - 5,333,0,0,7756,7757,3,496,248,0,7757,7774,1,0,0,0,7758,7759,5,138, - 0,0,7759,7760,5,451,0,0,7760,7761,3,1436,718,0,7761,7762,5,465,0, - 0,7762,7763,5,2,0,0,7763,7764,3,508,254,0,7764,7765,5,3,0,0,7765, - 7774,1,0,0,0,7766,7767,5,138,0,0,7767,7768,5,451,0,0,7768,7769,3, - 1436,718,0,7769,7770,5,282,0,0,7770,7771,5,94,0,0,7771,7772,3,1470, - 735,0,7772,7774,1,0,0,0,7773,7695,1,0,0,0,7773,7701,1,0,0,0,7773, - 7707,1,0,0,0,7773,7715,1,0,0,0,7773,7724,1,0,0,0,7773,7733,1,0,0, - 0,7773,7742,1,0,0,0,7773,7747,1,0,0,0,7773,7752,1,0,0,0,7773,7758, - 1,0,0,0,7773,7766,1,0,0,0,7774,803,1,0,0,0,7775,7777,5,46,0,0,7776, - 7778,3,658,329,0,7777,7776,1,0,0,0,7777,7778,1,0,0,0,7778,7779,1, - 0,0,0,7779,7780,5,321,0,0,7780,7781,3,1436,718,0,7781,7782,5,36, - 0,0,7782,7783,5,80,0,0,7783,7784,3,814,407,0,7784,7785,5,94,0,0, - 7785,7787,3,1412,706,0,7786,7788,3,1144,572,0,7787,7786,1,0,0,0, - 7787,7788,1,0,0,0,7788,7789,1,0,0,0,7789,7791,5,57,0,0,7790,7792, - 3,816,408,0,7791,7790,1,0,0,0,7791,7792,1,0,0,0,7792,7793,1,0,0, - 0,7793,7794,3,806,403,0,7794,805,1,0,0,0,7795,7802,5,270,0,0,7796, - 7802,3,810,405,0,7797,7798,5,2,0,0,7798,7799,3,808,404,0,7799,7800, - 5,3,0,0,7800,7802,1,0,0,0,7801,7795,1,0,0,0,7801,7796,1,0,0,0,7801, - 7797,1,0,0,0,7802,807,1,0,0,0,7803,7805,3,812,406,0,7804,7803,1, - 0,0,0,7804,7805,1,0,0,0,7805,7812,1,0,0,0,7806,7808,5,7,0,0,7807, - 7809,3,812,406,0,7808,7807,1,0,0,0,7808,7809,1,0,0,0,7809,7811,1, - 0,0,0,7810,7806,1,0,0,0,7811,7814,1,0,0,0,7812,7810,1,0,0,0,7812, - 7813,1,0,0,0,7813,809,1,0,0,0,7814,7812,1,0,0,0,7815,7821,3,1000, - 500,0,7816,7821,3,950,475,0,7817,7821,3,982,491,0,7818,7821,3,968, - 484,0,7819,7821,3,818,409,0,7820,7815,1,0,0,0,7820,7816,1,0,0,0, - 7820,7817,1,0,0,0,7820,7818,1,0,0,0,7820,7819,1,0,0,0,7821,811,1, - 0,0,0,7822,7823,3,810,405,0,7823,813,1,0,0,0,7824,7825,7,47,0,0, - 7825,815,1,0,0,0,7826,7827,7,48,0,0,7827,817,1,0,0,0,7828,7829,5, - 271,0,0,7829,7831,3,1474,737,0,7830,7832,3,820,410,0,7831,7830,1, - 0,0,0,7831,7832,1,0,0,0,7832,819,1,0,0,0,7833,7834,5,6,0,0,7834, - 7835,3,1458,729,0,7835,821,1,0,0,0,7836,7837,5,252,0,0,7837,7838, - 3,1474,737,0,7838,823,1,0,0,0,7839,7840,5,366,0,0,7840,7844,3,1474, - 737,0,7841,7842,5,366,0,0,7842,7844,5,9,0,0,7843,7839,1,0,0,0,7843, - 7841,1,0,0,0,7844,825,1,0,0,0,7845,7847,5,129,0,0,7846,7848,3,828, - 414,0,7847,7846,1,0,0,0,7847,7848,1,0,0,0,7848,7850,1,0,0,0,7849, - 7851,3,836,418,0,7850,7849,1,0,0,0,7850,7851,1,0,0,0,7851,7911,1, - 0,0,0,7852,7854,5,146,0,0,7853,7855,3,828,414,0,7854,7853,1,0,0, - 0,7854,7855,1,0,0,0,7855,7857,1,0,0,0,7856,7858,3,834,417,0,7857, - 7856,1,0,0,0,7857,7858,1,0,0,0,7858,7911,1,0,0,0,7859,7860,5,340, - 0,0,7860,7862,5,356,0,0,7861,7863,3,834,417,0,7862,7861,1,0,0,0, - 7862,7863,1,0,0,0,7863,7911,1,0,0,0,7864,7866,5,454,0,0,7865,7867, - 3,828,414,0,7866,7865,1,0,0,0,7866,7867,1,0,0,0,7867,7869,1,0,0, - 0,7868,7870,3,836,418,0,7869,7868,1,0,0,0,7869,7870,1,0,0,0,7870, - 7911,1,0,0,0,7871,7872,5,322,0,0,7872,7911,3,1474,737,0,7873,7875, - 5,308,0,0,7874,7876,5,322,0,0,7875,7874,1,0,0,0,7875,7876,1,0,0, - 0,7876,7877,1,0,0,0,7877,7911,3,1474,737,0,7878,7879,5,290,0,0,7879, - 7880,5,356,0,0,7880,7911,3,1458,729,0,7881,7882,5,161,0,0,7882,7883, - 5,291,0,0,7883,7911,3,1458,729,0,7884,7886,5,161,0,0,7885,7887,3, - 828,414,0,7886,7885,1,0,0,0,7886,7887,1,0,0,0,7887,7889,1,0,0,0, - 7888,7890,3,836,418,0,7889,7888,1,0,0,0,7889,7890,1,0,0,0,7890,7911, - 1,0,0,0,7891,7892,5,319,0,0,7892,7893,5,291,0,0,7893,7911,3,1458, - 729,0,7894,7896,5,319,0,0,7895,7897,3,828,414,0,7896,7895,1,0,0, - 0,7896,7897,1,0,0,0,7897,7898,1,0,0,0,7898,7900,5,94,0,0,7899,7901, - 5,322,0,0,7900,7899,1,0,0,0,7900,7901,1,0,0,0,7901,7902,1,0,0,0, - 7902,7911,3,1474,737,0,7903,7905,5,319,0,0,7904,7906,3,828,414,0, - 7905,7904,1,0,0,0,7905,7906,1,0,0,0,7906,7908,1,0,0,0,7907,7909, - 3,836,418,0,7908,7907,1,0,0,0,7908,7909,1,0,0,0,7909,7911,1,0,0, - 0,7910,7845,1,0,0,0,7910,7852,1,0,0,0,7910,7859,1,0,0,0,7910,7864, - 1,0,0,0,7910,7871,1,0,0,0,7910,7873,1,0,0,0,7910,7878,1,0,0,0,7910, - 7881,1,0,0,0,7910,7884,1,0,0,0,7910,7891,1,0,0,0,7910,7894,1,0,0, - 0,7910,7903,1,0,0,0,7911,827,1,0,0,0,7912,7913,7,49,0,0,7913,829, - 1,0,0,0,7914,7915,5,244,0,0,7915,7916,5,251,0,0,7916,7925,3,68,34, - 0,7917,7918,5,300,0,0,7918,7925,5,81,0,0,7919,7920,5,300,0,0,7920, - 7925,5,382,0,0,7921,7925,5,54,0,0,7922,7923,5,77,0,0,7923,7925,5, - 54,0,0,7924,7914,1,0,0,0,7924,7917,1,0,0,0,7924,7919,1,0,0,0,7924, - 7921,1,0,0,0,7924,7922,1,0,0,0,7925,831,1,0,0,0,7926,7933,3,830, - 415,0,7927,7929,5,6,0,0,7928,7927,1,0,0,0,7928,7929,1,0,0,0,7929, - 7930,1,0,0,0,7930,7932,3,830,415,0,7931,7928,1,0,0,0,7932,7935,1, - 0,0,0,7933,7931,1,0,0,0,7933,7934,1,0,0,0,7934,833,1,0,0,0,7935, - 7933,1,0,0,0,7936,7937,3,832,416,0,7937,835,1,0,0,0,7938,7940,5, - 33,0,0,7939,7941,5,269,0,0,7940,7939,1,0,0,0,7940,7941,1,0,0,0,7941, - 7942,1,0,0,0,7942,7943,5,153,0,0,7943,837,1,0,0,0,7944,7947,5,46, - 0,0,7945,7946,5,82,0,0,7946,7948,5,311,0,0,7947,7945,1,0,0,0,7947, - 7948,1,0,0,0,7948,7950,1,0,0,0,7949,7951,3,190,95,0,7950,7949,1, - 0,0,0,7950,7951,1,0,0,0,7951,7969,1,0,0,0,7952,7953,5,376,0,0,7953, - 7955,3,1408,704,0,7954,7956,3,242,121,0,7955,7954,1,0,0,0,7955,7956, - 1,0,0,0,7956,7958,1,0,0,0,7957,7959,3,134,67,0,7958,7957,1,0,0,0, - 7958,7959,1,0,0,0,7959,7970,1,0,0,0,7960,7961,5,303,0,0,7961,7962, - 5,376,0,0,7962,7963,3,1408,704,0,7963,7964,5,2,0,0,7964,7965,3,244, - 122,0,7965,7967,5,3,0,0,7966,7968,3,134,67,0,7967,7966,1,0,0,0,7967, - 7968,1,0,0,0,7968,7970,1,0,0,0,7969,7952,1,0,0,0,7969,7960,1,0,0, - 0,7970,7971,1,0,0,0,7971,7972,5,36,0,0,7972,7974,3,1000,500,0,7973, - 7975,3,840,420,0,7974,7973,1,0,0,0,7974,7975,1,0,0,0,7975,839,1, - 0,0,0,7976,7978,5,105,0,0,7977,7979,7,50,0,0,7978,7977,1,0,0,0,7978, - 7979,1,0,0,0,7979,7980,1,0,0,0,7980,7981,5,42,0,0,7981,7982,5,279, - 0,0,7982,841,1,0,0,0,7983,7984,5,253,0,0,7984,7985,3,1440,720,0, - 7985,843,1,0,0,0,7986,7987,5,46,0,0,7987,7988,5,175,0,0,7988,7990, - 3,1418,709,0,7989,7991,3,14,7,0,7990,7989,1,0,0,0,7990,7991,1,0, - 0,0,7991,7993,1,0,0,0,7992,7994,3,846,423,0,7993,7992,1,0,0,0,7993, - 7994,1,0,0,0,7994,845,1,0,0,0,7995,7996,3,848,424,0,7996,847,1,0, - 0,0,7997,7999,3,850,425,0,7998,7997,1,0,0,0,7999,8000,1,0,0,0,8000, - 7998,1,0,0,0,8000,8001,1,0,0,0,8001,849,1,0,0,0,8002,8004,3,852, - 426,0,8003,8005,3,854,427,0,8004,8003,1,0,0,0,8004,8005,1,0,0,0, - 8005,8009,1,0,0,0,8006,8010,3,1464,732,0,8007,8010,3,72,36,0,8008, - 8010,5,53,0,0,8009,8006,1,0,0,0,8009,8007,1,0,0,0,8009,8008,1,0, - 0,0,8010,851,1,0,0,0,8011,8012,5,164,0,0,8012,8020,5,74,0,0,8013, - 8020,5,194,0,0,8014,8020,5,255,0,0,8015,8020,5,282,0,0,8016,8020, - 5,351,0,0,8017,8020,5,353,0,0,8018,8020,3,1492,746,0,8019,8011,1, - 0,0,0,8019,8013,1,0,0,0,8019,8014,1,0,0,0,8019,8015,1,0,0,0,8019, - 8016,1,0,0,0,8019,8017,1,0,0,0,8019,8018,1,0,0,0,8020,853,1,0,0, - 0,8021,8022,5,10,0,0,8022,855,1,0,0,0,8023,8024,5,138,0,0,8024,8025, - 5,175,0,0,8025,8037,3,1420,710,0,8026,8027,5,333,0,0,8027,8028,5, - 351,0,0,8028,8030,3,1400,700,0,8029,8026,1,0,0,0,8029,8030,1,0,0, - 0,8030,8038,1,0,0,0,8031,8033,5,105,0,0,8032,8031,1,0,0,0,8032,8033, - 1,0,0,0,8033,8034,1,0,0,0,8034,8036,3,846,423,0,8035,8032,1,0,0, - 0,8035,8036,1,0,0,0,8036,8038,1,0,0,0,8037,8029,1,0,0,0,8037,8035, - 1,0,0,0,8038,857,1,0,0,0,8039,8040,5,138,0,0,8040,8041,5,175,0,0, - 8041,8043,3,1420,710,0,8042,8044,3,88,44,0,8043,8042,1,0,0,0,8043, - 8044,1,0,0,0,8044,859,1,0,0,0,8045,8050,3,862,431,0,8046,8047,5, - 6,0,0,8047,8049,3,862,431,0,8048,8046,1,0,0,0,8049,8052,1,0,0,0, - 8050,8048,1,0,0,0,8050,8051,1,0,0,0,8051,861,1,0,0,0,8052,8050,1, - 0,0,0,8053,8054,5,209,0,0,8054,863,1,0,0,0,8055,8056,5,138,0,0,8056, - 8057,5,108,0,0,8057,8058,3,558,279,0,8058,8059,5,305,0,0,8059,8060, - 5,375,0,0,8060,865,1,0,0,0,8061,8062,5,138,0,0,8062,8063,5,349,0, - 0,8063,8064,7,22,0,0,8064,8065,3,58,29,0,8065,867,1,0,0,0,8066,8067, - 5,46,0,0,8067,8068,5,189,0,0,8068,8070,3,558,279,0,8069,8071,3,872, - 436,0,8070,8069,1,0,0,0,8070,8071,1,0,0,0,8071,8072,1,0,0,0,8072, - 8073,3,1168,584,0,8073,8074,3,214,107,0,8074,869,1,0,0,0,8075,8076, - 5,138,0,0,8076,8077,5,189,0,0,8077,8099,3,558,279,0,8078,8100,3, - 122,61,0,8079,8080,5,191,0,0,8080,8081,5,77,0,0,8081,8100,5,78,0, - 0,8082,8083,5,333,0,0,8083,8084,5,77,0,0,8084,8100,5,78,0,0,8085, - 8086,5,133,0,0,8086,8100,3,234,117,0,8087,8088,5,191,0,0,8088,8090, - 5,45,0,0,8089,8091,3,748,374,0,8090,8089,1,0,0,0,8090,8091,1,0,0, - 0,8091,8092,1,0,0,0,8092,8094,3,1436,718,0,8093,8095,3,124,62,0, - 8094,8093,1,0,0,0,8094,8095,1,0,0,0,8095,8100,1,0,0,0,8096,8097, - 5,372,0,0,8097,8098,5,45,0,0,8098,8100,3,1436,718,0,8099,8078,1, - 0,0,0,8099,8079,1,0,0,0,8099,8082,1,0,0,0,8099,8085,1,0,0,0,8099, - 8087,1,0,0,0,8099,8096,1,0,0,0,8100,871,1,0,0,0,8101,8102,5,36,0, - 0,8102,873,1,0,0,0,8103,8104,5,138,0,0,8104,8105,5,355,0,0,8105, - 8106,5,325,0,0,8106,8107,5,185,0,0,8107,8108,3,558,279,0,8108,8109, - 3,496,248,0,8109,875,1,0,0,0,8110,8111,5,138,0,0,8111,8112,5,355, - 0,0,8112,8113,5,325,0,0,8113,8114,5,163,0,0,8114,8115,3,558,279, - 0,8115,8116,5,133,0,0,8116,8117,5,257,0,0,8117,8118,5,62,0,0,8118, - 8119,3,1416,708,0,8119,8120,3,878,439,0,8120,8121,3,552,276,0,8121, - 8174,1,0,0,0,8122,8123,5,138,0,0,8123,8124,5,355,0,0,8124,8125,5, - 325,0,0,8125,8126,5,163,0,0,8126,8127,3,558,279,0,8127,8128,5,138, - 0,0,8128,8129,5,257,0,0,8129,8130,5,62,0,0,8130,8131,3,1416,708, - 0,8131,8132,3,878,439,0,8132,8133,3,552,276,0,8133,8174,1,0,0,0, - 8134,8135,5,138,0,0,8135,8136,5,355,0,0,8136,8137,5,325,0,0,8137, - 8138,5,163,0,0,8138,8139,3,558,279,0,8139,8140,5,138,0,0,8140,8141, - 5,257,0,0,8141,8142,5,311,0,0,8142,8143,3,558,279,0,8143,8144,3, - 878,439,0,8144,8145,3,558,279,0,8145,8174,1,0,0,0,8146,8147,5,138, - 0,0,8147,8148,5,355,0,0,8148,8149,5,325,0,0,8149,8150,5,163,0,0, - 8150,8151,3,558,279,0,8151,8152,5,138,0,0,8152,8153,5,257,0,0,8153, - 8154,5,62,0,0,8154,8155,3,1416,708,0,8155,8156,5,311,0,0,8156,8157, - 3,558,279,0,8157,8158,3,878,439,0,8158,8159,3,558,279,0,8159,8174, - 1,0,0,0,8160,8161,5,138,0,0,8161,8162,5,355,0,0,8162,8163,5,325, - 0,0,8163,8164,5,163,0,0,8164,8165,3,558,279,0,8165,8166,5,191,0, - 0,8166,8168,5,257,0,0,8167,8169,3,748,374,0,8168,8167,1,0,0,0,8168, - 8169,1,0,0,0,8169,8170,1,0,0,0,8170,8171,5,62,0,0,8171,8172,3,1416, - 708,0,8172,8174,1,0,0,0,8173,8110,1,0,0,0,8173,8122,1,0,0,0,8173, - 8134,1,0,0,0,8173,8146,1,0,0,0,8173,8160,1,0,0,0,8174,877,1,0,0, - 0,8175,8176,5,105,0,0,8176,879,1,0,0,0,8177,8179,5,46,0,0,8178,8180, - 3,524,262,0,8179,8178,1,0,0,0,8179,8180,1,0,0,0,8180,8181,1,0,0, - 0,8181,8182,5,168,0,0,8182,8183,3,558,279,0,8183,8184,5,62,0,0,8184, - 8185,3,1458,729,0,8185,8186,5,94,0,0,8186,8187,3,1458,729,0,8187, - 8188,5,64,0,0,8188,8189,3,558,279,0,8189,881,1,0,0,0,8190,8192,5, - 158,0,0,8191,8193,3,908,454,0,8192,8191,1,0,0,0,8192,8193,1,0,0, - 0,8193,8194,1,0,0,0,8194,8196,3,1406,703,0,8195,8197,3,886,443,0, - 8196,8195,1,0,0,0,8196,8197,1,0,0,0,8197,8209,1,0,0,0,8198,8200, - 5,158,0,0,8199,8201,3,908,454,0,8200,8199,1,0,0,0,8200,8201,1,0, - 0,0,8201,8209,1,0,0,0,8202,8203,5,158,0,0,8203,8204,3,884,442,0, - 8204,8206,3,1406,703,0,8205,8207,3,886,443,0,8206,8205,1,0,0,0,8206, - 8207,1,0,0,0,8207,8209,1,0,0,0,8208,8190,1,0,0,0,8208,8198,1,0,0, - 0,8208,8202,1,0,0,0,8209,883,1,0,0,0,8210,8211,5,2,0,0,8211,8216, - 3,908,454,0,8212,8213,5,6,0,0,8213,8215,3,908,454,0,8214,8212,1, - 0,0,0,8215,8218,1,0,0,0,8216,8214,1,0,0,0,8216,8217,1,0,0,0,8217, - 8219,1,0,0,0,8218,8216,1,0,0,0,8219,8220,5,3,0,0,8220,885,1,0,0, - 0,8221,8222,5,100,0,0,8222,8223,3,1436,718,0,8223,887,1,0,0,0,8224, - 8226,5,370,0,0,8225,8227,3,914,457,0,8226,8225,1,0,0,0,8226,8227, - 1,0,0,0,8227,8229,1,0,0,0,8228,8230,3,916,458,0,8229,8228,1,0,0, - 0,8229,8230,1,0,0,0,8230,8232,1,0,0,0,8231,8233,3,908,454,0,8232, - 8231,1,0,0,0,8232,8233,1,0,0,0,8233,8235,1,0,0,0,8234,8236,3,902, - 451,0,8235,8234,1,0,0,0,8235,8236,1,0,0,0,8236,8238,1,0,0,0,8237, - 8239,3,924,462,0,8238,8237,1,0,0,0,8238,8239,1,0,0,0,8239,8251,1, - 0,0,0,8240,8245,5,370,0,0,8241,8242,5,2,0,0,8242,8243,3,892,446, - 0,8243,8244,5,3,0,0,8244,8246,1,0,0,0,8245,8241,1,0,0,0,8245,8246, - 1,0,0,0,8246,8248,1,0,0,0,8247,8249,3,924,462,0,8248,8247,1,0,0, - 0,8248,8249,1,0,0,0,8249,8251,1,0,0,0,8250,8224,1,0,0,0,8250,8240, - 1,0,0,0,8251,889,1,0,0,0,8252,8254,3,894,447,0,8253,8255,3,908,454, - 0,8254,8253,1,0,0,0,8254,8255,1,0,0,0,8255,8257,1,0,0,0,8256,8258, - 3,924,462,0,8257,8256,1,0,0,0,8257,8258,1,0,0,0,8258,8267,1,0,0, - 0,8259,8260,3,894,447,0,8260,8261,5,2,0,0,8261,8262,3,904,452,0, - 8262,8264,5,3,0,0,8263,8265,3,924,462,0,8264,8263,1,0,0,0,8264,8265, - 1,0,0,0,8265,8267,1,0,0,0,8266,8252,1,0,0,0,8266,8259,1,0,0,0,8267, - 891,1,0,0,0,8268,8273,3,896,448,0,8269,8270,5,6,0,0,8270,8272,3, - 896,448,0,8271,8269,1,0,0,0,8272,8275,1,0,0,0,8273,8271,1,0,0,0, - 8273,8274,1,0,0,0,8274,893,1,0,0,0,8275,8273,1,0,0,0,8276,8277,7, - 51,0,0,8277,895,1,0,0,0,8278,8280,3,898,449,0,8279,8281,3,900,450, - 0,8280,8279,1,0,0,0,8280,8281,1,0,0,0,8281,897,1,0,0,0,8282,8285, - 3,1488,744,0,8283,8285,3,894,447,0,8284,8282,1,0,0,0,8284,8283,1, - 0,0,0,8285,899,1,0,0,0,8286,8289,3,72,36,0,8287,8289,3,322,161,0, - 8288,8286,1,0,0,0,8288,8287,1,0,0,0,8289,901,1,0,0,0,8290,8291,3, - 894,447,0,8291,903,1,0,0,0,8292,8297,3,906,453,0,8293,8294,5,6,0, - 0,8294,8296,3,906,453,0,8295,8293,1,0,0,0,8296,8299,1,0,0,0,8297, - 8295,1,0,0,0,8297,8298,1,0,0,0,8298,905,1,0,0,0,8299,8297,1,0,0, - 0,8300,8304,3,908,454,0,8301,8304,3,910,455,0,8302,8304,3,912,456, - 0,8303,8300,1,0,0,0,8303,8301,1,0,0,0,8303,8302,1,0,0,0,8304,907, - 1,0,0,0,8305,8307,5,128,0,0,8306,8308,7,52,0,0,8307,8306,1,0,0,0, - 8307,8308,1,0,0,0,8308,909,1,0,0,0,8309,8311,5,547,0,0,8310,8312, - 7,52,0,0,8311,8310,1,0,0,0,8311,8312,1,0,0,0,8312,911,1,0,0,0,8313, - 8316,5,548,0,0,8314,8317,3,322,161,0,8315,8317,3,1458,729,0,8316, - 8314,1,0,0,0,8316,8315,1,0,0,0,8317,913,1,0,0,0,8318,8319,5,113, - 0,0,8319,915,1,0,0,0,8320,8321,5,112,0,0,8321,917,1,0,0,0,8322,8323, - 5,2,0,0,8323,8324,3,244,122,0,8324,8325,5,3,0,0,8325,919,1,0,0,0, - 8326,8328,3,1406,703,0,8327,8329,3,918,459,0,8328,8327,1,0,0,0,8328, - 8329,1,0,0,0,8329,921,1,0,0,0,8330,8335,3,920,460,0,8331,8332,5, - 6,0,0,8332,8334,3,920,460,0,8333,8331,1,0,0,0,8334,8337,1,0,0,0, - 8335,8333,1,0,0,0,8335,8336,1,0,0,0,8336,923,1,0,0,0,8337,8335,1, - 0,0,0,8338,8339,3,922,461,0,8339,925,1,0,0,0,8340,8341,5,203,0,0, - 8341,8359,3,928,464,0,8342,8343,5,203,0,0,8343,8345,3,894,447,0, - 8344,8346,3,908,454,0,8345,8344,1,0,0,0,8345,8346,1,0,0,0,8346,8347, - 1,0,0,0,8347,8348,3,928,464,0,8348,8359,1,0,0,0,8349,8350,5,203, - 0,0,8350,8351,5,128,0,0,8351,8359,3,928,464,0,8352,8353,5,203,0, - 0,8353,8354,5,2,0,0,8354,8355,3,930,465,0,8355,8356,5,3,0,0,8356, - 8357,3,928,464,0,8357,8359,1,0,0,0,8358,8340,1,0,0,0,8358,8342,1, - 0,0,0,8358,8349,1,0,0,0,8358,8352,1,0,0,0,8359,927,1,0,0,0,8360, - 8370,3,1000,500,0,8361,8370,3,950,475,0,8362,8370,3,982,491,0,8363, - 8370,3,968,484,0,8364,8370,3,992,496,0,8365,8370,3,294,147,0,8366, - 8370,3,300,150,0,8367,8370,3,306,153,0,8368,8370,3,944,472,0,8369, - 8360,1,0,0,0,8369,8361,1,0,0,0,8369,8362,1,0,0,0,8369,8363,1,0,0, - 0,8369,8364,1,0,0,0,8369,8365,1,0,0,0,8369,8366,1,0,0,0,8369,8367, - 1,0,0,0,8369,8368,1,0,0,0,8370,929,1,0,0,0,8371,8376,3,932,466,0, - 8372,8373,5,6,0,0,8373,8375,3,932,466,0,8374,8372,1,0,0,0,8375,8378, - 1,0,0,0,8376,8374,1,0,0,0,8376,8377,1,0,0,0,8377,931,1,0,0,0,8378, - 8376,1,0,0,0,8379,8381,3,934,467,0,8380,8382,3,936,468,0,8381,8380, - 1,0,0,0,8381,8382,1,0,0,0,8382,933,1,0,0,0,8383,8386,3,1488,744, - 0,8384,8386,3,894,447,0,8385,8383,1,0,0,0,8385,8384,1,0,0,0,8386, - 935,1,0,0,0,8387,8390,3,72,36,0,8388,8390,3,322,161,0,8389,8387, - 1,0,0,0,8389,8388,1,0,0,0,8390,937,1,0,0,0,8391,8392,5,290,0,0,8392, - 8394,3,1436,718,0,8393,8395,3,940,470,0,8394,8393,1,0,0,0,8394,8395, - 1,0,0,0,8395,8396,1,0,0,0,8396,8397,5,36,0,0,8397,8398,3,942,471, - 0,8398,939,1,0,0,0,8399,8400,5,2,0,0,8400,8401,3,1342,671,0,8401, - 8402,5,3,0,0,8402,941,1,0,0,0,8403,8408,3,1000,500,0,8404,8408,3, - 950,475,0,8405,8408,3,982,491,0,8406,8408,3,968,484,0,8407,8403, - 1,0,0,0,8407,8404,1,0,0,0,8407,8405,1,0,0,0,8407,8406,1,0,0,0,8408, - 943,1,0,0,0,8409,8410,5,202,0,0,8410,8412,3,1436,718,0,8411,8413, - 3,946,473,0,8412,8411,1,0,0,0,8412,8413,1,0,0,0,8413,8433,1,0,0, - 0,8414,8416,5,46,0,0,8415,8417,3,190,95,0,8416,8415,1,0,0,0,8416, - 8417,1,0,0,0,8417,8418,1,0,0,0,8418,8420,5,92,0,0,8419,8421,3,516, - 258,0,8420,8419,1,0,0,0,8420,8421,1,0,0,0,8421,8422,1,0,0,0,8422, - 8423,3,296,148,0,8423,8424,5,36,0,0,8424,8425,5,202,0,0,8425,8427, - 3,1436,718,0,8426,8428,3,946,473,0,8427,8426,1,0,0,0,8427,8428,1, - 0,0,0,8428,8430,1,0,0,0,8429,8431,3,298,149,0,8430,8429,1,0,0,0, - 8430,8431,1,0,0,0,8431,8433,1,0,0,0,8432,8409,1,0,0,0,8432,8414, - 1,0,0,0,8433,945,1,0,0,0,8434,8435,5,2,0,0,8435,8436,3,1328,664, - 0,8436,8437,5,3,0,0,8437,947,1,0,0,0,8438,8440,5,177,0,0,8439,8441, - 5,290,0,0,8440,8439,1,0,0,0,8440,8441,1,0,0,0,8441,8444,1,0,0,0, - 8442,8445,3,1436,718,0,8443,8445,5,30,0,0,8444,8442,1,0,0,0,8444, - 8443,1,0,0,0,8445,949,1,0,0,0,8446,8448,3,1026,513,0,8447,8446,1, - 0,0,0,8447,8448,1,0,0,0,8448,8449,1,0,0,0,8449,8450,5,241,0,0,8450, - 8451,5,71,0,0,8451,8452,3,952,476,0,8452,8454,3,954,477,0,8453,8455, - 3,962,481,0,8454,8453,1,0,0,0,8454,8455,1,0,0,0,8455,8457,1,0,0, - 0,8456,8458,3,966,483,0,8457,8456,1,0,0,0,8457,8458,1,0,0,0,8458, - 951,1,0,0,0,8459,8462,3,1406,703,0,8460,8461,5,36,0,0,8461,8463, - 3,1474,737,0,8462,8460,1,0,0,0,8462,8463,1,0,0,0,8463,953,1,0,0, - 0,8464,8465,5,2,0,0,8465,8466,3,958,479,0,8466,8467,5,3,0,0,8467, - 8469,1,0,0,0,8468,8464,1,0,0,0,8468,8469,1,0,0,0,8469,8474,1,0,0, - 0,8470,8471,5,463,0,0,8471,8472,3,956,478,0,8472,8473,5,450,0,0, - 8473,8475,1,0,0,0,8474,8470,1,0,0,0,8474,8475,1,0,0,0,8475,8478, - 1,0,0,0,8476,8479,3,1694,847,0,8477,8479,3,1000,500,0,8478,8476, - 1,0,0,0,8478,8477,1,0,0,0,8479,955,1,0,0,0,8480,8481,7,53,0,0,8481, - 957,1,0,0,0,8482,8487,3,960,480,0,8483,8484,5,6,0,0,8484,8486,3, - 960,480,0,8485,8483,1,0,0,0,8486,8489,1,0,0,0,8487,8485,1,0,0,0, - 8487,8488,1,0,0,0,8488,959,1,0,0,0,8489,8487,1,0,0,0,8490,8491,3, - 1432,716,0,8491,8492,3,1382,691,0,8492,961,1,0,0,0,8493,8494,5,80, - 0,0,8494,8496,5,464,0,0,8495,8497,3,964,482,0,8496,8495,1,0,0,0, - 8496,8497,1,0,0,0,8497,8498,1,0,0,0,8498,8506,5,57,0,0,8499,8500, - 5,369,0,0,8500,8501,5,333,0,0,8501,8503,3,984,492,0,8502,8504,3, - 1144,572,0,8503,8502,1,0,0,0,8503,8504,1,0,0,0,8504,8507,1,0,0,0, - 8505,8507,5,270,0,0,8506,8499,1,0,0,0,8506,8505,1,0,0,0,8507,963, - 1,0,0,0,8508,8509,5,2,0,0,8509,8510,3,636,318,0,8510,8512,5,3,0, - 0,8511,8513,3,1144,572,0,8512,8511,1,0,0,0,8512,8513,1,0,0,0,8513, - 8518,1,0,0,0,8514,8515,5,80,0,0,8515,8516,5,45,0,0,8516,8518,3,1436, - 718,0,8517,8508,1,0,0,0,8517,8514,1,0,0,0,8518,965,1,0,0,0,8519, - 8520,5,87,0,0,8520,8521,3,1386,693,0,8521,967,1,0,0,0,8522,8524, - 3,1026,513,0,8523,8522,1,0,0,0,8523,8524,1,0,0,0,8524,8525,1,0,0, - 0,8525,8526,5,182,0,0,8526,8527,5,64,0,0,8527,8529,3,1128,564,0, - 8528,8530,3,970,485,0,8529,8528,1,0,0,0,8529,8530,1,0,0,0,8530,8532, - 1,0,0,0,8531,8533,3,1146,573,0,8532,8531,1,0,0,0,8532,8533,1,0,0, - 0,8533,8535,1,0,0,0,8534,8536,3,966,483,0,8535,8534,1,0,0,0,8535, - 8536,1,0,0,0,8536,969,1,0,0,0,8537,8538,5,100,0,0,8538,8539,3,1104, - 552,0,8539,971,1,0,0,0,8540,8542,5,256,0,0,8541,8543,3,1034,517, - 0,8542,8541,1,0,0,0,8542,8543,1,0,0,0,8543,8544,1,0,0,0,8544,8546, - 3,1124,562,0,8545,8547,3,974,487,0,8546,8545,1,0,0,0,8546,8547,1, - 0,0,0,8547,8549,1,0,0,0,8548,8550,3,978,489,0,8549,8548,1,0,0,0, - 8549,8550,1,0,0,0,8550,973,1,0,0,0,8551,8552,5,68,0,0,8552,8553, - 3,976,488,0,8553,8554,5,263,0,0,8554,975,1,0,0,0,8555,8556,5,131, - 0,0,8556,8568,7,54,0,0,8557,8558,5,414,0,0,8558,8568,7,54,0,0,8559, - 8564,5,334,0,0,8560,8561,5,369,0,0,8561,8565,5,201,0,0,8562,8563, - 5,414,0,0,8563,8565,5,201,0,0,8564,8560,1,0,0,0,8564,8562,1,0,0, - 0,8564,8565,1,0,0,0,8565,8568,1,0,0,0,8566,8568,5,201,0,0,8567,8555, - 1,0,0,0,8567,8557,1,0,0,0,8567,8559,1,0,0,0,8567,8566,1,0,0,0,8568, - 977,1,0,0,0,8569,8570,5,272,0,0,8570,979,1,0,0,0,8571,8575,5,272, - 0,0,8572,8573,5,465,0,0,8573,8575,5,466,0,0,8574,8571,1,0,0,0,8574, - 8572,1,0,0,0,8575,981,1,0,0,0,8576,8578,3,1026,513,0,8577,8576,1, - 0,0,0,8577,8578,1,0,0,0,8578,8579,1,0,0,0,8579,8580,5,369,0,0,8580, - 8581,3,1128,564,0,8581,8582,5,333,0,0,8582,8584,3,984,492,0,8583, - 8585,3,1102,551,0,8584,8583,1,0,0,0,8584,8585,1,0,0,0,8585,8587, - 1,0,0,0,8586,8588,3,1146,573,0,8587,8586,1,0,0,0,8587,8588,1,0,0, - 0,8588,8590,1,0,0,0,8589,8591,3,966,483,0,8590,8589,1,0,0,0,8590, - 8591,1,0,0,0,8591,983,1,0,0,0,8592,8597,3,986,493,0,8593,8594,5, - 6,0,0,8594,8596,3,986,493,0,8595,8593,1,0,0,0,8596,8599,1,0,0,0, - 8597,8595,1,0,0,0,8597,8598,1,0,0,0,8598,985,1,0,0,0,8599,8597,1, - 0,0,0,8600,8601,3,988,494,0,8601,8602,5,10,0,0,8602,8603,3,1212, - 606,0,8603,8619,1,0,0,0,8604,8605,5,2,0,0,8605,8606,3,990,495,0, - 8606,8607,5,3,0,0,8607,8616,5,10,0,0,8608,8610,5,414,0,0,8609,8608, - 1,0,0,0,8609,8610,1,0,0,0,8610,8611,1,0,0,0,8611,8617,3,1212,606, - 0,8612,8613,5,2,0,0,8613,8614,3,1006,503,0,8614,8615,5,3,0,0,8615, - 8617,1,0,0,0,8616,8609,1,0,0,0,8616,8612,1,0,0,0,8617,8619,1,0,0, - 0,8618,8600,1,0,0,0,8618,8604,1,0,0,0,8619,987,1,0,0,0,8620,8621, - 3,1432,716,0,8621,8622,3,1382,691,0,8622,989,1,0,0,0,8623,8628,3, - 988,494,0,8624,8625,5,6,0,0,8625,8627,3,988,494,0,8626,8624,1,0, - 0,0,8627,8630,1,0,0,0,8628,8626,1,0,0,0,8628,8629,1,0,0,0,8629,991, - 1,0,0,0,8630,8628,1,0,0,0,8631,8632,5,178,0,0,8632,8633,3,994,497, - 0,8633,8634,3,996,498,0,8634,8635,5,172,0,0,8635,8636,3,998,499, - 0,8636,8637,5,62,0,0,8637,8638,3,1000,500,0,8638,993,1,0,0,0,8639, - 8640,3,1436,718,0,8640,995,1,0,0,0,8641,8642,5,269,0,0,8642,8647, - 5,324,0,0,8643,8647,5,324,0,0,8644,8647,5,107,0,0,8645,8647,5,240, - 0,0,8646,8641,1,0,0,0,8646,8643,1,0,0,0,8646,8644,1,0,0,0,8646,8645, - 1,0,0,0,8647,8650,1,0,0,0,8648,8646,1,0,0,0,8648,8649,1,0,0,0,8649, - 997,1,0,0,0,8650,8648,1,0,0,0,8651,8657,1,0,0,0,8652,8653,5,105, - 0,0,8653,8657,5,217,0,0,8654,8655,5,379,0,0,8655,8657,5,217,0,0, - 8656,8651,1,0,0,0,8656,8652,1,0,0,0,8656,8654,1,0,0,0,8657,999,1, - 0,0,0,8658,8661,3,1004,502,0,8659,8661,3,1002,501,0,8660,8658,1, - 0,0,0,8660,8659,1,0,0,0,8661,1001,1,0,0,0,8662,8663,5,2,0,0,8663, - 8664,3,1004,502,0,8664,8665,5,3,0,0,8665,8671,1,0,0,0,8666,8667, - 5,2,0,0,8667,8668,3,1002,501,0,8668,8669,5,3,0,0,8669,8671,1,0,0, - 0,8670,8662,1,0,0,0,8670,8666,1,0,0,0,8671,1003,1,0,0,0,8672,8674, - 3,1006,503,0,8673,8675,3,1042,521,0,8674,8673,1,0,0,0,8674,8675, - 1,0,0,0,8675,8684,1,0,0,0,8676,8678,3,1088,544,0,8677,8679,3,1052, - 526,0,8678,8677,1,0,0,0,8678,8679,1,0,0,0,8679,8685,1,0,0,0,8680, - 8682,3,1050,525,0,8681,8683,3,1090,545,0,8682,8681,1,0,0,0,8682, - 8683,1,0,0,0,8683,8685,1,0,0,0,8684,8676,1,0,0,0,8684,8680,1,0,0, - 0,8684,8685,1,0,0,0,8685,8702,1,0,0,0,8686,8687,3,1014,507,0,8687, - 8689,3,1006,503,0,8688,8690,3,1042,521,0,8689,8688,1,0,0,0,8689, - 8690,1,0,0,0,8690,8699,1,0,0,0,8691,8693,3,1088,544,0,8692,8694, - 3,1052,526,0,8693,8692,1,0,0,0,8693,8694,1,0,0,0,8694,8700,1,0,0, - 0,8695,8697,3,1050,525,0,8696,8698,3,1090,545,0,8697,8696,1,0,0, - 0,8697,8698,1,0,0,0,8698,8700,1,0,0,0,8699,8691,1,0,0,0,8699,8695, - 1,0,0,0,8699,8700,1,0,0,0,8700,8702,1,0,0,0,8701,8672,1,0,0,0,8701, - 8686,1,0,0,0,8702,1005,1,0,0,0,8703,8706,3,1008,504,0,8704,8706, - 3,1002,501,0,8705,8703,1,0,0,0,8705,8704,1,0,0,0,8706,1007,1,0,0, - 0,8707,8723,5,88,0,0,8708,8710,3,1040,520,0,8709,8708,1,0,0,0,8709, - 8710,1,0,0,0,8710,8712,1,0,0,0,8711,8713,3,1028,514,0,8712,8711, - 1,0,0,0,8712,8713,1,0,0,0,8713,8715,1,0,0,0,8714,8716,3,1384,692, - 0,8715,8714,1,0,0,0,8715,8716,1,0,0,0,8716,8724,1,0,0,0,8717,8719, - 3,1038,519,0,8718,8717,1,0,0,0,8718,8719,1,0,0,0,8719,8721,1,0,0, - 0,8720,8722,3,1386,693,0,8721,8720,1,0,0,0,8721,8722,1,0,0,0,8722, - 8724,1,0,0,0,8723,8709,1,0,0,0,8723,8718,1,0,0,0,8724,8726,1,0,0, - 0,8725,8727,3,1028,514,0,8726,8725,1,0,0,0,8726,8727,1,0,0,0,8727, - 8729,1,0,0,0,8728,8730,3,1102,551,0,8729,8728,1,0,0,0,8729,8730, - 1,0,0,0,8730,8732,1,0,0,0,8731,8733,3,1144,572,0,8732,8731,1,0,0, - 0,8732,8733,1,0,0,0,8733,8735,1,0,0,0,8734,8736,3,1072,536,0,8735, - 8734,1,0,0,0,8735,8736,1,0,0,0,8736,8738,1,0,0,0,8737,8739,3,1086, - 543,0,8738,8737,1,0,0,0,8738,8739,1,0,0,0,8739,8741,1,0,0,0,8740, - 8742,3,1288,644,0,8741,8740,1,0,0,0,8741,8742,1,0,0,0,8742,8753, - 1,0,0,0,8743,8753,3,1100,550,0,8744,8745,5,92,0,0,8745,8753,3,1118, - 559,0,8746,8747,3,1002,501,0,8747,8750,3,1012,506,0,8748,8751,3, - 1008,504,0,8749,8751,3,1002,501,0,8750,8748,1,0,0,0,8750,8749,1, - 0,0,0,8751,8753,1,0,0,0,8752,8707,1,0,0,0,8752,8743,1,0,0,0,8752, - 8744,1,0,0,0,8752,8746,1,0,0,0,8753,8761,1,0,0,0,8754,8757,3,1012, - 506,0,8755,8758,3,1008,504,0,8756,8758,3,1002,501,0,8757,8755,1, - 0,0,0,8757,8756,1,0,0,0,8758,8760,1,0,0,0,8759,8754,1,0,0,0,8760, - 8763,1,0,0,0,8761,8759,1,0,0,0,8761,8762,1,0,0,0,8762,1009,1,0,0, - 0,8763,8761,1,0,0,0,8764,8768,5,97,0,0,8765,8768,5,70,0,0,8766,8768, - 5,59,0,0,8767,8764,1,0,0,0,8767,8765,1,0,0,0,8767,8766,1,0,0,0,8768, - 1011,1,0,0,0,8769,8771,3,1010,505,0,8770,8772,3,1036,518,0,8771, - 8770,1,0,0,0,8771,8772,1,0,0,0,8772,1013,1,0,0,0,8773,8775,5,105, - 0,0,8774,8776,5,303,0,0,8775,8774,1,0,0,0,8775,8776,1,0,0,0,8776, - 8777,1,0,0,0,8777,8778,3,1016,508,0,8778,1015,1,0,0,0,8779,8784, - 3,1018,509,0,8780,8781,5,6,0,0,8781,8783,3,1018,509,0,8782,8780, - 1,0,0,0,8783,8786,1,0,0,0,8784,8782,1,0,0,0,8784,8785,1,0,0,0,8785, - 1017,1,0,0,0,8786,8784,1,0,0,0,8787,8789,3,1436,718,0,8788,8790, - 3,918,459,0,8789,8788,1,0,0,0,8789,8790,1,0,0,0,8790,8791,1,0,0, - 0,8791,8793,5,36,0,0,8792,8794,3,1024,512,0,8793,8792,1,0,0,0,8793, - 8794,1,0,0,0,8794,8795,1,0,0,0,8795,8796,5,2,0,0,8796,8797,3,942, - 471,0,8797,8799,5,3,0,0,8798,8800,3,1020,510,0,8799,8798,1,0,0,0, - 8799,8800,1,0,0,0,8800,8802,1,0,0,0,8801,8803,3,1022,511,0,8802, - 8801,1,0,0,0,8802,8803,1,0,0,0,8803,1019,1,0,0,0,8804,8805,5,325, - 0,0,8805,8806,7,55,0,0,8806,8807,5,207,0,0,8807,8808,5,147,0,0,8808, - 8809,3,244,122,0,8809,8810,5,333,0,0,8810,8811,3,1432,716,0,8811, - 1021,1,0,0,0,8812,8813,5,173,0,0,8813,8814,3,244,122,0,8814,8815, - 5,333,0,0,8815,8821,3,1432,716,0,8816,8817,5,94,0,0,8817,8818,3, - 1436,718,0,8818,8819,5,53,0,0,8819,8820,3,1436,718,0,8820,8822,1, - 0,0,0,8821,8816,1,0,0,0,8821,8822,1,0,0,0,8822,8823,1,0,0,0,8823, - 8824,5,100,0,0,8824,8825,3,1432,716,0,8825,1023,1,0,0,0,8826,8830, - 5,259,0,0,8827,8828,5,77,0,0,8828,8830,5,259,0,0,8829,8826,1,0,0, - 0,8829,8827,1,0,0,0,8830,1025,1,0,0,0,8831,8832,3,1014,507,0,8832, - 1027,1,0,0,0,8833,8838,5,71,0,0,8834,8835,3,1030,515,0,8835,8836, - 3,1032,516,0,8836,8839,1,0,0,0,8837,8839,3,1674,837,0,8838,8834, - 1,0,0,0,8838,8837,1,0,0,0,8839,1029,1,0,0,0,8840,8843,1,0,0,0,8841, - 8843,5,346,0,0,8842,8840,1,0,0,0,8842,8841,1,0,0,0,8843,1031,1,0, - 0,0,8844,8846,7,56,0,0,8845,8844,1,0,0,0,8845,8846,1,0,0,0,8846, - 8847,1,0,0,0,8847,8849,7,25,0,0,8848,8850,3,1034,517,0,8849,8848, - 1,0,0,0,8849,8850,1,0,0,0,8850,8851,1,0,0,0,8851,8861,3,1404,702, - 0,8852,8854,5,367,0,0,8853,8855,3,1034,517,0,8854,8853,1,0,0,0,8854, - 8855,1,0,0,0,8855,8856,1,0,0,0,8856,8861,3,1404,702,0,8857,8858, - 5,92,0,0,8858,8861,3,1404,702,0,8859,8861,3,1404,702,0,8860,8845, - 1,0,0,0,8860,8852,1,0,0,0,8860,8857,1,0,0,0,8860,8859,1,0,0,0,8861, - 1033,1,0,0,0,8862,8863,5,92,0,0,8863,1035,1,0,0,0,8864,8865,7,57, - 0,0,8865,1037,1,0,0,0,8866,8872,5,56,0,0,8867,8868,5,80,0,0,8868, - 8869,5,2,0,0,8869,8870,3,1328,664,0,8870,8871,5,3,0,0,8871,8873, - 1,0,0,0,8872,8867,1,0,0,0,8872,8873,1,0,0,0,8873,1039,1,0,0,0,8874, - 8875,5,30,0,0,8875,1041,1,0,0,0,8876,8877,3,1044,522,0,8877,1043, - 1,0,0,0,8878,8879,5,83,0,0,8879,8880,5,147,0,0,8880,8881,3,1046, - 523,0,8881,1045,1,0,0,0,8882,8887,3,1048,524,0,8883,8884,5,6,0,0, - 8884,8886,3,1048,524,0,8885,8883,1,0,0,0,8886,8889,1,0,0,0,8887, - 8885,1,0,0,0,8887,8888,1,0,0,0,8888,1047,1,0,0,0,8889,8887,1,0,0, - 0,8890,8894,3,1336,668,0,8891,8892,5,100,0,0,8892,8895,3,1324,662, - 0,8893,8895,3,650,325,0,8894,8891,1,0,0,0,8894,8893,1,0,0,0,8894, - 8895,1,0,0,0,8895,8897,1,0,0,0,8896,8898,3,652,326,0,8897,8896,1, - 0,0,0,8897,8898,1,0,0,0,8898,1049,1,0,0,0,8899,8901,3,1054,527,0, - 8900,8902,3,1058,529,0,8901,8900,1,0,0,0,8901,8902,1,0,0,0,8902, - 8912,1,0,0,0,8903,8905,3,1058,529,0,8904,8906,3,1056,528,0,8905, - 8904,1,0,0,0,8905,8906,1,0,0,0,8906,8912,1,0,0,0,8907,8909,3,1056, - 528,0,8908,8910,3,1058,529,0,8909,8908,1,0,0,0,8909,8910,1,0,0,0, - 8910,8912,1,0,0,0,8911,8899,1,0,0,0,8911,8903,1,0,0,0,8911,8907, - 1,0,0,0,8912,1051,1,0,0,0,8913,8914,3,1050,525,0,8914,1053,1,0,0, - 0,8915,8916,5,74,0,0,8916,8919,3,1060,530,0,8917,8918,5,6,0,0,8918, - 8920,3,1062,531,0,8919,8917,1,0,0,0,8919,8920,1,0,0,0,8920,1055, - 1,0,0,0,8921,8922,5,61,0,0,8922,8936,3,1070,535,0,8923,8924,3,1064, - 532,0,8924,8928,3,1068,534,0,8925,8929,5,81,0,0,8926,8927,5,105, - 0,0,8927,8929,5,467,0,0,8928,8925,1,0,0,0,8928,8926,1,0,0,0,8929, - 8937,1,0,0,0,8930,8934,3,1068,534,0,8931,8935,5,81,0,0,8932,8933, - 5,105,0,0,8933,8935,5,467,0,0,8934,8931,1,0,0,0,8934,8932,1,0,0, - 0,8935,8937,1,0,0,0,8936,8923,1,0,0,0,8936,8930,1,0,0,0,8937,1057, - 1,0,0,0,8938,8943,5,79,0,0,8939,8940,3,1064,532,0,8940,8941,3,1068, - 534,0,8941,8944,1,0,0,0,8942,8944,3,1062,531,0,8943,8939,1,0,0,0, - 8943,8942,1,0,0,0,8944,1059,1,0,0,0,8945,8948,3,1212,606,0,8946, - 8948,5,30,0,0,8947,8945,1,0,0,0,8947,8946,1,0,0,0,8948,1061,1,0, - 0,0,8949,8950,3,1212,606,0,8950,1063,1,0,0,0,8951,8952,5,12,0,0, - 8952,8957,3,1066,533,0,8953,8954,5,13,0,0,8954,8957,3,1066,533,0, - 8955,8957,3,1254,627,0,8956,8951,1,0,0,0,8956,8953,1,0,0,0,8956, - 8955,1,0,0,0,8957,1065,1,0,0,0,8958,8961,3,1456,728,0,8959,8961, - 3,1454,727,0,8960,8958,1,0,0,0,8960,8959,1,0,0,0,8961,1067,1,0,0, - 0,8962,8963,7,58,0,0,8963,1069,1,0,0,0,8964,8965,7,59,0,0,8965,1071, - 1,0,0,0,8966,8967,5,66,0,0,8967,8969,5,147,0,0,8968,8970,3,1036, - 518,0,8969,8968,1,0,0,0,8969,8970,1,0,0,0,8970,8971,1,0,0,0,8971, - 8972,3,1074,537,0,8972,1073,1,0,0,0,8973,8978,3,1076,538,0,8974, - 8975,5,6,0,0,8975,8977,3,1076,538,0,8976,8974,1,0,0,0,8977,8980, - 1,0,0,0,8978,8976,1,0,0,0,8978,8979,1,0,0,0,8979,1075,1,0,0,0,8980, - 8978,1,0,0,0,8981,8991,3,1336,668,0,8982,8991,3,1078,539,0,8983, - 8991,3,1082,541,0,8984,8991,3,1080,540,0,8985,8991,3,1084,542,0, - 8986,8987,5,2,0,0,8987,8988,3,1330,665,0,8988,8989,5,3,0,0,8989, - 8991,1,0,0,0,8990,8981,1,0,0,0,8990,8982,1,0,0,0,8990,8983,1,0,0, - 0,8990,8984,1,0,0,0,8990,8985,1,0,0,0,8990,8986,1,0,0,0,8991,1077, - 1,0,0,0,8992,8993,5,2,0,0,8993,8994,5,3,0,0,8994,1079,1,0,0,0,8995, - 8996,5,468,0,0,8996,8997,5,2,0,0,8997,8998,3,1330,665,0,8998,8999, - 5,3,0,0,8999,1081,1,0,0,0,9000,9001,5,469,0,0,9001,9002,5,2,0,0, - 9002,9003,3,1330,665,0,9003,9004,5,3,0,0,9004,1083,1,0,0,0,9005, - 9006,5,470,0,0,9006,9007,5,471,0,0,9007,9008,5,2,0,0,9008,9009,3, - 1074,537,0,9009,9010,5,3,0,0,9010,1085,1,0,0,0,9011,9012,5,67,0, - 0,9012,9013,3,1212,606,0,9013,1087,1,0,0,0,9014,9019,3,1092,546, - 0,9015,9016,5,62,0,0,9016,9017,5,300,0,0,9017,9019,5,81,0,0,9018, - 9014,1,0,0,0,9018,9015,1,0,0,0,9019,1089,1,0,0,0,9020,9021,3,1088, - 544,0,9021,1091,1,0,0,0,9022,9024,3,1094,547,0,9023,9022,1,0,0,0, - 9024,9025,1,0,0,0,9025,9023,1,0,0,0,9025,9026,1,0,0,0,9026,1093, - 1,0,0,0,9027,9029,3,1096,548,0,9028,9030,3,1098,549,0,9029,9028, - 1,0,0,0,9029,9030,1,0,0,0,9030,9032,1,0,0,0,9031,9033,3,980,490, - 0,9032,9031,1,0,0,0,9032,9033,1,0,0,0,9033,1095,1,0,0,0,9034,9044, - 5,62,0,0,9035,9036,5,269,0,0,9036,9038,5,245,0,0,9037,9035,1,0,0, - 0,9037,9038,1,0,0,0,9038,9039,1,0,0,0,9039,9045,5,369,0,0,9040,9042, - 5,245,0,0,9041,9040,1,0,0,0,9041,9042,1,0,0,0,9042,9043,1,0,0,0, - 9043,9045,5,334,0,0,9044,9037,1,0,0,0,9044,9041,1,0,0,0,9045,1097, - 1,0,0,0,9046,9047,5,275,0,0,9047,9048,3,1390,695,0,9048,1099,1,0, - 0,0,9049,9050,5,422,0,0,9050,9051,5,2,0,0,9051,9052,3,1328,664,0, - 9052,9060,5,3,0,0,9053,9054,5,6,0,0,9054,9055,5,2,0,0,9055,9056, - 3,1328,664,0,9056,9057,5,3,0,0,9057,9059,1,0,0,0,9058,9053,1,0,0, - 0,9059,9062,1,0,0,0,9060,9058,1,0,0,0,9060,9061,1,0,0,0,9061,1101, - 1,0,0,0,9062,9060,1,0,0,0,9063,9064,5,64,0,0,9064,9065,3,1104,552, - 0,9065,1103,1,0,0,0,9066,9071,3,1106,553,0,9067,9068,5,6,0,0,9068, - 9070,3,1106,553,0,9069,9067,1,0,0,0,9070,9073,1,0,0,0,9071,9069, - 1,0,0,0,9071,9072,1,0,0,0,9072,1105,1,0,0,0,9073,9071,1,0,0,0,9074, - 9077,3,1118,559,0,9075,9077,3,1120,560,0,9076,9074,1,0,0,0,9076, - 9075,1,0,0,0,9077,9079,1,0,0,0,9078,9080,3,1110,555,0,9079,9078, - 1,0,0,0,9079,9080,1,0,0,0,9080,9082,1,0,0,0,9081,9083,3,1130,565, - 0,9082,9081,1,0,0,0,9082,9083,1,0,0,0,9083,9136,1,0,0,0,9084,9086, - 3,1134,567,0,9085,9087,3,1112,556,0,9086,9085,1,0,0,0,9086,9087, - 1,0,0,0,9087,9136,1,0,0,0,9088,9090,3,1154,577,0,9089,9091,3,1110, - 555,0,9090,9089,1,0,0,0,9090,9091,1,0,0,0,9091,9136,1,0,0,0,9092, - 9094,3,1002,501,0,9093,9095,3,1110,555,0,9094,9093,1,0,0,0,9094, - 9095,1,0,0,0,9095,9136,1,0,0,0,9096,9109,5,72,0,0,9097,9099,3,1154, - 577,0,9098,9100,3,1110,555,0,9099,9098,1,0,0,0,9099,9100,1,0,0,0, - 9100,9110,1,0,0,0,9101,9103,3,1134,567,0,9102,9104,3,1112,556,0, - 9103,9102,1,0,0,0,9103,9104,1,0,0,0,9104,9110,1,0,0,0,9105,9107, - 3,1002,501,0,9106,9108,3,1110,555,0,9107,9106,1,0,0,0,9107,9108, - 1,0,0,0,9108,9110,1,0,0,0,9109,9097,1,0,0,0,9109,9101,1,0,0,0,9109, - 9105,1,0,0,0,9110,9136,1,0,0,0,9111,9112,5,2,0,0,9112,9129,3,1106, - 553,0,9113,9114,5,110,0,0,9114,9115,5,118,0,0,9115,9130,3,1106,553, - 0,9116,9118,5,121,0,0,9117,9119,3,1114,557,0,9118,9117,1,0,0,0,9118, - 9119,1,0,0,0,9119,9120,1,0,0,0,9120,9121,5,118,0,0,9121,9130,3,1106, - 553,0,9122,9124,3,1114,557,0,9123,9122,1,0,0,0,9123,9124,1,0,0,0, - 9124,9125,1,0,0,0,9125,9126,5,118,0,0,9126,9127,3,1106,553,0,9127, - 9128,3,1116,558,0,9128,9130,1,0,0,0,9129,9113,1,0,0,0,9129,9116, - 1,0,0,0,9129,9123,1,0,0,0,9129,9130,1,0,0,0,9130,9131,1,0,0,0,9131, - 9133,5,3,0,0,9132,9134,3,1110,555,0,9133,9132,1,0,0,0,9133,9134, - 1,0,0,0,9134,9136,1,0,0,0,9135,9076,1,0,0,0,9135,9084,1,0,0,0,9135, - 9088,1,0,0,0,9135,9092,1,0,0,0,9135,9096,1,0,0,0,9135,9111,1,0,0, - 0,9136,9155,1,0,0,0,9137,9138,5,110,0,0,9138,9139,5,118,0,0,9139, - 9154,3,1106,553,0,9140,9142,5,121,0,0,9141,9143,3,1114,557,0,9142, - 9141,1,0,0,0,9142,9143,1,0,0,0,9143,9144,1,0,0,0,9144,9145,5,118, - 0,0,9145,9154,3,1106,553,0,9146,9148,3,1114,557,0,9147,9146,1,0, - 0,0,9147,9148,1,0,0,0,9148,9149,1,0,0,0,9149,9150,5,118,0,0,9150, - 9151,3,1106,553,0,9151,9152,3,1116,558,0,9152,9154,1,0,0,0,9153, - 9137,1,0,0,0,9153,9140,1,0,0,0,9153,9147,1,0,0,0,9154,9157,1,0,0, - 0,9155,9153,1,0,0,0,9155,9156,1,0,0,0,9156,1107,1,0,0,0,9157,9155, - 1,0,0,0,9158,9160,5,36,0,0,9159,9158,1,0,0,0,9159,9160,1,0,0,0,9160, - 9161,1,0,0,0,9161,9166,3,1474,737,0,9162,9163,5,2,0,0,9163,9164, - 3,1416,708,0,9164,9165,5,3,0,0,9165,9167,1,0,0,0,9166,9162,1,0,0, - 0,9166,9167,1,0,0,0,9167,1109,1,0,0,0,9168,9169,3,1108,554,0,9169, - 1111,1,0,0,0,9170,9183,3,1108,554,0,9171,9173,5,36,0,0,9172,9174, - 3,1474,737,0,9173,9172,1,0,0,0,9173,9174,1,0,0,0,9174,9177,1,0,0, - 0,9175,9177,3,1474,737,0,9176,9171,1,0,0,0,9176,9175,1,0,0,0,9177, - 9178,1,0,0,0,9178,9179,5,2,0,0,9179,9180,3,1150,575,0,9180,9181, - 5,3,0,0,9181,9183,1,0,0,0,9182,9170,1,0,0,0,9182,9176,1,0,0,0,9183, - 1113,1,0,0,0,9184,9186,7,60,0,0,9185,9187,5,123,0,0,9186,9185,1, - 0,0,0,9186,9187,1,0,0,0,9187,1115,1,0,0,0,9188,9189,5,100,0,0,9189, - 9190,5,2,0,0,9190,9191,3,244,122,0,9191,9192,5,3,0,0,9192,9196,1, - 0,0,0,9193,9194,5,80,0,0,9194,9196,3,1212,606,0,9195,9188,1,0,0, - 0,9195,9193,1,0,0,0,9196,1117,1,0,0,0,9197,9199,5,81,0,0,9198,9197, - 1,0,0,0,9198,9199,1,0,0,0,9199,9200,1,0,0,0,9200,9202,3,1406,703, - 0,9201,9203,5,9,0,0,9202,9201,1,0,0,0,9202,9203,1,0,0,0,9203,9219, - 1,0,0,0,9204,9210,5,81,0,0,9205,9211,3,1406,703,0,9206,9207,5,2, - 0,0,9207,9208,3,1406,703,0,9208,9209,5,3,0,0,9209,9211,1,0,0,0,9210, - 9205,1,0,0,0,9210,9206,1,0,0,0,9211,9219,1,0,0,0,9212,9213,5,68, - 0,0,9213,9216,5,323,0,0,9214,9217,3,1422,711,0,9215,9217,5,111,0, - 0,9216,9214,1,0,0,0,9216,9215,1,0,0,0,9217,9219,1,0,0,0,9218,9198, - 1,0,0,0,9218,9204,1,0,0,0,9218,9212,1,0,0,0,9219,1119,1,0,0,0,9220, - 9222,5,81,0,0,9221,9220,1,0,0,0,9221,9222,1,0,0,0,9222,9223,1,0, - 0,0,9223,9225,3,1410,705,0,9224,9226,5,9,0,0,9225,9224,1,0,0,0,9225, - 9226,1,0,0,0,9226,9228,1,0,0,0,9227,9229,3,244,122,0,9228,9227,1, - 0,0,0,9228,9229,1,0,0,0,9229,9231,1,0,0,0,9230,9232,3,1144,572,0, - 9231,9230,1,0,0,0,9231,9232,1,0,0,0,9232,1121,1,0,0,0,9233,9235, - 5,92,0,0,9234,9236,5,81,0,0,9235,9234,1,0,0,0,9235,9236,1,0,0,0, - 9236,9237,1,0,0,0,9237,9239,3,1406,703,0,9238,9240,5,9,0,0,9239, - 9238,1,0,0,0,9239,9240,1,0,0,0,9240,9245,1,0,0,0,9241,9242,5,2,0, - 0,9242,9243,3,244,122,0,9243,9244,5,3,0,0,9244,9246,1,0,0,0,9245, - 9241,1,0,0,0,9245,9246,1,0,0,0,9246,9248,1,0,0,0,9247,9249,3,1144, - 572,0,9248,9247,1,0,0,0,9248,9249,1,0,0,0,9249,9267,1,0,0,0,9250, - 9251,5,92,0,0,9251,9257,5,81,0,0,9252,9258,3,1406,703,0,9253,9254, - 5,2,0,0,9254,9255,3,1406,703,0,9255,9256,5,3,0,0,9256,9258,1,0,0, - 0,9257,9252,1,0,0,0,9257,9253,1,0,0,0,9258,9267,1,0,0,0,9259,9260, - 5,350,0,0,9260,9261,5,68,0,0,9261,9264,5,323,0,0,9262,9265,3,1422, - 711,0,9263,9265,5,111,0,0,9264,9262,1,0,0,0,9264,9263,1,0,0,0,9265, - 9267,1,0,0,0,9266,9233,1,0,0,0,9266,9250,1,0,0,0,9266,9259,1,0,0, - 0,9267,1123,1,0,0,0,9268,9273,3,1118,559,0,9269,9270,5,6,0,0,9270, - 9272,3,1118,559,0,9271,9269,1,0,0,0,9272,9275,1,0,0,0,9273,9271, - 1,0,0,0,9273,9274,1,0,0,0,9274,1125,1,0,0,0,9275,9273,1,0,0,0,9276, - 9281,3,1122,561,0,9277,9278,5,6,0,0,9278,9280,3,1122,561,0,9279, - 9277,1,0,0,0,9280,9283,1,0,0,0,9281,9279,1,0,0,0,9281,9282,1,0,0, - 0,9282,1127,1,0,0,0,9283,9281,1,0,0,0,9284,9289,3,1118,559,0,9285, - 9287,5,36,0,0,9286,9285,1,0,0,0,9286,9287,1,0,0,0,9287,9288,1,0, - 0,0,9288,9290,3,1474,737,0,9289,9286,1,0,0,0,9289,9290,1,0,0,0,9290, - 1129,1,0,0,0,9291,9292,5,472,0,0,9292,9293,3,1444,722,0,9293,9294, - 5,2,0,0,9294,9295,3,1328,664,0,9295,9297,5,3,0,0,9296,9298,3,1132, - 566,0,9297,9296,1,0,0,0,9297,9298,1,0,0,0,9298,1131,1,0,0,0,9299, - 9300,5,310,0,0,9300,9301,5,2,0,0,9301,9302,3,1212,606,0,9302,9303, - 5,3,0,0,9303,1133,1,0,0,0,9304,9306,3,1262,631,0,9305,9307,3,1142, - 571,0,9306,9305,1,0,0,0,9306,9307,1,0,0,0,9307,9317,1,0,0,0,9308, - 9309,5,320,0,0,9309,9310,5,64,0,0,9310,9311,5,2,0,0,9311,9312,3, - 1138,569,0,9312,9314,5,3,0,0,9313,9315,3,1142,571,0,9314,9313,1, - 0,0,0,9314,9315,1,0,0,0,9315,9317,1,0,0,0,9316,9304,1,0,0,0,9316, - 9308,1,0,0,0,9317,1135,1,0,0,0,9318,9320,3,1262,631,0,9319,9321, - 3,1140,570,0,9320,9319,1,0,0,0,9320,9321,1,0,0,0,9321,1137,1,0,0, - 0,9322,9327,3,1136,568,0,9323,9324,5,6,0,0,9324,9326,3,1136,568, - 0,9325,9323,1,0,0,0,9326,9329,1,0,0,0,9327,9325,1,0,0,0,9327,9328, - 1,0,0,0,9328,1139,1,0,0,0,9329,9327,1,0,0,0,9330,9331,5,36,0,0,9331, - 9332,5,2,0,0,9332,9333,3,1150,575,0,9333,9334,5,3,0,0,9334,1141, - 1,0,0,0,9335,9336,5,105,0,0,9336,9337,5,473,0,0,9337,1143,1,0,0, - 0,9338,9339,5,103,0,0,9339,9340,3,1336,668,0,9340,1145,1,0,0,0,9341, - 9346,5,103,0,0,9342,9343,5,434,0,0,9343,9344,5,275,0,0,9344,9347, - 3,994,497,0,9345,9347,3,1212,606,0,9346,9342,1,0,0,0,9346,9345,1, - 0,0,0,9347,1147,1,0,0,0,9348,9349,3,1150,575,0,9349,1149,1,0,0,0, - 9350,9355,3,1152,576,0,9351,9352,5,6,0,0,9352,9354,3,1152,576,0, - 9353,9351,1,0,0,0,9354,9357,1,0,0,0,9355,9353,1,0,0,0,9355,9356, - 1,0,0,0,9356,1151,1,0,0,0,9357,9355,1,0,0,0,9358,9359,3,1474,737, - 0,9359,9361,3,1168,584,0,9360,9362,3,126,63,0,9361,9360,1,0,0,0, - 9361,9362,1,0,0,0,9362,1153,1,0,0,0,9363,9364,5,474,0,0,9364,9380, - 5,2,0,0,9365,9366,3,1254,627,0,9366,9367,3,1280,640,0,9367,9368, - 5,475,0,0,9368,9369,3,1156,578,0,9369,9381,1,0,0,0,9370,9371,5,476, - 0,0,9371,9372,5,2,0,0,9372,9373,3,1164,582,0,9373,9374,5,3,0,0,9374, - 9375,5,6,0,0,9375,9376,3,1254,627,0,9376,9377,3,1280,640,0,9377, - 9378,5,475,0,0,9378,9379,3,1156,578,0,9379,9381,1,0,0,0,9380,9365, - 1,0,0,0,9380,9370,1,0,0,0,9381,9382,1,0,0,0,9382,9383,5,3,0,0,9383, - 1155,1,0,0,0,9384,9389,3,1158,579,0,9385,9386,5,6,0,0,9386,9388, - 3,1158,579,0,9387,9385,1,0,0,0,9388,9391,1,0,0,0,9389,9387,1,0,0, - 0,9389,9390,1,0,0,0,9390,1157,1,0,0,0,9391,9389,1,0,0,0,9392,9399, - 3,1474,737,0,9393,9395,3,1168,584,0,9394,9396,3,1160,580,0,9395, - 9394,1,0,0,0,9395,9396,1,0,0,0,9396,9400,1,0,0,0,9397,9398,5,62, - 0,0,9398,9400,5,473,0,0,9399,9393,1,0,0,0,9399,9397,1,0,0,0,9400, - 1159,1,0,0,0,9401,9403,3,1162,581,0,9402,9401,1,0,0,0,9403,9404, - 1,0,0,0,9404,9402,1,0,0,0,9404,9405,1,0,0,0,9405,1161,1,0,0,0,9406, - 9407,5,53,0,0,9407,9415,3,1212,606,0,9408,9409,3,1492,746,0,9409, - 9410,3,1212,606,0,9410,9415,1,0,0,0,9411,9412,5,77,0,0,9412,9415, - 5,78,0,0,9413,9415,5,78,0,0,9414,9406,1,0,0,0,9414,9408,1,0,0,0, - 9414,9411,1,0,0,0,9414,9413,1,0,0,0,9415,1163,1,0,0,0,9416,9421, - 3,1166,583,0,9417,9418,5,6,0,0,9418,9420,3,1166,583,0,9419,9417, - 1,0,0,0,9420,9423,1,0,0,0,9421,9419,1,0,0,0,9421,9422,1,0,0,0,9422, - 1165,1,0,0,0,9423,9421,1,0,0,0,9424,9425,3,1252,626,0,9425,9426, - 5,36,0,0,9426,9427,3,1490,745,0,9427,9431,1,0,0,0,9428,9429,5,53, - 0,0,9429,9431,3,1252,626,0,9430,9424,1,0,0,0,9430,9428,1,0,0,0,9431, - 1167,1,0,0,0,9432,9434,5,415,0,0,9433,9432,1,0,0,0,9433,9434,1,0, - 0,0,9434,9435,1,0,0,0,9435,9444,3,1172,586,0,9436,9445,3,1170,585, - 0,9437,9442,5,35,0,0,9438,9439,5,4,0,0,9439,9440,3,1456,728,0,9440, - 9441,5,5,0,0,9441,9443,1,0,0,0,9442,9438,1,0,0,0,9442,9443,1,0,0, - 0,9443,9445,1,0,0,0,9444,9436,1,0,0,0,9444,9437,1,0,0,0,9445,9451, - 1,0,0,0,9446,9447,3,1412,706,0,9447,9448,5,27,0,0,9448,9449,7,61, - 0,0,9449,9451,1,0,0,0,9450,9433,1,0,0,0,9450,9446,1,0,0,0,9451,1169, - 1,0,0,0,9452,9454,5,4,0,0,9453,9455,3,1456,728,0,9454,9453,1,0,0, - 0,9454,9455,1,0,0,0,9455,9456,1,0,0,0,9456,9458,5,5,0,0,9457,9452, - 1,0,0,0,9458,9461,1,0,0,0,9459,9457,1,0,0,0,9459,9460,1,0,0,0,9460, - 1171,1,0,0,0,9461,9459,1,0,0,0,9462,9478,3,1176,588,0,9463,9478, - 3,1180,590,0,9464,9478,3,1184,592,0,9465,9478,3,1192,596,0,9466, - 9478,3,1200,600,0,9467,9475,3,1202,601,0,9468,9470,3,1206,603,0, - 9469,9468,1,0,0,0,9469,9470,1,0,0,0,9470,9476,1,0,0,0,9471,9472, - 5,2,0,0,9472,9473,3,1456,728,0,9473,9474,5,3,0,0,9474,9476,1,0,0, - 0,9475,9469,1,0,0,0,9475,9471,1,0,0,0,9476,9478,1,0,0,0,9477,9462, - 1,0,0,0,9477,9463,1,0,0,0,9477,9464,1,0,0,0,9477,9465,1,0,0,0,9477, - 9466,1,0,0,0,9477,9467,1,0,0,0,9478,1173,1,0,0,0,9479,9484,3,1180, - 590,0,9480,9484,3,1186,593,0,9481,9484,3,1194,597,0,9482,9484,3, - 1200,600,0,9483,9479,1,0,0,0,9483,9480,1,0,0,0,9483,9481,1,0,0,0, - 9483,9482,1,0,0,0,9484,1175,1,0,0,0,9485,9487,3,1482,741,0,9486, - 9488,3,560,280,0,9487,9486,1,0,0,0,9487,9488,1,0,0,0,9488,9490,1, - 0,0,0,9489,9491,3,1178,589,0,9490,9489,1,0,0,0,9490,9491,1,0,0,0, - 9491,1177,1,0,0,0,9492,9493,5,2,0,0,9493,9494,3,1328,664,0,9494, - 9495,5,3,0,0,9495,1179,1,0,0,0,9496,9521,5,401,0,0,9497,9521,5,402, - 0,0,9498,9521,5,416,0,0,9499,9521,5,388,0,0,9500,9521,5,413,0,0, - 9501,9503,5,398,0,0,9502,9504,3,1182,591,0,9503,9502,1,0,0,0,9503, - 9504,1,0,0,0,9504,9521,1,0,0,0,9505,9506,5,190,0,0,9506,9521,5,412, - 0,0,9507,9509,5,395,0,0,9508,9510,3,1178,589,0,9509,9508,1,0,0,0, - 9509,9510,1,0,0,0,9510,9521,1,0,0,0,9511,9513,5,394,0,0,9512,9514, - 3,1178,589,0,9513,9512,1,0,0,0,9513,9514,1,0,0,0,9514,9521,1,0,0, - 0,9515,9517,5,409,0,0,9516,9518,3,1178,589,0,9517,9516,1,0,0,0,9517, - 9518,1,0,0,0,9518,9521,1,0,0,0,9519,9521,5,390,0,0,9520,9496,1,0, - 0,0,9520,9497,1,0,0,0,9520,9498,1,0,0,0,9520,9499,1,0,0,0,9520,9500, - 1,0,0,0,9520,9501,1,0,0,0,9520,9505,1,0,0,0,9520,9507,1,0,0,0,9520, - 9511,1,0,0,0,9520,9515,1,0,0,0,9520,9519,1,0,0,0,9521,1181,1,0,0, - 0,9522,9523,5,2,0,0,9523,9524,3,1456,728,0,9524,9525,5,3,0,0,9525, - 1183,1,0,0,0,9526,9529,3,1188,594,0,9527,9529,3,1190,595,0,9528, - 9526,1,0,0,0,9528,9527,1,0,0,0,9529,1185,1,0,0,0,9530,9533,3,1188, - 594,0,9531,9533,3,1190,595,0,9532,9530,1,0,0,0,9532,9531,1,0,0,0, - 9533,1187,1,0,0,0,9534,9536,5,389,0,0,9535,9537,3,1198,599,0,9536, - 9535,1,0,0,0,9536,9537,1,0,0,0,9537,9538,1,0,0,0,9538,9539,5,2,0, - 0,9539,9540,3,1328,664,0,9540,9541,5,3,0,0,9541,1189,1,0,0,0,9542, - 9544,5,389,0,0,9543,9545,3,1198,599,0,9544,9543,1,0,0,0,9544,9545, - 1,0,0,0,9545,1191,1,0,0,0,9546,9551,3,1196,598,0,9547,9548,5,2,0, - 0,9548,9549,3,1456,728,0,9549,9550,5,3,0,0,9550,9552,1,0,0,0,9551, - 9547,1,0,0,0,9551,9552,1,0,0,0,9552,1193,1,0,0,0,9553,9558,3,1196, - 598,0,9554,9555,5,2,0,0,9555,9556,3,1456,728,0,9556,9557,5,3,0,0, - 9557,9559,1,0,0,0,9558,9554,1,0,0,0,9558,9559,1,0,0,0,9559,1195, - 1,0,0,0,9560,9562,7,62,0,0,9561,9563,3,1198,599,0,9562,9561,1,0, - 0,0,9562,9563,1,0,0,0,9563,9571,1,0,0,0,9564,9571,5,423,0,0,9565, - 9566,5,405,0,0,9566,9568,7,63,0,0,9567,9569,3,1198,599,0,9568,9567, - 1,0,0,0,9568,9569,1,0,0,0,9569,9571,1,0,0,0,9570,9560,1,0,0,0,9570, - 9564,1,0,0,0,9570,9565,1,0,0,0,9571,1197,1,0,0,0,9572,9573,5,374, - 0,0,9573,1199,1,0,0,0,9574,9579,7,64,0,0,9575,9576,5,2,0,0,9576, - 9577,3,1456,728,0,9577,9578,5,3,0,0,9578,9580,1,0,0,0,9579,9575, - 1,0,0,0,9579,9580,1,0,0,0,9580,9582,1,0,0,0,9581,9583,3,1204,602, - 0,9582,9581,1,0,0,0,9582,9583,1,0,0,0,9583,1201,1,0,0,0,9584,9585, - 5,403,0,0,9585,1203,1,0,0,0,9586,9587,5,105,0,0,9587,9588,5,418, - 0,0,9588,9593,5,386,0,0,9589,9590,5,379,0,0,9590,9591,5,418,0,0, - 9591,9593,5,386,0,0,9592,9586,1,0,0,0,9592,9589,1,0,0,0,9593,1205, - 1,0,0,0,9594,9620,5,384,0,0,9595,9620,5,264,0,0,9596,9620,5,176, - 0,0,9597,9620,5,218,0,0,9598,9620,5,261,0,0,9599,9620,3,1208,604, - 0,9600,9601,5,384,0,0,9601,9602,5,94,0,0,9602,9620,5,264,0,0,9603, - 9604,5,176,0,0,9604,9608,5,94,0,0,9605,9609,5,218,0,0,9606,9609, - 5,261,0,0,9607,9609,3,1208,604,0,9608,9605,1,0,0,0,9608,9606,1,0, - 0,0,9608,9607,1,0,0,0,9609,9620,1,0,0,0,9610,9611,5,218,0,0,9611, - 9614,5,94,0,0,9612,9615,5,261,0,0,9613,9615,3,1208,604,0,9614,9612, - 1,0,0,0,9614,9613,1,0,0,0,9615,9620,1,0,0,0,9616,9617,5,261,0,0, - 9617,9618,5,94,0,0,9618,9620,3,1208,604,0,9619,9594,1,0,0,0,9619, - 9595,1,0,0,0,9619,9596,1,0,0,0,9619,9597,1,0,0,0,9619,9598,1,0,0, - 0,9619,9599,1,0,0,0,9619,9600,1,0,0,0,9619,9603,1,0,0,0,9619,9610, - 1,0,0,0,9619,9616,1,0,0,0,9620,1207,1,0,0,0,9621,9626,5,326,0,0, - 9622,9623,5,2,0,0,9623,9624,3,1456,728,0,9624,9625,5,3,0,0,9625, - 9627,1,0,0,0,9626,9622,1,0,0,0,9626,9627,1,0,0,0,9627,1209,1,0,0, - 0,9628,9629,5,197,0,0,9629,9630,3,1212,606,0,9630,1211,1,0,0,0,9631, - 9632,3,1214,607,0,9632,1213,1,0,0,0,9633,9635,3,1216,608,0,9634, - 9636,3,1322,661,0,9635,9634,1,0,0,0,9635,9636,1,0,0,0,9636,1215, - 1,0,0,0,9637,9642,3,1218,609,0,9638,9639,7,65,0,0,9639,9641,3,1218, - 609,0,9640,9638,1,0,0,0,9641,9644,1,0,0,0,9642,9640,1,0,0,0,9642, - 9643,1,0,0,0,9643,1217,1,0,0,0,9644,9642,1,0,0,0,9645,9650,3,1220, - 610,0,9646,9647,5,82,0,0,9647,9649,3,1220,610,0,9648,9646,1,0,0, - 0,9649,9652,1,0,0,0,9650,9648,1,0,0,0,9650,9651,1,0,0,0,9651,1219, - 1,0,0,0,9652,9650,1,0,0,0,9653,9658,3,1222,611,0,9654,9655,5,33, - 0,0,9655,9657,3,1222,611,0,9656,9654,1,0,0,0,9657,9660,1,0,0,0,9658, - 9656,1,0,0,0,9658,9659,1,0,0,0,9659,1221,1,0,0,0,9660,9658,1,0,0, - 0,9661,9667,3,1224,612,0,9662,9664,5,77,0,0,9663,9662,1,0,0,0,9663, - 9664,1,0,0,0,9664,9665,1,0,0,0,9665,9666,5,68,0,0,9666,9668,3,1362, - 681,0,9667,9663,1,0,0,0,9667,9668,1,0,0,0,9668,1223,1,0,0,0,9669, - 9671,5,77,0,0,9670,9669,1,0,0,0,9670,9671,1,0,0,0,9671,9672,1,0, - 0,0,9672,9673,3,1226,613,0,9673,1225,1,0,0,0,9674,9676,3,1228,614, - 0,9675,9677,7,66,0,0,9676,9675,1,0,0,0,9676,9677,1,0,0,0,9677,1227, - 1,0,0,0,9678,9702,3,1230,615,0,9679,9681,5,116,0,0,9680,9682,5,77, - 0,0,9681,9680,1,0,0,0,9681,9682,1,0,0,0,9682,9700,1,0,0,0,9683,9701, - 5,78,0,0,9684,9701,5,96,0,0,9685,9701,5,60,0,0,9686,9701,5,365,0, - 0,9687,9688,5,56,0,0,9688,9689,5,64,0,0,9689,9701,3,1212,606,0,9690, - 9691,5,275,0,0,9691,9692,5,2,0,0,9692,9693,3,1342,671,0,9693,9694, - 5,3,0,0,9694,9701,1,0,0,0,9695,9701,5,188,0,0,9696,9698,3,1352,676, - 0,9697,9696,1,0,0,0,9697,9698,1,0,0,0,9698,9699,1,0,0,0,9699,9701, - 5,478,0,0,9700,9683,1,0,0,0,9700,9684,1,0,0,0,9700,9685,1,0,0,0, - 9700,9686,1,0,0,0,9700,9687,1,0,0,0,9700,9690,1,0,0,0,9700,9695, - 1,0,0,0,9700,9697,1,0,0,0,9701,9703,1,0,0,0,9702,9679,1,0,0,0,9702, - 9703,1,0,0,0,9703,1229,1,0,0,0,9704,9716,3,1232,616,0,9705,9706, - 7,67,0,0,9706,9717,3,1232,616,0,9707,9708,3,1326,663,0,9708,9714, - 3,1316,658,0,9709,9715,3,1002,501,0,9710,9711,5,2,0,0,9711,9712, - 3,1212,606,0,9712,9713,5,3,0,0,9713,9715,1,0,0,0,9714,9709,1,0,0, - 0,9714,9710,1,0,0,0,9715,9717,1,0,0,0,9716,9705,1,0,0,0,9716,9707, - 1,0,0,0,9716,9717,1,0,0,0,9717,1231,1,0,0,0,9718,9736,3,1234,617, - 0,9719,9721,5,77,0,0,9720,9719,1,0,0,0,9720,9721,1,0,0,0,9721,9730, - 1,0,0,0,9722,9731,5,120,0,0,9723,9731,5,114,0,0,9724,9725,5,127, - 0,0,9725,9731,5,94,0,0,9726,9728,5,387,0,0,9727,9729,5,91,0,0,9728, - 9727,1,0,0,0,9728,9729,1,0,0,0,9729,9731,1,0,0,0,9730,9722,1,0,0, - 0,9730,9723,1,0,0,0,9730,9724,1,0,0,0,9730,9726,1,0,0,0,9731,9732, - 1,0,0,0,9732,9734,3,1234,617,0,9733,9735,3,1210,605,0,9734,9733, - 1,0,0,0,9734,9735,1,0,0,0,9735,9737,1,0,0,0,9736,9720,1,0,0,0,9736, - 9737,1,0,0,0,9737,1233,1,0,0,0,9738,9744,3,1236,618,0,9739,9740, - 3,1322,661,0,9740,9741,3,1236,618,0,9741,9743,1,0,0,0,9742,9739, - 1,0,0,0,9743,9746,1,0,0,0,9744,9742,1,0,0,0,9744,9745,1,0,0,0,9745, - 1235,1,0,0,0,9746,9744,1,0,0,0,9747,9749,3,1322,661,0,9748,9747, - 1,0,0,0,9748,9749,1,0,0,0,9749,9750,1,0,0,0,9750,9751,3,1238,619, - 0,9751,1237,1,0,0,0,9752,9757,3,1240,620,0,9753,9754,7,68,0,0,9754, - 9756,3,1240,620,0,9755,9753,1,0,0,0,9756,9759,1,0,0,0,9757,9755, - 1,0,0,0,9757,9758,1,0,0,0,9758,1239,1,0,0,0,9759,9757,1,0,0,0,9760, - 9765,3,1242,621,0,9761,9762,7,69,0,0,9762,9764,3,1242,621,0,9763, - 9761,1,0,0,0,9764,9767,1,0,0,0,9765,9763,1,0,0,0,9765,9766,1,0,0, - 0,9766,1241,1,0,0,0,9767,9765,1,0,0,0,9768,9771,3,1244,622,0,9769, - 9770,5,15,0,0,9770,9772,3,1212,606,0,9771,9769,1,0,0,0,9771,9772, - 1,0,0,0,9772,1243,1,0,0,0,9773,9775,7,68,0,0,9774,9773,1,0,0,0,9774, - 9775,1,0,0,0,9775,9776,1,0,0,0,9776,9777,3,1246,623,0,9777,1245, - 1,0,0,0,9778,9783,3,1248,624,0,9779,9780,5,142,0,0,9780,9781,5,418, - 0,0,9781,9782,5,386,0,0,9782,9784,3,1212,606,0,9783,9779,1,0,0,0, - 9783,9784,1,0,0,0,9784,1247,1,0,0,0,9785,9788,3,1250,625,0,9786, - 9787,5,43,0,0,9787,9789,3,558,279,0,9788,9786,1,0,0,0,9788,9789, - 1,0,0,0,9789,1249,1,0,0,0,9790,9795,3,1254,627,0,9791,9792,5,26, - 0,0,9792,9794,3,1168,584,0,9793,9791,1,0,0,0,9794,9797,1,0,0,0,9795, - 9793,1,0,0,0,9795,9796,1,0,0,0,9796,1251,1,0,0,0,9797,9795,1,0,0, - 0,9798,9799,6,626,-1,0,9799,9806,3,1254,627,0,9800,9801,7,68,0,0, - 9801,9806,3,1252,626,9,9802,9803,3,1322,661,0,9803,9804,3,1252,626, - 3,9804,9806,1,0,0,0,9805,9798,1,0,0,0,9805,9800,1,0,0,0,9805,9802, - 1,0,0,0,9806,9846,1,0,0,0,9807,9808,10,8,0,0,9808,9809,5,15,0,0, - 9809,9845,3,1252,626,9,9810,9811,10,7,0,0,9811,9812,7,69,0,0,9812, - 9845,3,1252,626,8,9813,9814,10,6,0,0,9814,9815,7,68,0,0,9815,9845, - 3,1252,626,7,9816,9817,10,5,0,0,9817,9818,3,1322,661,0,9818,9819, - 3,1252,626,6,9819,9845,1,0,0,0,9820,9821,10,4,0,0,9821,9822,7,67, - 0,0,9822,9845,3,1252,626,5,9823,9824,10,10,0,0,9824,9825,5,26,0, - 0,9825,9845,3,1168,584,0,9826,9827,10,2,0,0,9827,9845,3,1322,661, - 0,9828,9829,10,1,0,0,9829,9831,5,116,0,0,9830,9832,5,77,0,0,9831, - 9830,1,0,0,0,9831,9832,1,0,0,0,9832,9842,1,0,0,0,9833,9834,5,56, - 0,0,9834,9835,5,64,0,0,9835,9843,3,1252,626,0,9836,9837,5,275,0, - 0,9837,9838,5,2,0,0,9838,9839,3,1342,671,0,9839,9840,5,3,0,0,9840, - 9843,1,0,0,0,9841,9843,5,188,0,0,9842,9833,1,0,0,0,9842,9836,1,0, - 0,0,9842,9841,1,0,0,0,9843,9845,1,0,0,0,9844,9807,1,0,0,0,9844,9810, - 1,0,0,0,9844,9813,1,0,0,0,9844,9816,1,0,0,0,9844,9820,1,0,0,0,9844, - 9823,1,0,0,0,9844,9826,1,0,0,0,9844,9828,1,0,0,0,9845,9848,1,0,0, - 0,9846,9844,1,0,0,0,9846,9847,1,0,0,0,9847,1253,1,0,0,0,9848,9846, - 1,0,0,0,9849,9850,5,396,0,0,9850,9886,3,1002,501,0,9851,9854,5,35, - 0,0,9852,9855,3,1002,501,0,9853,9855,3,1344,672,0,9854,9852,1,0, - 0,0,9854,9853,1,0,0,0,9855,9886,1,0,0,0,9856,9857,5,28,0,0,9857, - 9886,3,1382,691,0,9858,9859,5,470,0,0,9859,9860,5,2,0,0,9860,9861, - 3,1328,664,0,9861,9862,5,3,0,0,9862,9886,1,0,0,0,9863,9864,5,98, - 0,0,9864,9886,3,1002,501,0,9865,9886,3,1448,724,0,9866,9886,3,1256, - 628,0,9867,9868,5,2,0,0,9868,9869,3,1212,606,0,9869,9870,5,3,0,0, - 9870,9871,3,1382,691,0,9871,9886,1,0,0,0,9872,9886,3,1364,682,0, - 9873,9886,3,1260,630,0,9874,9876,3,1002,501,0,9875,9877,3,1380,690, - 0,9876,9875,1,0,0,0,9876,9877,1,0,0,0,9877,9886,1,0,0,0,9878,9886, - 3,1312,656,0,9879,9886,3,1314,657,0,9880,9881,3,1310,655,0,9881, - 9882,5,125,0,0,9882,9883,3,1310,655,0,9883,9886,1,0,0,0,9884,9886, - 3,1374,687,0,9885,9849,1,0,0,0,9885,9851,1,0,0,0,9885,9856,1,0,0, - 0,9885,9858,1,0,0,0,9885,9863,1,0,0,0,9885,9865,1,0,0,0,9885,9866, - 1,0,0,0,9885,9867,1,0,0,0,9885,9872,1,0,0,0,9885,9873,1,0,0,0,9885, - 9874,1,0,0,0,9885,9878,1,0,0,0,9885,9879,1,0,0,0,9885,9880,1,0,0, - 0,9885,9884,1,0,0,0,9886,1255,1,0,0,0,9887,9888,5,574,0,0,9888,1257, - 1,0,0,0,9889,9915,3,1444,722,0,9890,9912,5,2,0,0,9891,9895,3,1338, - 669,0,9892,9893,5,6,0,0,9893,9894,5,101,0,0,9894,9896,3,1340,670, - 0,9895,9892,1,0,0,0,9895,9896,1,0,0,0,9896,9898,1,0,0,0,9897,9899, - 3,1042,521,0,9898,9897,1,0,0,0,9898,9899,1,0,0,0,9899,9913,1,0,0, - 0,9900,9901,5,101,0,0,9901,9903,3,1340,670,0,9902,9904,3,1042,521, - 0,9903,9902,1,0,0,0,9903,9904,1,0,0,0,9904,9913,1,0,0,0,9905,9906, - 7,57,0,0,9906,9908,3,1338,669,0,9907,9909,3,1042,521,0,9908,9907, - 1,0,0,0,9908,9909,1,0,0,0,9909,9913,1,0,0,0,9910,9913,5,9,0,0,9911, - 9913,1,0,0,0,9912,9891,1,0,0,0,9912,9900,1,0,0,0,9912,9905,1,0,0, - 0,9912,9910,1,0,0,0,9912,9911,1,0,0,0,9913,9914,1,0,0,0,9914,9916, - 5,3,0,0,9915,9890,1,0,0,0,9915,9916,1,0,0,0,9916,1259,1,0,0,0,9917, - 9919,3,1258,629,0,9918,9920,3,1284,642,0,9919,9918,1,0,0,0,9919, - 9920,1,0,0,0,9920,9922,1,0,0,0,9921,9923,3,1286,643,0,9922,9921, - 1,0,0,0,9922,9923,1,0,0,0,9923,9925,1,0,0,0,9924,9926,3,1294,647, - 0,9925,9924,1,0,0,0,9925,9926,1,0,0,0,9926,9929,1,0,0,0,9927,9929, - 3,1264,632,0,9928,9917,1,0,0,0,9928,9927,1,0,0,0,9929,1261,1,0,0, - 0,9930,9933,3,1258,629,0,9931,9933,3,1264,632,0,9932,9930,1,0,0, - 0,9932,9931,1,0,0,0,9933,1263,1,0,0,0,9934,9935,5,108,0,0,9935,9936, - 5,62,0,0,9936,9937,5,2,0,0,9937,9938,3,1212,606,0,9938,9939,5,3, - 0,0,9939,10119,1,0,0,0,9940,10119,5,48,0,0,9941,9946,5,50,0,0,9942, - 9943,5,2,0,0,9943,9944,3,1456,728,0,9944,9945,5,3,0,0,9945,9947, - 1,0,0,0,9946,9942,1,0,0,0,9946,9947,1,0,0,0,9947,10119,1,0,0,0,9948, - 9953,5,51,0,0,9949,9950,5,2,0,0,9950,9951,3,1456,728,0,9951,9952, - 5,3,0,0,9952,9954,1,0,0,0,9953,9949,1,0,0,0,9953,9954,1,0,0,0,9954, - 10119,1,0,0,0,9955,9960,5,75,0,0,9956,9957,5,2,0,0,9957,9958,3,1456, - 728,0,9958,9959,5,3,0,0,9959,9961,1,0,0,0,9960,9956,1,0,0,0,9960, - 9961,1,0,0,0,9961,10119,1,0,0,0,9962,9967,5,76,0,0,9963,9964,5,2, - 0,0,9964,9965,3,1456,728,0,9965,9966,5,3,0,0,9966,9968,1,0,0,0,9967, - 9963,1,0,0,0,9967,9968,1,0,0,0,9968,10119,1,0,0,0,9969,10119,5,49, - 0,0,9970,10119,5,52,0,0,9971,10119,5,89,0,0,9972,10119,5,99,0,0, - 9973,10119,5,47,0,0,9974,10119,5,111,0,0,9975,9976,5,41,0,0,9976, - 9977,5,2,0,0,9977,9978,3,1212,606,0,9978,9979,5,36,0,0,9979,9980, - 3,1168,584,0,9980,9981,5,3,0,0,9981,10119,1,0,0,0,9982,9983,5,397, - 0,0,9983,9985,5,2,0,0,9984,9986,3,1348,674,0,9985,9984,1,0,0,0,9985, - 9986,1,0,0,0,9986,9987,1,0,0,0,9987,10119,5,3,0,0,9988,9989,5,489, - 0,0,9989,9990,5,2,0,0,9990,9993,3,1212,606,0,9991,9992,5,6,0,0,9992, - 9994,3,1352,676,0,9993,9991,1,0,0,0,9993,9994,1,0,0,0,9994,9995, - 1,0,0,0,9995,9996,5,3,0,0,9996,10119,1,0,0,0,9997,9998,5,410,0,0, - 9998,9999,5,2,0,0,9999,10000,3,1354,677,0,10000,10001,5,3,0,0,10001, - 10119,1,0,0,0,10002,10003,5,411,0,0,10003,10005,5,2,0,0,10004,10006, - 3,1356,678,0,10005,10004,1,0,0,0,10005,10006,1,0,0,0,10006,10007, - 1,0,0,0,10007,10119,5,3,0,0,10008,10009,5,417,0,0,10009,10011,5, - 2,0,0,10010,10012,3,1358,679,0,10011,10010,1,0,0,0,10011,10012,1, - 0,0,0,10012,10013,1,0,0,0,10013,10119,5,3,0,0,10014,10015,5,420, - 0,0,10015,10016,5,2,0,0,10016,10017,3,1212,606,0,10017,10018,5,36, - 0,0,10018,10019,3,1168,584,0,10019,10020,5,3,0,0,10020,10119,1,0, - 0,0,10021,10022,5,421,0,0,10022,10024,5,2,0,0,10023,10025,7,70,0, - 0,10024,10023,1,0,0,0,10024,10025,1,0,0,0,10025,10026,1,0,0,0,10026, - 10027,3,1360,680,0,10027,10028,5,3,0,0,10028,10119,1,0,0,0,10029, - 10030,5,408,0,0,10030,10031,5,2,0,0,10031,10032,3,1212,606,0,10032, - 10033,5,6,0,0,10033,10034,3,1212,606,0,10034,10035,5,3,0,0,10035, - 10119,1,0,0,0,10036,10037,5,393,0,0,10037,10038,5,2,0,0,10038,10039, - 3,1328,664,0,10039,10040,5,3,0,0,10040,10119,1,0,0,0,10041,10042, - 5,399,0,0,10042,10043,5,2,0,0,10043,10044,3,1328,664,0,10044,10045, - 5,3,0,0,10045,10119,1,0,0,0,10046,10047,5,404,0,0,10047,10048,5, - 2,0,0,10048,10049,3,1328,664,0,10049,10050,5,3,0,0,10050,10119,1, - 0,0,0,10051,10052,5,425,0,0,10052,10053,5,2,0,0,10053,10054,3,1328, - 664,0,10054,10055,5,3,0,0,10055,10119,1,0,0,0,10056,10057,5,426, - 0,0,10057,10058,5,2,0,0,10058,10059,5,266,0,0,10059,10065,3,1490, - 745,0,10060,10063,5,6,0,0,10061,10064,3,1270,635,0,10062,10064,3, - 1328,664,0,10063,10061,1,0,0,0,10063,10062,1,0,0,0,10064,10066,1, - 0,0,0,10065,10060,1,0,0,0,10065,10066,1,0,0,0,10066,10067,1,0,0, - 0,10067,10068,5,3,0,0,10068,10119,1,0,0,0,10069,10070,5,427,0,0, - 10070,10071,5,2,0,0,10071,10072,3,1254,627,0,10072,10073,3,1280, - 640,0,10073,10074,5,3,0,0,10074,10119,1,0,0,0,10075,10076,5,428, - 0,0,10076,10077,5,2,0,0,10077,10078,3,1272,636,0,10078,10079,5,3, - 0,0,10079,10119,1,0,0,0,10080,10081,5,429,0,0,10081,10082,5,2,0, - 0,10082,10083,3,1276,638,0,10083,10085,3,1212,606,0,10084,10086, - 3,1278,639,0,10085,10084,1,0,0,0,10085,10086,1,0,0,0,10086,10087, - 1,0,0,0,10087,10088,5,3,0,0,10088,10119,1,0,0,0,10089,10090,5,430, - 0,0,10090,10091,5,2,0,0,10091,10092,5,266,0,0,10092,10095,3,1490, - 745,0,10093,10094,5,6,0,0,10094,10096,3,1212,606,0,10095,10093,1, - 0,0,0,10095,10096,1,0,0,0,10096,10097,1,0,0,0,10097,10098,5,3,0, - 0,10098,10119,1,0,0,0,10099,10100,5,431,0,0,10100,10101,5,2,0,0, - 10101,10102,5,383,0,0,10102,10103,3,1212,606,0,10103,10104,5,6,0, - 0,10104,10106,3,1266,633,0,10105,10107,3,1268,634,0,10106,10105, - 1,0,0,0,10106,10107,1,0,0,0,10107,10108,1,0,0,0,10108,10109,5,3, - 0,0,10109,10119,1,0,0,0,10110,10111,5,432,0,0,10111,10112,5,2,0, - 0,10112,10113,3,1276,638,0,10113,10114,3,1212,606,0,10114,10115, - 5,36,0,0,10115,10116,3,1172,586,0,10116,10117,5,3,0,0,10117,10119, - 1,0,0,0,10118,9934,1,0,0,0,10118,9940,1,0,0,0,10118,9941,1,0,0,0, - 10118,9948,1,0,0,0,10118,9955,1,0,0,0,10118,9962,1,0,0,0,10118,9969, - 1,0,0,0,10118,9970,1,0,0,0,10118,9971,1,0,0,0,10118,9972,1,0,0,0, - 10118,9973,1,0,0,0,10118,9974,1,0,0,0,10118,9975,1,0,0,0,10118,9982, - 1,0,0,0,10118,9988,1,0,0,0,10118,9997,1,0,0,0,10118,10002,1,0,0, - 0,10118,10008,1,0,0,0,10118,10014,1,0,0,0,10118,10021,1,0,0,0,10118, - 10029,1,0,0,0,10118,10036,1,0,0,0,10118,10041,1,0,0,0,10118,10046, - 1,0,0,0,10118,10051,1,0,0,0,10118,10056,1,0,0,0,10118,10069,1,0, - 0,0,10118,10075,1,0,0,0,10118,10080,1,0,0,0,10118,10089,1,0,0,0, - 10118,10099,1,0,0,0,10118,10110,1,0,0,0,10119,1265,1,0,0,0,10120, - 10121,5,375,0,0,10121,10126,3,1212,606,0,10122,10123,5,375,0,0,10123, - 10124,5,269,0,0,10124,10126,5,450,0,0,10125,10120,1,0,0,0,10125, - 10122,1,0,0,0,10126,1267,1,0,0,0,10127,10128,5,6,0,0,10128,10129, - 5,339,0,0,10129,10138,5,385,0,0,10130,10131,5,6,0,0,10131,10132, - 5,339,0,0,10132,10138,5,269,0,0,10133,10134,5,6,0,0,10134,10135, - 5,339,0,0,10135,10136,5,269,0,0,10136,10138,5,450,0,0,10137,10127, - 1,0,0,0,10137,10130,1,0,0,0,10137,10133,1,0,0,0,10138,1269,1,0,0, - 0,10139,10140,5,424,0,0,10140,10141,5,2,0,0,10141,10142,3,1272,636, - 0,10142,10143,5,3,0,0,10143,1271,1,0,0,0,10144,10149,3,1274,637, - 0,10145,10146,5,6,0,0,10146,10148,3,1274,637,0,10147,10145,1,0,0, - 0,10148,10151,1,0,0,0,10149,10147,1,0,0,0,10149,10150,1,0,0,0,10150, - 1273,1,0,0,0,10151,10149,1,0,0,0,10152,10155,3,1212,606,0,10153, - 10154,5,36,0,0,10154,10156,3,1490,745,0,10155,10153,1,0,0,0,10155, - 10156,1,0,0,0,10156,1275,1,0,0,0,10157,10158,7,71,0,0,10158,1277, - 1,0,0,0,10159,10160,5,292,0,0,10160,10164,5,378,0,0,10161,10162, - 5,347,0,0,10162,10164,5,378,0,0,10163,10159,1,0,0,0,10163,10161, - 1,0,0,0,10164,1279,1,0,0,0,10165,10166,5,286,0,0,10166,10181,3,1254, - 627,0,10167,10168,5,286,0,0,10168,10169,3,1254,627,0,10169,10170, - 3,1282,641,0,10170,10181,1,0,0,0,10171,10172,5,286,0,0,10172,10173, - 3,1282,641,0,10173,10174,3,1254,627,0,10174,10181,1,0,0,0,10175, - 10176,5,286,0,0,10176,10177,3,1282,641,0,10177,10178,3,1254,627, - 0,10178,10179,3,1282,641,0,10179,10181,1,0,0,0,10180,10165,1,0,0, - 0,10180,10167,1,0,0,0,10180,10171,1,0,0,0,10180,10175,1,0,0,0,10181, - 1281,1,0,0,0,10182,10183,5,147,0,0,10183,10184,7,72,0,0,10184,1283, - 1,0,0,0,10185,10186,5,479,0,0,10186,10187,5,66,0,0,10187,10188,5, - 2,0,0,10188,10189,3,1044,522,0,10189,10190,5,3,0,0,10190,1285,1, - 0,0,0,10191,10192,5,480,0,0,10192,10193,5,2,0,0,10193,10194,5,103, - 0,0,10194,10195,3,1212,606,0,10195,10196,5,3,0,0,10196,1287,1,0, - 0,0,10197,10198,5,104,0,0,10198,10199,3,1290,645,0,10199,1289,1, - 0,0,0,10200,10205,3,1292,646,0,10201,10202,5,6,0,0,10202,10204,3, - 1292,646,0,10203,10201,1,0,0,0,10204,10207,1,0,0,0,10205,10203,1, - 0,0,0,10205,10206,1,0,0,0,10206,1291,1,0,0,0,10207,10205,1,0,0,0, - 10208,10209,3,1474,737,0,10209,10210,5,36,0,0,10210,10211,3,1296, - 648,0,10211,1293,1,0,0,0,10212,10215,5,124,0,0,10213,10216,3,1296, - 648,0,10214,10216,3,1474,737,0,10215,10213,1,0,0,0,10215,10214,1, - 0,0,0,10216,1295,1,0,0,0,10217,10219,5,2,0,0,10218,10220,3,1298, - 649,0,10219,10218,1,0,0,0,10219,10220,1,0,0,0,10220,10222,1,0,0, - 0,10221,10223,3,1300,650,0,10222,10221,1,0,0,0,10222,10223,1,0,0, - 0,10223,10225,1,0,0,0,10224,10226,3,1042,521,0,10225,10224,1,0,0, - 0,10225,10226,1,0,0,0,10226,10228,1,0,0,0,10227,10229,3,1302,651, - 0,10228,10227,1,0,0,0,10228,10229,1,0,0,0,10229,10230,1,0,0,0,10230, - 10231,5,3,0,0,10231,1297,1,0,0,0,10232,10233,3,1474,737,0,10233, - 1299,1,0,0,0,10234,10235,5,285,0,0,10235,10236,5,147,0,0,10236,10237, - 3,1328,664,0,10237,1301,1,0,0,0,10238,10239,5,299,0,0,10239,10241, - 3,1304,652,0,10240,10242,3,1308,654,0,10241,10240,1,0,0,0,10241, - 10242,1,0,0,0,10242,10254,1,0,0,0,10243,10244,5,320,0,0,10244,10246, - 3,1304,652,0,10245,10247,3,1308,654,0,10246,10245,1,0,0,0,10246, - 10247,1,0,0,0,10247,10254,1,0,0,0,10248,10249,5,481,0,0,10249,10251, - 3,1304,652,0,10250,10252,3,1308,654,0,10251,10250,1,0,0,0,10251, - 10252,1,0,0,0,10252,10254,1,0,0,0,10253,10238,1,0,0,0,10253,10243, - 1,0,0,0,10253,10248,1,0,0,0,10254,1303,1,0,0,0,10255,10262,3,1306, - 653,0,10256,10257,5,387,0,0,10257,10258,3,1306,653,0,10258,10259, - 5,33,0,0,10259,10260,3,1306,653,0,10260,10262,1,0,0,0,10261,10255, - 1,0,0,0,10261,10256,1,0,0,0,10262,1305,1,0,0,0,10263,10264,5,362, - 0,0,10264,10271,7,73,0,0,10265,10266,5,434,0,0,10266,10271,5,414, - 0,0,10267,10268,3,1212,606,0,10268,10269,7,73,0,0,10269,10271,1, - 0,0,0,10270,10263,1,0,0,0,10270,10265,1,0,0,0,10270,10267,1,0,0, - 0,10271,1307,1,0,0,0,10272,10279,5,199,0,0,10273,10274,5,434,0,0, - 10274,10280,5,414,0,0,10275,10280,5,66,0,0,10276,10280,5,467,0,0, - 10277,10278,5,269,0,0,10278,10280,5,482,0,0,10279,10273,1,0,0,0, - 10279,10275,1,0,0,0,10279,10276,1,0,0,0,10279,10277,1,0,0,0,10280, - 1309,1,0,0,0,10281,10282,5,414,0,0,10282,10284,5,2,0,0,10283,10285, - 3,1328,664,0,10284,10283,1,0,0,0,10284,10285,1,0,0,0,10285,10286, - 1,0,0,0,10286,10294,5,3,0,0,10287,10288,5,2,0,0,10288,10289,3,1328, - 664,0,10289,10290,5,6,0,0,10290,10291,3,1212,606,0,10291,10292,5, - 3,0,0,10292,10294,1,0,0,0,10293,10281,1,0,0,0,10293,10287,1,0,0, - 0,10294,1311,1,0,0,0,10295,10296,5,414,0,0,10296,10298,5,2,0,0,10297, - 10299,3,1328,664,0,10298,10297,1,0,0,0,10298,10299,1,0,0,0,10299, - 10300,1,0,0,0,10300,10301,5,3,0,0,10301,1313,1,0,0,0,10302,10303, - 5,2,0,0,10303,10304,3,1212,606,0,10304,10305,5,6,0,0,10305,10306, - 3,1328,664,0,10306,10307,5,3,0,0,10307,1315,1,0,0,0,10308,10309, - 7,74,0,0,10309,1317,1,0,0,0,10310,10313,5,29,0,0,10311,10313,3,1320, - 660,0,10312,10310,1,0,0,0,10312,10311,1,0,0,0,10313,1319,1,0,0,0, - 10314,10315,7,75,0,0,10315,1321,1,0,0,0,10316,10323,5,29,0,0,10317, - 10318,5,278,0,0,10318,10319,5,2,0,0,10319,10320,3,732,366,0,10320, - 10321,5,3,0,0,10321,10323,1,0,0,0,10322,10316,1,0,0,0,10322,10317, - 1,0,0,0,10323,1323,1,0,0,0,10324,10331,3,1318,659,0,10325,10326, - 5,278,0,0,10326,10327,5,2,0,0,10327,10328,3,732,366,0,10328,10329, - 5,3,0,0,10329,10331,1,0,0,0,10330,10324,1,0,0,0,10330,10325,1,0, - 0,0,10331,1325,1,0,0,0,10332,10345,3,1318,659,0,10333,10334,5,278, - 0,0,10334,10335,5,2,0,0,10335,10336,3,732,366,0,10336,10337,5,3, - 0,0,10337,10345,1,0,0,0,10338,10345,5,120,0,0,10339,10340,5,77,0, - 0,10340,10345,5,120,0,0,10341,10345,5,114,0,0,10342,10343,5,77,0, - 0,10343,10345,5,114,0,0,10344,10332,1,0,0,0,10344,10333,1,0,0,0, - 10344,10338,1,0,0,0,10344,10339,1,0,0,0,10344,10341,1,0,0,0,10344, - 10342,1,0,0,0,10345,1327,1,0,0,0,10346,10351,3,1212,606,0,10347, - 10348,5,6,0,0,10348,10350,3,1212,606,0,10349,10347,1,0,0,0,10350, - 10353,1,0,0,0,10351,10349,1,0,0,0,10351,10352,1,0,0,0,10352,1329, - 1,0,0,0,10353,10351,1,0,0,0,10354,10359,3,1336,668,0,10355,10356, - 5,6,0,0,10356,10358,3,1336,668,0,10357,10355,1,0,0,0,10358,10361, - 1,0,0,0,10359,10357,1,0,0,0,10359,10360,1,0,0,0,10360,1331,1,0,0, - 0,10361,10359,1,0,0,0,10362,10367,3,1334,667,0,10363,10364,5,6,0, - 0,10364,10366,3,1334,667,0,10365,10363,1,0,0,0,10366,10369,1,0,0, - 0,10367,10365,1,0,0,0,10367,10368,1,0,0,0,10368,1333,1,0,0,0,10369, - 10367,1,0,0,0,10370,10371,5,2,0,0,10371,10372,3,1212,606,0,10372, - 10373,5,3,0,0,10373,10376,1,0,0,0,10374,10376,3,1432,716,0,10375, - 10370,1,0,0,0,10375,10374,1,0,0,0,10376,1335,1,0,0,0,10377,10380, - 3,1212,606,0,10378,10380,3,1432,716,0,10379,10377,1,0,0,0,10379, - 10378,1,0,0,0,10380,1337,1,0,0,0,10381,10386,3,1340,670,0,10382, - 10383,5,6,0,0,10383,10385,3,1340,670,0,10384,10382,1,0,0,0,10385, - 10388,1,0,0,0,10386,10384,1,0,0,0,10386,10387,1,0,0,0,10387,1339, - 1,0,0,0,10388,10386,1,0,0,0,10389,10395,3,1212,606,0,10390,10391, - 3,684,342,0,10391,10392,7,76,0,0,10392,10393,3,1212,606,0,10393, - 10395,1,0,0,0,10394,10389,1,0,0,0,10394,10390,1,0,0,0,10395,1341, - 1,0,0,0,10396,10401,3,1168,584,0,10397,10398,5,6,0,0,10398,10400, - 3,1168,584,0,10399,10397,1,0,0,0,10400,10403,1,0,0,0,10401,10399, - 1,0,0,0,10401,10402,1,0,0,0,10402,1343,1,0,0,0,10403,10401,1,0,0, - 0,10404,10407,5,4,0,0,10405,10408,3,1328,664,0,10406,10408,3,1346, - 673,0,10407,10405,1,0,0,0,10407,10406,1,0,0,0,10407,10408,1,0,0, - 0,10408,10409,1,0,0,0,10409,10410,5,5,0,0,10410,1345,1,0,0,0,10411, - 10416,3,1344,672,0,10412,10413,5,6,0,0,10413,10415,3,1344,672,0, - 10414,10412,1,0,0,0,10415,10418,1,0,0,0,10416,10414,1,0,0,0,10416, - 10417,1,0,0,0,10417,1347,1,0,0,0,10418,10416,1,0,0,0,10419,10420, - 3,1350,675,0,10420,10421,5,64,0,0,10421,10422,3,1212,606,0,10422, - 1349,1,0,0,0,10423,10432,3,1492,746,0,10424,10432,5,384,0,0,10425, - 10432,5,264,0,0,10426,10432,5,176,0,0,10427,10432,5,218,0,0,10428, - 10432,5,261,0,0,10429,10432,5,326,0,0,10430,10432,3,1458,729,0,10431, - 10423,1,0,0,0,10431,10424,1,0,0,0,10431,10425,1,0,0,0,10431,10426, - 1,0,0,0,10431,10427,1,0,0,0,10431,10428,1,0,0,0,10431,10429,1,0, - 0,0,10431,10430,1,0,0,0,10432,1351,1,0,0,0,10433,10434,7,77,0,0, - 10434,1353,1,0,0,0,10435,10436,3,1212,606,0,10436,10437,5,84,0,0, - 10437,10438,3,1212,606,0,10438,10439,5,64,0,0,10439,10442,3,1212, - 606,0,10440,10441,5,62,0,0,10441,10443,3,1212,606,0,10442,10440, - 1,0,0,0,10442,10443,1,0,0,0,10443,1355,1,0,0,0,10444,10445,3,1252, - 626,0,10445,10446,5,68,0,0,10446,10447,3,1252,626,0,10447,1357,1, - 0,0,0,10448,10449,3,1212,606,0,10449,10450,5,64,0,0,10450,10451, - 3,1212,606,0,10451,10452,5,62,0,0,10452,10453,3,1212,606,0,10453, - 10476,1,0,0,0,10454,10455,3,1212,606,0,10455,10456,5,62,0,0,10456, - 10457,3,1212,606,0,10457,10458,5,64,0,0,10458,10459,3,1212,606,0, - 10459,10476,1,0,0,0,10460,10461,3,1212,606,0,10461,10462,5,64,0, - 0,10462,10463,3,1212,606,0,10463,10476,1,0,0,0,10464,10465,3,1212, - 606,0,10465,10466,5,62,0,0,10466,10467,3,1212,606,0,10467,10476, - 1,0,0,0,10468,10469,3,1212,606,0,10469,10470,5,127,0,0,10470,10471, - 3,1212,606,0,10471,10472,5,197,0,0,10472,10473,3,1212,606,0,10473, - 10476,1,0,0,0,10474,10476,3,1328,664,0,10475,10448,1,0,0,0,10475, - 10454,1,0,0,0,10475,10460,1,0,0,0,10475,10464,1,0,0,0,10475,10468, - 1,0,0,0,10475,10474,1,0,0,0,10476,1359,1,0,0,0,10477,10478,3,1212, - 606,0,10478,10479,5,64,0,0,10479,10480,3,1328,664,0,10480,10485, - 1,0,0,0,10481,10482,5,64,0,0,10482,10485,3,1328,664,0,10483,10485, - 3,1328,664,0,10484,10477,1,0,0,0,10484,10481,1,0,0,0,10484,10483, - 1,0,0,0,10485,1361,1,0,0,0,10486,10492,3,1002,501,0,10487,10488, - 5,2,0,0,10488,10489,3,1328,664,0,10489,10490,5,3,0,0,10490,10492, - 1,0,0,0,10491,10486,1,0,0,0,10491,10487,1,0,0,0,10492,1363,1,0,0, - 0,10493,10495,5,40,0,0,10494,10496,3,1372,686,0,10495,10494,1,0, - 0,0,10495,10496,1,0,0,0,10496,10497,1,0,0,0,10497,10499,3,1366,683, - 0,10498,10500,3,1370,685,0,10499,10498,1,0,0,0,10499,10500,1,0,0, - 0,10500,10501,1,0,0,0,10501,10502,5,454,0,0,10502,1365,1,0,0,0,10503, - 10505,3,1368,684,0,10504,10503,1,0,0,0,10505,10506,1,0,0,0,10506, - 10504,1,0,0,0,10506,10507,1,0,0,0,10507,1367,1,0,0,0,10508,10509, - 5,102,0,0,10509,10510,3,1212,606,0,10510,10511,5,93,0,0,10511,10512, - 3,1212,606,0,10512,1369,1,0,0,0,10513,10514,5,58,0,0,10514,10515, - 3,1212,606,0,10515,1371,1,0,0,0,10516,10517,3,1212,606,0,10517,1373, - 1,0,0,0,10518,10520,3,1474,737,0,10519,10521,3,1380,690,0,10520, - 10519,1,0,0,0,10520,10521,1,0,0,0,10521,1375,1,0,0,0,10522,10525, - 5,11,0,0,10523,10526,3,1438,719,0,10524,10526,5,9,0,0,10525,10523, - 1,0,0,0,10525,10524,1,0,0,0,10526,10540,1,0,0,0,10527,10536,5,4, - 0,0,10528,10537,3,1212,606,0,10529,10531,3,1378,689,0,10530,10529, - 1,0,0,0,10530,10531,1,0,0,0,10531,10532,1,0,0,0,10532,10534,5,8, - 0,0,10533,10535,3,1378,689,0,10534,10533,1,0,0,0,10534,10535,1,0, - 0,0,10535,10537,1,0,0,0,10536,10528,1,0,0,0,10536,10530,1,0,0,0, - 10537,10538,1,0,0,0,10538,10540,5,5,0,0,10539,10522,1,0,0,0,10539, - 10527,1,0,0,0,10540,1377,1,0,0,0,10541,10542,3,1212,606,0,10542, - 1379,1,0,0,0,10543,10545,3,1376,688,0,10544,10543,1,0,0,0,10545, - 10546,1,0,0,0,10546,10544,1,0,0,0,10546,10547,1,0,0,0,10547,1381, - 1,0,0,0,10548,10550,3,1376,688,0,10549,10548,1,0,0,0,10550,10553, - 1,0,0,0,10551,10549,1,0,0,0,10551,10552,1,0,0,0,10552,1383,1,0,0, - 0,10553,10551,1,0,0,0,10554,10555,3,1386,693,0,10555,1385,1,0,0, - 0,10556,10561,3,1388,694,0,10557,10558,5,6,0,0,10558,10560,3,1388, - 694,0,10559,10557,1,0,0,0,10560,10563,1,0,0,0,10561,10559,1,0,0, - 0,10561,10562,1,0,0,0,10562,1387,1,0,0,0,10563,10561,1,0,0,0,10564, - 10569,3,1336,668,0,10565,10566,5,36,0,0,10566,10570,3,1490,745,0, - 10567,10570,3,1492,746,0,10568,10570,1,0,0,0,10569,10565,1,0,0,0, - 10569,10567,1,0,0,0,10569,10568,1,0,0,0,10570,10573,1,0,0,0,10571, - 10573,5,9,0,0,10572,10564,1,0,0,0,10572,10571,1,0,0,0,10573,1389, - 1,0,0,0,10574,10579,3,1412,706,0,10575,10576,5,6,0,0,10576,10578, - 3,1412,706,0,10577,10575,1,0,0,0,10578,10581,1,0,0,0,10579,10577, - 1,0,0,0,10579,10580,1,0,0,0,10580,1391,1,0,0,0,10581,10579,1,0,0, - 0,10582,10587,3,1406,703,0,10583,10584,5,6,0,0,10584,10586,3,1406, - 703,0,10585,10583,1,0,0,0,10586,10589,1,0,0,0,10587,10585,1,0,0, - 0,10587,10588,1,0,0,0,10588,1393,1,0,0,0,10589,10587,1,0,0,0,10590, - 10595,3,1422,711,0,10591,10592,5,6,0,0,10592,10594,3,1422,711,0, - 10593,10591,1,0,0,0,10594,10597,1,0,0,0,10595,10593,1,0,0,0,10595, - 10596,1,0,0,0,10596,1395,1,0,0,0,10597,10595,1,0,0,0,10598,10603, - 3,1420,710,0,10599,10600,5,6,0,0,10600,10602,3,1420,710,0,10601, - 10599,1,0,0,0,10602,10605,1,0,0,0,10603,10601,1,0,0,0,10603,10604, - 1,0,0,0,10604,1397,1,0,0,0,10605,10603,1,0,0,0,10606,10611,3,1428, - 714,0,10607,10608,5,6,0,0,10608,10610,3,1428,714,0,10609,10607,1, - 0,0,0,10610,10613,1,0,0,0,10611,10609,1,0,0,0,10611,10612,1,0,0, - 0,10612,1399,1,0,0,0,10613,10611,1,0,0,0,10614,10616,3,1474,737, - 0,10615,10617,3,1380,690,0,10616,10615,1,0,0,0,10616,10617,1,0,0, - 0,10617,1401,1,0,0,0,10618,10620,3,1474,737,0,10619,10621,3,1380, - 690,0,10620,10619,1,0,0,0,10620,10621,1,0,0,0,10621,1403,1,0,0,0, - 10622,10624,3,1474,737,0,10623,10625,3,1380,690,0,10624,10623,1, - 0,0,0,10624,10625,1,0,0,0,10625,1405,1,0,0,0,10626,10628,3,1474, - 737,0,10627,10629,3,1380,690,0,10628,10627,1,0,0,0,10628,10629,1, - 0,0,0,10629,1407,1,0,0,0,10630,10632,3,1474,737,0,10631,10633,3, - 1380,690,0,10632,10631,1,0,0,0,10632,10633,1,0,0,0,10633,1409,1, - 0,0,0,10634,10636,3,1474,737,0,10635,10637,3,560,280,0,10636,10635, - 1,0,0,0,10636,10637,1,0,0,0,10637,1411,1,0,0,0,10638,10640,3,1474, - 737,0,10639,10641,3,1380,690,0,10640,10639,1,0,0,0,10640,10641,1, - 0,0,0,10641,1413,1,0,0,0,10642,10647,3,1402,701,0,10643,10644,5, - 6,0,0,10644,10646,3,1402,701,0,10645,10643,1,0,0,0,10646,10649,1, - 0,0,0,10647,10645,1,0,0,0,10647,10648,1,0,0,0,10648,1415,1,0,0,0, - 10649,10647,1,0,0,0,10650,10655,3,1436,718,0,10651,10652,5,6,0,0, - 10652,10654,3,1436,718,0,10653,10651,1,0,0,0,10654,10657,1,0,0,0, - 10655,10653,1,0,0,0,10655,10656,1,0,0,0,10656,1417,1,0,0,0,10657, - 10655,1,0,0,0,10658,10660,3,1474,737,0,10659,10661,3,560,280,0,10660, - 10659,1,0,0,0,10660,10661,1,0,0,0,10661,1419,1,0,0,0,10662,10664, - 3,1474,737,0,10663,10665,3,560,280,0,10664,10663,1,0,0,0,10664,10665, - 1,0,0,0,10665,1421,1,0,0,0,10666,10668,3,1474,737,0,10667,10669, - 3,560,280,0,10668,10667,1,0,0,0,10668,10669,1,0,0,0,10669,1423,1, - 0,0,0,10670,10671,3,1474,737,0,10671,1425,1,0,0,0,10672,10673,3, - 1474,737,0,10673,1427,1,0,0,0,10674,10679,3,1482,741,0,10675,10676, - 3,1474,737,0,10676,10677,3,1380,690,0,10677,10679,1,0,0,0,10678, - 10674,1,0,0,0,10678,10675,1,0,0,0,10679,1429,1,0,0,0,10680,10685, - 3,1482,741,0,10681,10682,3,1474,737,0,10682,10683,3,1380,690,0,10683, - 10685,1,0,0,0,10684,10680,1,0,0,0,10684,10681,1,0,0,0,10685,1431, - 1,0,0,0,10686,10690,3,1474,737,0,10687,10689,3,1376,688,0,10688, - 10687,1,0,0,0,10689,10692,1,0,0,0,10690,10688,1,0,0,0,10690,10691, - 1,0,0,0,10691,10695,1,0,0,0,10692,10690,1,0,0,0,10693,10695,4,716, - 8,0,10694,10686,1,0,0,0,10694,10693,1,0,0,0,10695,1433,1,0,0,0,10696, - 10697,3,1474,737,0,10697,1435,1,0,0,0,10698,10699,3,1474,737,0,10699, - 1437,1,0,0,0,10700,10701,3,1490,745,0,10701,1439,1,0,0,0,10702,10703, - 3,1458,729,0,10703,1441,1,0,0,0,10704,10709,3,1482,741,0,10705,10706, - 3,1474,737,0,10706,10707,3,1380,690,0,10707,10709,1,0,0,0,10708, - 10704,1,0,0,0,10708,10705,1,0,0,0,10709,1443,1,0,0,0,10710,10715, - 3,1482,741,0,10711,10712,3,1474,737,0,10712,10713,3,1380,690,0,10713, - 10715,1,0,0,0,10714,10710,1,0,0,0,10714,10711,1,0,0,0,10715,1445, - 1,0,0,0,10716,10721,3,1484,742,0,10717,10718,3,1474,737,0,10718, - 10719,3,1380,690,0,10719,10721,1,0,0,0,10720,10716,1,0,0,0,10720, - 10717,1,0,0,0,10721,1447,1,0,0,0,10722,10758,3,1456,728,0,10723, - 10758,3,1454,727,0,10724,10758,3,1458,729,0,10725,10758,3,1452,726, - 0,10726,10758,3,1450,725,0,10727,10737,3,1444,722,0,10728,10738, - 3,1458,729,0,10729,10730,5,2,0,0,10730,10732,3,1338,669,0,10731, - 10733,3,1042,521,0,10732,10731,1,0,0,0,10732,10733,1,0,0,0,10733, - 10734,1,0,0,0,10734,10735,5,3,0,0,10735,10736,3,1458,729,0,10736, - 10738,1,0,0,0,10737,10728,1,0,0,0,10737,10729,1,0,0,0,10738,10758, - 1,0,0,0,10739,10740,3,1174,587,0,10740,10741,3,1458,729,0,10741, - 10758,1,0,0,0,10742,10752,3,1202,601,0,10743,10745,3,1458,729,0, - 10744,10746,3,1206,603,0,10745,10744,1,0,0,0,10745,10746,1,0,0,0, - 10746,10753,1,0,0,0,10747,10748,5,2,0,0,10748,10749,3,1456,728,0, - 10749,10750,5,3,0,0,10750,10751,3,1458,729,0,10751,10753,1,0,0,0, - 10752,10743,1,0,0,0,10752,10747,1,0,0,0,10753,10758,1,0,0,0,10754, - 10758,5,96,0,0,10755,10758,5,60,0,0,10756,10758,5,78,0,0,10757,10722, - 1,0,0,0,10757,10723,1,0,0,0,10757,10724,1,0,0,0,10757,10725,1,0, - 0,0,10757,10726,1,0,0,0,10757,10727,1,0,0,0,10757,10739,1,0,0,0, - 10757,10742,1,0,0,0,10757,10754,1,0,0,0,10757,10755,1,0,0,0,10757, - 10756,1,0,0,0,10758,1449,1,0,0,0,10759,10760,5,567,0,0,10760,1451, - 1,0,0,0,10761,10762,5,563,0,0,10762,1453,1,0,0,0,10763,10764,5,573, - 0,0,10764,1455,1,0,0,0,10765,10766,5,571,0,0,10766,1457,1,0,0,0, - 10767,10769,3,1460,730,0,10768,10770,3,1462,731,0,10769,10768,1, - 0,0,0,10769,10770,1,0,0,0,10770,1459,1,0,0,0,10771,10783,5,558,0, - 0,10772,10783,5,560,0,0,10773,10777,5,562,0,0,10774,10776,5,588, - 0,0,10775,10774,1,0,0,0,10776,10779,1,0,0,0,10777,10775,1,0,0,0, - 10777,10778,1,0,0,0,10778,10780,1,0,0,0,10779,10777,1,0,0,0,10780, - 10783,5,589,0,0,10781,10783,5,584,0,0,10782,10771,1,0,0,0,10782, - 10772,1,0,0,0,10782,10773,1,0,0,0,10782,10781,1,0,0,0,10783,1461, - 1,0,0,0,10784,10785,5,487,0,0,10785,10786,3,1460,730,0,10786,1463, - 1,0,0,0,10787,10793,3,1456,728,0,10788,10789,5,12,0,0,10789,10793, - 3,1456,728,0,10790,10791,5,13,0,0,10791,10793,3,1456,728,0,10792, - 10787,1,0,0,0,10792,10788,1,0,0,0,10792,10790,1,0,0,0,10793,1465, - 1,0,0,0,10794,10795,3,1470,735,0,10795,1467,1,0,0,0,10796,10797, - 3,1470,735,0,10797,1469,1,0,0,0,10798,10804,3,1488,744,0,10799,10804, - 5,52,0,0,10800,10804,5,49,0,0,10801,10804,5,89,0,0,10802,10804,5, - 524,0,0,10803,10798,1,0,0,0,10803,10799,1,0,0,0,10803,10800,1,0, - 0,0,10803,10801,1,0,0,0,10803,10802,1,0,0,0,10804,1471,1,0,0,0,10805, - 10810,3,1470,735,0,10806,10807,5,6,0,0,10807,10809,3,1470,735,0, - 10808,10806,1,0,0,0,10809,10812,1,0,0,0,10810,10808,1,0,0,0,10810, - 10811,1,0,0,0,10811,1473,1,0,0,0,10812,10810,1,0,0,0,10813,10818, - 3,1492,746,0,10814,10818,3,1496,748,0,10815,10818,3,1498,749,0,10816, - 10818,3,1734,867,0,10817,10813,1,0,0,0,10817,10814,1,0,0,0,10817, - 10815,1,0,0,0,10817,10816,1,0,0,0,10818,1475,1,0,0,0,10819,10820, - 3,1492,746,0,10820,1477,1,0,0,0,10821,10834,3,710,355,0,10822,10823, - 5,2,0,0,10823,10824,3,1212,606,0,10824,10825,5,3,0,0,10825,10826, - 1,0,0,0,10826,10828,3,1492,746,0,10827,10829,3,650,325,0,10828,10827, - 1,0,0,0,10828,10829,1,0,0,0,10829,10831,1,0,0,0,10830,10832,3,652, - 326,0,10831,10830,1,0,0,0,10831,10832,1,0,0,0,10832,10834,1,0,0, - 0,10833,10821,1,0,0,0,10833,10822,1,0,0,0,10834,1479,1,0,0,0,10835, - 10836,5,105,0,0,10836,10838,3,132,66,0,10837,10835,1,0,0,0,10837, - 10838,1,0,0,0,10838,10840,1,0,0,0,10839,10841,3,286,143,0,10840, - 10839,1,0,0,0,10840,10841,1,0,0,0,10841,1481,1,0,0,0,10842,10847, - 3,1492,746,0,10843,10847,3,1496,748,0,10844,10847,3,1734,867,0,10845, - 10847,3,1500,750,0,10846,10842,1,0,0,0,10846,10843,1,0,0,0,10846, - 10844,1,0,0,0,10846,10845,1,0,0,0,10847,1483,1,0,0,0,10848,10853, - 3,1492,746,0,10849,10853,3,1496,748,0,10850,10853,3,1734,867,0,10851, - 10853,3,1500,750,0,10852,10848,1,0,0,0,10852,10849,1,0,0,0,10852, - 10850,1,0,0,0,10852,10851,1,0,0,0,10853,1485,1,0,0,0,10854,10857, - 3,1432,716,0,10855,10857,3,1500,750,0,10856,10854,1,0,0,0,10856, - 10855,1,0,0,0,10857,1487,1,0,0,0,10858,10863,3,1492,746,0,10859, - 10863,3,1496,748,0,10860,10863,3,1498,749,0,10861,10863,3,1500,750, - 0,10862,10858,1,0,0,0,10862,10859,1,0,0,0,10862,10860,1,0,0,0,10862, - 10861,1,0,0,0,10863,1489,1,0,0,0,10864,10871,3,1492,746,0,10865, - 10871,3,1734,867,0,10866,10871,3,1496,748,0,10867,10871,3,1498,749, - 0,10868,10871,3,1500,750,0,10869,10871,3,1502,751,0,10870,10864, - 1,0,0,0,10870,10865,1,0,0,0,10870,10866,1,0,0,0,10870,10867,1,0, - 0,0,10870,10868,1,0,0,0,10870,10869,1,0,0,0,10871,1491,1,0,0,0,10872, - 10874,5,549,0,0,10873,10875,3,1462,731,0,10874,10873,1,0,0,0,10874, - 10875,1,0,0,0,10875,10883,1,0,0,0,10876,10883,3,1458,729,0,10877, - 10883,5,550,0,0,10878,10883,5,554,0,0,10879,10883,3,1256,628,0,10880, - 10883,3,1494,747,0,10881,10883,3,1734,867,0,10882,10872,1,0,0,0, - 10882,10876,1,0,0,0,10882,10877,1,0,0,0,10882,10878,1,0,0,0,10882, - 10879,1,0,0,0,10882,10880,1,0,0,0,10882,10881,1,0,0,0,10883,1493, - 1,0,0,0,10884,10885,5,575,0,0,10885,1495,1,0,0,0,10886,10887,7,78, - 0,0,10887,1497,1,0,0,0,10888,10940,5,387,0,0,10889,10940,5,388,0, - 0,10890,10940,3,1184,592,0,10891,10940,5,390,0,0,10892,10940,5,391, - 0,0,10893,10940,3,1192,596,0,10894,10940,5,393,0,0,10895,10940,5, - 394,0,0,10896,10940,5,395,0,0,10897,10940,5,396,0,0,10898,10940, - 5,397,0,0,10899,10940,5,398,0,0,10900,10940,5,399,0,0,10901,10940, - 5,470,0,0,10902,10940,5,400,0,0,10903,10940,5,401,0,0,10904,10940, - 5,402,0,0,10905,10940,5,403,0,0,10906,10940,5,404,0,0,10907,10940, - 5,405,0,0,10908,10940,5,406,0,0,10909,10940,5,407,0,0,10910,10940, - 5,489,0,0,10911,10940,5,408,0,0,10912,10940,3,1180,590,0,10913,10940, - 5,453,0,0,10914,10940,5,410,0,0,10915,10940,5,411,0,0,10916,10940, - 5,412,0,0,10917,10940,5,413,0,0,10918,10940,5,414,0,0,10919,10940, - 5,415,0,0,10920,10940,5,416,0,0,10921,10940,5,417,0,0,10922,10940, - 5,418,0,0,10923,10940,5,419,0,0,10924,10940,5,420,0,0,10925,10940, - 5,421,0,0,10926,10940,5,422,0,0,10927,10940,5,423,0,0,10928,10940, - 5,424,0,0,10929,10940,5,425,0,0,10930,10940,5,426,0,0,10931,10940, - 5,427,0,0,10932,10940,5,428,0,0,10933,10940,5,476,0,0,10934,10940, - 5,429,0,0,10935,10940,5,430,0,0,10936,10940,5,431,0,0,10937,10940, - 5,432,0,0,10938,10940,5,474,0,0,10939,10888,1,0,0,0,10939,10889, - 1,0,0,0,10939,10890,1,0,0,0,10939,10891,1,0,0,0,10939,10892,1,0, - 0,0,10939,10893,1,0,0,0,10939,10894,1,0,0,0,10939,10895,1,0,0,0, - 10939,10896,1,0,0,0,10939,10897,1,0,0,0,10939,10898,1,0,0,0,10939, - 10899,1,0,0,0,10939,10900,1,0,0,0,10939,10901,1,0,0,0,10939,10902, - 1,0,0,0,10939,10903,1,0,0,0,10939,10904,1,0,0,0,10939,10905,1,0, - 0,0,10939,10906,1,0,0,0,10939,10907,1,0,0,0,10939,10908,1,0,0,0, - 10939,10909,1,0,0,0,10939,10910,1,0,0,0,10939,10911,1,0,0,0,10939, - 10912,1,0,0,0,10939,10913,1,0,0,0,10939,10914,1,0,0,0,10939,10915, - 1,0,0,0,10939,10916,1,0,0,0,10939,10917,1,0,0,0,10939,10918,1,0, - 0,0,10939,10919,1,0,0,0,10939,10920,1,0,0,0,10939,10921,1,0,0,0, - 10939,10922,1,0,0,0,10939,10923,1,0,0,0,10939,10924,1,0,0,0,10939, - 10925,1,0,0,0,10939,10926,1,0,0,0,10939,10927,1,0,0,0,10939,10928, - 1,0,0,0,10939,10929,1,0,0,0,10939,10930,1,0,0,0,10939,10931,1,0, - 0,0,10939,10932,1,0,0,0,10939,10933,1,0,0,0,10939,10934,1,0,0,0, - 10939,10935,1,0,0,0,10939,10936,1,0,0,0,10939,10937,1,0,0,0,10939, - 10938,1,0,0,0,10940,1499,1,0,0,0,10941,10942,7,79,0,0,10942,1501, - 1,0,0,0,10943,10944,7,80,0,0,10944,1503,1,0,0,0,10945,10946,3,1506, - 753,0,10946,10947,3,1516,758,0,10947,10948,3,1514,757,0,10948,1505, - 1,0,0,0,10949,10951,3,1508,754,0,10950,10949,1,0,0,0,10951,10954, - 1,0,0,0,10952,10950,1,0,0,0,10952,10953,1,0,0,0,10953,1507,1,0,0, - 0,10954,10952,1,0,0,0,10955,10956,3,1510,755,0,10956,10957,5,279, - 0,0,10957,10958,5,490,0,0,10958,10976,1,0,0,0,10959,10960,3,1510, - 755,0,10960,10961,5,491,0,0,10961,10962,3,1512,756,0,10962,10976, - 1,0,0,0,10963,10964,3,1510,755,0,10964,10965,5,492,0,0,10965,10966, - 5,493,0,0,10966,10976,1,0,0,0,10967,10968,3,1510,755,0,10968,10969, - 5,492,0,0,10969,10970,5,494,0,0,10970,10976,1,0,0,0,10971,10972, - 3,1510,755,0,10972,10973,5,492,0,0,10973,10974,5,495,0,0,10974,10976, - 1,0,0,0,10975,10955,1,0,0,0,10975,10959,1,0,0,0,10975,10963,1,0, - 0,0,10975,10967,1,0,0,0,10975,10971,1,0,0,0,10976,1509,1,0,0,0,10977, - 10978,5,29,0,0,10978,1511,1,0,0,0,10979,10984,3,1458,729,0,10980, - 10984,3,1502,751,0,10981,10984,3,1734,867,0,10982,10984,3,1496,748, - 0,10983,10979,1,0,0,0,10983,10980,1,0,0,0,10983,10981,1,0,0,0,10983, - 10982,1,0,0,0,10984,1513,1,0,0,0,10985,10988,1,0,0,0,10986,10988, - 5,7,0,0,10987,10985,1,0,0,0,10987,10986,1,0,0,0,10988,1515,1,0,0, - 0,10989,10990,3,1518,759,0,10990,10991,5,146,0,0,10991,10992,3,1560, - 780,0,10992,10993,3,1714,857,0,10993,10994,5,454,0,0,10994,10995, - 3,1728,864,0,10995,1517,1,0,0,0,10996,11001,3,1724,862,0,10997,10999, - 3,1520,760,0,10998,11000,3,1522,761,0,10999,10998,1,0,0,0,10999, - 11000,1,0,0,0,11000,11002,1,0,0,0,11001,10997,1,0,0,0,11001,11002, - 1,0,0,0,11002,1519,1,0,0,0,11003,11004,5,178,0,0,11004,1521,1,0, - 0,0,11005,11007,3,1526,763,0,11006,11005,1,0,0,0,11007,11008,1,0, - 0,0,11008,11006,1,0,0,0,11008,11009,1,0,0,0,11009,1523,1,0,0,0,11010, - 11011,5,18,0,0,11011,11012,3,1732,866,0,11012,11013,5,19,0,0,11013, - 1525,1,0,0,0,11014,11018,3,1528,764,0,11015,11018,5,178,0,0,11016, - 11018,3,1524,762,0,11017,11014,1,0,0,0,11017,11015,1,0,0,0,11017, - 11016,1,0,0,0,11018,1527,1,0,0,0,11019,11035,3,1544,772,0,11020, - 11021,5,496,0,0,11021,11022,5,62,0,0,11022,11036,3,1542,771,0,11023, - 11024,3,1546,773,0,11024,11025,3,1548,774,0,11025,11026,3,1550,775, - 0,11026,11027,3,1552,776,0,11027,11028,3,1554,777,0,11028,11036, - 1,0,0,0,11029,11030,3,1530,765,0,11030,11031,5,172,0,0,11031,11032, - 3,1534,767,0,11032,11033,3,1540,770,0,11033,11034,3,1532,766,0,11034, - 11036,1,0,0,0,11035,11020,1,0,0,0,11035,11023,1,0,0,0,11035,11029, - 1,0,0,0,11036,11037,1,0,0,0,11037,11038,5,7,0,0,11038,1529,1,0,0, - 0,11039,11044,1,0,0,0,11040,11041,5,269,0,0,11041,11044,5,324,0, - 0,11042,11044,5,324,0,0,11043,11039,1,0,0,0,11043,11040,1,0,0,0, - 11043,11042,1,0,0,0,11044,1531,1,0,0,0,11045,11046,3,1000,500,0, - 11046,1533,1,0,0,0,11047,11053,1,0,0,0,11048,11049,5,2,0,0,11049, - 11050,3,1536,768,0,11050,11051,5,3,0,0,11051,11053,1,0,0,0,11052, - 11047,1,0,0,0,11052,11048,1,0,0,0,11053,1535,1,0,0,0,11054,11059, - 3,1538,769,0,11055,11056,5,6,0,0,11056,11058,3,1538,769,0,11057, - 11055,1,0,0,0,11058,11061,1,0,0,0,11059,11057,1,0,0,0,11059,11060, - 1,0,0,0,11060,1537,1,0,0,0,11061,11059,1,0,0,0,11062,11063,3,1544, - 772,0,11063,11064,3,1548,774,0,11064,1539,1,0,0,0,11065,11066,7, - 81,0,0,11066,1541,1,0,0,0,11067,11070,5,28,0,0,11068,11070,3,1474, - 737,0,11069,11067,1,0,0,0,11069,11068,1,0,0,0,11070,1543,1,0,0,0, - 11071,11072,3,1732,866,0,11072,1545,1,0,0,0,11073,11076,1,0,0,0, - 11074,11076,5,497,0,0,11075,11073,1,0,0,0,11075,11074,1,0,0,0,11076, - 1547,1,0,0,0,11077,11078,3,1168,584,0,11078,1549,1,0,0,0,11079,11083, - 1,0,0,0,11080,11081,5,43,0,0,11081,11083,3,558,279,0,11082,11079, - 1,0,0,0,11082,11080,1,0,0,0,11083,1551,1,0,0,0,11084,11088,1,0,0, - 0,11085,11086,5,77,0,0,11086,11088,5,78,0,0,11087,11084,1,0,0,0, - 11087,11085,1,0,0,0,11088,1553,1,0,0,0,11089,11094,1,0,0,0,11090, - 11091,3,1556,778,0,11091,11092,3,1736,868,0,11092,11094,1,0,0,0, - 11093,11089,1,0,0,0,11093,11090,1,0,0,0,11094,1555,1,0,0,0,11095, - 11098,3,1558,779,0,11096,11098,5,53,0,0,11097,11095,1,0,0,0,11097, - 11096,1,0,0,0,11098,1557,1,0,0,0,11099,11100,7,82,0,0,11100,1559, - 1,0,0,0,11101,11103,3,1562,781,0,11102,11101,1,0,0,0,11103,11106, - 1,0,0,0,11104,11102,1,0,0,0,11104,11105,1,0,0,0,11105,1561,1,0,0, - 0,11106,11104,1,0,0,0,11107,11108,3,1516,758,0,11108,11109,5,7,0, - 0,11109,11135,1,0,0,0,11110,11135,3,1628,814,0,11111,11135,3,1632, - 816,0,11112,11135,3,1570,785,0,11113,11135,3,1586,793,0,11114,11135, - 3,1592,796,0,11115,11135,3,1602,801,0,11116,11135,3,1604,802,0,11117, - 11135,3,1606,803,0,11118,11135,3,1620,810,0,11119,11135,3,1624,812, - 0,11120,11135,3,1644,822,0,11121,11135,3,1650,825,0,11122,11135, - 3,1652,826,0,11123,11135,3,1564,782,0,11124,11135,3,1566,783,0,11125, - 11135,3,1572,786,0,11126,11135,3,1660,830,0,11127,11135,3,1672,836, - 0,11128,11135,3,1680,840,0,11129,11135,3,1700,850,0,11130,11135, - 3,1702,851,0,11131,11135,3,1704,852,0,11132,11135,3,1706,853,0,11133, - 11135,3,1710,855,0,11134,11107,1,0,0,0,11134,11110,1,0,0,0,11134, - 11111,1,0,0,0,11134,11112,1,0,0,0,11134,11113,1,0,0,0,11134,11114, - 1,0,0,0,11134,11115,1,0,0,0,11134,11116,1,0,0,0,11134,11117,1,0, - 0,0,11134,11118,1,0,0,0,11134,11119,1,0,0,0,11134,11120,1,0,0,0, - 11134,11121,1,0,0,0,11134,11122,1,0,0,0,11134,11123,1,0,0,0,11134, - 11124,1,0,0,0,11134,11125,1,0,0,0,11134,11126,1,0,0,0,11134,11127, - 1,0,0,0,11134,11128,1,0,0,0,11134,11129,1,0,0,0,11134,11130,1,0, - 0,0,11134,11131,1,0,0,0,11134,11132,1,0,0,0,11134,11133,1,0,0,0, - 11135,1563,1,0,0,0,11136,11137,5,498,0,0,11137,11138,3,1740,870, - 0,11138,11139,5,7,0,0,11139,1565,1,0,0,0,11140,11141,5,433,0,0,11141, - 11147,3,1732,866,0,11142,11143,5,2,0,0,11143,11144,3,1568,784,0, - 11144,11145,5,3,0,0,11145,11146,5,7,0,0,11146,11148,1,0,0,0,11147, - 11142,1,0,0,0,11147,11148,1,0,0,0,11148,11157,1,0,0,0,11149,11150, - 5,57,0,0,11150,11151,3,1732,866,0,11151,11152,5,2,0,0,11152,11153, - 3,1568,784,0,11153,11154,5,3,0,0,11154,11155,5,7,0,0,11155,11157, - 1,0,0,0,11156,11140,1,0,0,0,11156,11149,1,0,0,0,11157,1567,1,0,0, - 0,11158,11161,1,0,0,0,11159,11161,3,1328,664,0,11160,11158,1,0,0, - 0,11160,11159,1,0,0,0,11161,1569,1,0,0,0,11162,11163,3,1584,792, - 0,11163,11164,3,1558,779,0,11164,11165,3,1736,868,0,11165,11166, - 5,7,0,0,11166,1571,1,0,0,0,11167,11168,5,499,0,0,11168,11169,3,1574, - 787,0,11169,11170,5,500,0,0,11170,11171,3,1576,788,0,11171,11172, - 5,7,0,0,11172,1573,1,0,0,0,11173,11177,1,0,0,0,11174,11177,5,434, - 0,0,11175,11177,5,501,0,0,11176,11173,1,0,0,0,11176,11174,1,0,0, - 0,11176,11175,1,0,0,0,11177,1575,1,0,0,0,11178,11183,3,1578,789, - 0,11179,11180,5,6,0,0,11180,11182,3,1578,789,0,11181,11179,1,0,0, - 0,11182,11185,1,0,0,0,11183,11181,1,0,0,0,11183,11184,1,0,0,0,11184, - 1577,1,0,0,0,11185,11183,1,0,0,0,11186,11187,3,1582,791,0,11187, - 11188,3,1558,779,0,11188,11189,3,1580,790,0,11189,1579,1,0,0,0,11190, - 11191,3,1474,737,0,11191,1581,1,0,0,0,11192,11193,3,1584,792,0,11193, - 1583,1,0,0,0,11194,11197,3,558,279,0,11195,11197,5,28,0,0,11196, - 11194,1,0,0,0,11196,11195,1,0,0,0,11197,11204,1,0,0,0,11198,11199, - 5,4,0,0,11199,11200,3,1742,871,0,11200,11201,5,5,0,0,11201,11203, - 1,0,0,0,11202,11198,1,0,0,0,11203,11206,1,0,0,0,11204,11202,1,0, - 0,0,11204,11205,1,0,0,0,11205,1585,1,0,0,0,11206,11204,1,0,0,0,11207, - 11208,5,220,0,0,11208,11209,3,1738,869,0,11209,11210,5,93,0,0,11210, - 11211,3,1560,780,0,11211,11212,3,1588,794,0,11212,11213,3,1590,795, - 0,11213,11214,5,454,0,0,11214,11215,5,220,0,0,11215,11216,5,7,0, - 0,11216,1587,1,0,0,0,11217,11218,5,502,0,0,11218,11219,3,1212,606, - 0,11219,11220,5,93,0,0,11220,11221,3,1560,780,0,11221,11223,1,0, - 0,0,11222,11217,1,0,0,0,11223,11226,1,0,0,0,11224,11222,1,0,0,0, - 11224,11225,1,0,0,0,11225,1589,1,0,0,0,11226,11224,1,0,0,0,11227, - 11231,1,0,0,0,11228,11229,5,58,0,0,11229,11231,3,1560,780,0,11230, - 11227,1,0,0,0,11230,11228,1,0,0,0,11231,1591,1,0,0,0,11232,11233, - 5,40,0,0,11233,11234,3,1594,797,0,11234,11235,3,1596,798,0,11235, - 11236,3,1600,800,0,11236,11237,5,454,0,0,11237,11238,5,40,0,0,11238, - 11239,5,7,0,0,11239,1593,1,0,0,0,11240,11243,1,0,0,0,11241,11243, - 3,1736,868,0,11242,11240,1,0,0,0,11242,11241,1,0,0,0,11243,1595, - 1,0,0,0,11244,11246,3,1598,799,0,11245,11244,1,0,0,0,11246,11247, - 1,0,0,0,11247,11245,1,0,0,0,11247,11248,1,0,0,0,11248,1597,1,0,0, - 0,11249,11250,5,102,0,0,11250,11251,3,1328,664,0,11251,11252,5,93, - 0,0,11252,11253,3,1560,780,0,11253,1599,1,0,0,0,11254,11258,1,0, - 0,0,11255,11256,5,58,0,0,11256,11258,3,1560,780,0,11257,11254,1, - 0,0,0,11257,11255,1,0,0,0,11258,1601,1,0,0,0,11259,11260,3,1726, - 863,0,11260,11261,3,1648,824,0,11261,1603,1,0,0,0,11262,11263,3, - 1726,863,0,11263,11264,5,503,0,0,11264,11265,3,1744,872,0,11265, - 11266,3,1648,824,0,11266,1605,1,0,0,0,11267,11268,3,1726,863,0,11268, - 11269,5,62,0,0,11269,11270,3,1608,804,0,11270,11271,3,1648,824,0, - 11271,1607,1,0,0,0,11272,11273,3,1618,809,0,11273,11289,5,68,0,0, - 11274,11275,3,994,497,0,11275,11276,3,1612,806,0,11276,11290,1,0, - 0,0,11277,11290,3,1000,500,0,11278,11290,3,926,463,0,11279,11280, - 5,202,0,0,11280,11281,3,1212,606,0,11281,11282,3,1610,805,0,11282, - 11290,1,0,0,0,11283,11284,3,1614,807,0,11284,11285,3,1212,606,0, - 11285,11286,5,24,0,0,11286,11287,3,1212,606,0,11287,11288,3,1616, - 808,0,11288,11290,1,0,0,0,11289,11274,1,0,0,0,11289,11277,1,0,0, - 0,11289,11278,1,0,0,0,11289,11279,1,0,0,0,11289,11283,1,0,0,0,11290, - 1609,1,0,0,0,11291,11295,1,0,0,0,11292,11293,5,100,0,0,11293,11295, - 3,1328,664,0,11294,11291,1,0,0,0,11294,11292,1,0,0,0,11295,1611, - 1,0,0,0,11296,11309,1,0,0,0,11297,11298,5,2,0,0,11298,11303,3,1212, - 606,0,11299,11300,5,6,0,0,11300,11302,3,1212,606,0,11301,11299,1, - 0,0,0,11302,11305,1,0,0,0,11303,11301,1,0,0,0,11303,11304,1,0,0, - 0,11304,11306,1,0,0,0,11305,11303,1,0,0,0,11306,11307,5,3,0,0,11307, - 11309,1,0,0,0,11308,11296,1,0,0,0,11308,11297,1,0,0,0,11309,1613, - 1,0,0,0,11310,11313,1,0,0,0,11311,11313,5,504,0,0,11312,11310,1, - 0,0,0,11312,11311,1,0,0,0,11313,1615,1,0,0,0,11314,11318,1,0,0,0, - 11315,11316,5,147,0,0,11316,11318,3,1212,606,0,11317,11314,1,0,0, - 0,11317,11315,1,0,0,0,11318,1617,1,0,0,0,11319,11320,3,552,276,0, - 11320,1619,1,0,0,0,11321,11322,3,1726,863,0,11322,11323,5,505,0, - 0,11323,11324,3,1618,809,0,11324,11325,3,1622,811,0,11325,11326, - 5,68,0,0,11326,11327,5,35,0,0,11327,11328,3,1212,606,0,11328,11329, - 3,1648,824,0,11329,1621,1,0,0,0,11330,11334,1,0,0,0,11331,11332, - 5,506,0,0,11332,11334,3,1456,728,0,11333,11330,1,0,0,0,11333,11331, - 1,0,0,0,11334,1623,1,0,0,0,11335,11336,3,1626,813,0,11336,11338, - 3,1728,864,0,11337,11339,3,1730,865,0,11338,11337,1,0,0,0,11338, - 11339,1,0,0,0,11339,11340,1,0,0,0,11340,11341,5,7,0,0,11341,1625, - 1,0,0,0,11342,11343,7,83,0,0,11343,1627,1,0,0,0,11344,11356,5,508, - 0,0,11345,11346,5,268,0,0,11346,11357,3,1736,868,0,11347,11353,5, - 509,0,0,11348,11349,5,202,0,0,11349,11350,3,1212,606,0,11350,11351, - 3,1610,805,0,11351,11354,1,0,0,0,11352,11354,3,1000,500,0,11353, - 11348,1,0,0,0,11353,11352,1,0,0,0,11354,11357,1,0,0,0,11355,11357, - 3,1630,815,0,11356,11345,1,0,0,0,11356,11347,1,0,0,0,11356,11355, - 1,0,0,0,11357,11358,1,0,0,0,11358,11359,5,7,0,0,11359,1629,1,0,0, - 0,11360,11363,1,0,0,0,11361,11363,3,1736,868,0,11362,11360,1,0,0, - 0,11362,11361,1,0,0,0,11363,1631,1,0,0,0,11364,11366,5,510,0,0,11365, - 11367,3,1634,817,0,11366,11365,1,0,0,0,11366,11367,1,0,0,0,11367, - 11368,1,0,0,0,11368,11369,3,1458,729,0,11369,11370,3,1636,818,0, - 11370,11371,3,1638,819,0,11371,11372,5,7,0,0,11372,11399,1,0,0,0, - 11373,11375,5,510,0,0,11374,11376,3,1634,817,0,11375,11374,1,0,0, - 0,11375,11376,1,0,0,0,11376,11377,1,0,0,0,11377,11378,3,1492,746, - 0,11378,11379,3,1638,819,0,11379,11380,5,7,0,0,11380,11399,1,0,0, - 0,11381,11383,5,510,0,0,11382,11384,3,1634,817,0,11383,11382,1,0, - 0,0,11383,11384,1,0,0,0,11384,11385,1,0,0,0,11385,11386,5,511,0, - 0,11386,11387,3,1458,729,0,11387,11388,3,1638,819,0,11388,11389, - 5,7,0,0,11389,11399,1,0,0,0,11390,11392,5,510,0,0,11391,11393,3, - 1634,817,0,11392,11391,1,0,0,0,11392,11393,1,0,0,0,11393,11394,1, - 0,0,0,11394,11395,3,1638,819,0,11395,11396,5,7,0,0,11396,11399,1, - 0,0,0,11397,11399,5,510,0,0,11398,11364,1,0,0,0,11398,11373,1,0, - 0,0,11398,11381,1,0,0,0,11398,11390,1,0,0,0,11398,11397,1,0,0,0, - 11399,1633,1,0,0,0,11400,11401,7,84,0,0,11401,1635,1,0,0,0,11402, - 11410,1,0,0,0,11403,11404,5,6,0,0,11404,11406,3,1212,606,0,11405, - 11403,1,0,0,0,11406,11407,1,0,0,0,11407,11405,1,0,0,0,11407,11408, - 1,0,0,0,11408,11410,1,0,0,0,11409,11402,1,0,0,0,11409,11405,1,0, - 0,0,11410,1637,1,0,0,0,11411,11415,1,0,0,0,11412,11413,5,100,0,0, - 11413,11415,3,1642,821,0,11414,11411,1,0,0,0,11414,11412,1,0,0,0, - 11415,1639,1,0,0,0,11416,11417,3,1492,746,0,11417,11418,5,10,0,0, - 11418,11419,3,1212,606,0,11419,1641,1,0,0,0,11420,11425,3,1640,820, - 0,11421,11422,5,6,0,0,11422,11424,3,1640,820,0,11423,11421,1,0,0, - 0,11424,11427,1,0,0,0,11425,11423,1,0,0,0,11425,11426,1,0,0,0,11426, - 1643,1,0,0,0,11427,11425,1,0,0,0,11428,11429,5,518,0,0,11429,11430, - 3,1736,868,0,11430,11431,3,1646,823,0,11431,11432,5,7,0,0,11432, - 1645,1,0,0,0,11433,11437,1,0,0,0,11434,11435,5,6,0,0,11435,11437, - 3,1736,868,0,11436,11433,1,0,0,0,11436,11434,1,0,0,0,11437,1647, - 1,0,0,0,11438,11439,5,519,0,0,11439,11440,3,1560,780,0,11440,11441, - 5,454,0,0,11441,11442,5,519,0,0,11442,11443,3,1728,864,0,11443,11444, - 5,7,0,0,11444,1649,1,0,0,0,11445,11446,3,1746,873,0,11446,11447, - 5,7,0,0,11447,1651,1,0,0,0,11448,11449,5,202,0,0,11449,11457,3,1212, - 606,0,11450,11451,3,1658,829,0,11451,11452,3,1654,827,0,11452,11458, - 1,0,0,0,11453,11454,3,1654,827,0,11454,11455,3,1658,829,0,11455, - 11458,1,0,0,0,11456,11458,1,0,0,0,11457,11450,1,0,0,0,11457,11453, - 1,0,0,0,11457,11456,1,0,0,0,11458,11459,1,0,0,0,11459,11460,5,7, - 0,0,11460,1653,1,0,0,0,11461,11465,1,0,0,0,11462,11463,5,100,0,0, - 11463,11465,3,1656,828,0,11464,11461,1,0,0,0,11464,11462,1,0,0,0, - 11465,1655,1,0,0,0,11466,11471,3,1212,606,0,11467,11468,5,6,0,0, - 11468,11470,3,1212,606,0,11469,11467,1,0,0,0,11470,11473,1,0,0,0, - 11471,11469,1,0,0,0,11471,11472,1,0,0,0,11472,1657,1,0,0,0,11473, - 11471,1,0,0,0,11474,11481,1,0,0,0,11475,11477,5,71,0,0,11476,11478, - 5,346,0,0,11477,11476,1,0,0,0,11477,11478,1,0,0,0,11478,11479,1, - 0,0,0,11479,11481,3,1674,837,0,11480,11474,1,0,0,0,11480,11475,1, - 0,0,0,11481,1659,1,0,0,0,11482,11500,5,520,0,0,11483,11484,3,1712, - 856,0,11484,11485,3,1668,834,0,11485,11491,5,62,0,0,11486,11492, - 3,1000,500,0,11487,11488,5,202,0,0,11488,11489,3,1736,868,0,11489, - 11490,3,1666,833,0,11490,11492,1,0,0,0,11491,11486,1,0,0,0,11491, - 11487,1,0,0,0,11492,11501,1,0,0,0,11493,11498,3,1474,737,0,11494, - 11495,5,2,0,0,11495,11496,3,1664,832,0,11496,11497,5,3,0,0,11497, - 11499,1,0,0,0,11498,11494,1,0,0,0,11498,11499,1,0,0,0,11499,11501, - 1,0,0,0,11500,11483,1,0,0,0,11500,11493,1,0,0,0,11501,11502,1,0, - 0,0,11502,11503,5,7,0,0,11503,1661,1,0,0,0,11504,11505,3,1474,737, - 0,11505,11506,5,20,0,0,11506,11507,3,1212,606,0,11507,11510,1,0, - 0,0,11508,11510,3,1212,606,0,11509,11504,1,0,0,0,11509,11508,1,0, - 0,0,11510,1663,1,0,0,0,11511,11516,3,1662,831,0,11512,11513,5,6, - 0,0,11513,11515,3,1662,831,0,11514,11512,1,0,0,0,11515,11518,1,0, - 0,0,11516,11514,1,0,0,0,11516,11517,1,0,0,0,11517,1665,1,0,0,0,11518, - 11516,1,0,0,0,11519,11523,1,0,0,0,11520,11521,5,100,0,0,11521,11523, - 3,1328,664,0,11522,11519,1,0,0,0,11522,11520,1,0,0,0,11523,1667, - 1,0,0,0,11524,11529,1,0,0,0,11525,11526,3,1670,835,0,11526,11527, - 5,324,0,0,11527,11529,1,0,0,0,11528,11524,1,0,0,0,11528,11525,1, - 0,0,0,11529,1669,1,0,0,0,11530,11533,1,0,0,0,11531,11533,5,269,0, - 0,11532,11530,1,0,0,0,11532,11531,1,0,0,0,11533,1671,1,0,0,0,11534, - 11536,5,61,0,0,11535,11537,3,1678,839,0,11536,11535,1,0,0,0,11536, - 11537,1,0,0,0,11537,11538,1,0,0,0,11538,11539,3,1676,838,0,11539, - 11540,3,1712,856,0,11540,11541,5,71,0,0,11541,11542,3,1674,837,0, - 11542,11543,5,7,0,0,11543,1673,1,0,0,0,11544,11545,3,1328,664,0, - 11545,1675,1,0,0,0,11546,11550,1,0,0,0,11547,11550,5,64,0,0,11548, - 11550,5,68,0,0,11549,11546,1,0,0,0,11549,11547,1,0,0,0,11549,11548, - 1,0,0,0,11550,1677,1,0,0,0,11551,11567,5,268,0,0,11552,11567,5,293, - 0,0,11553,11567,5,207,0,0,11554,11567,5,249,0,0,11555,11556,5,130, - 0,0,11556,11567,3,1212,606,0,11557,11558,5,307,0,0,11558,11567,3, - 1212,606,0,11559,11567,3,1212,606,0,11560,11567,5,30,0,0,11561,11564, - 7,85,0,0,11562,11565,3,1212,606,0,11563,11565,5,30,0,0,11564,11562, - 1,0,0,0,11564,11563,1,0,0,0,11564,11565,1,0,0,0,11565,11567,1,0, - 0,0,11566,11551,1,0,0,0,11566,11552,1,0,0,0,11566,11553,1,0,0,0, - 11566,11554,1,0,0,0,11566,11555,1,0,0,0,11566,11557,1,0,0,0,11566, - 11559,1,0,0,0,11566,11560,1,0,0,0,11566,11561,1,0,0,0,11567,1679, - 1,0,0,0,11568,11570,5,265,0,0,11569,11571,3,1678,839,0,11570,11569, - 1,0,0,0,11570,11571,1,0,0,0,11571,11572,1,0,0,0,11572,11573,3,1712, - 856,0,11573,11574,5,7,0,0,11574,1681,1,0,0,0,11575,11577,3,1014, - 507,0,11576,11575,1,0,0,0,11576,11577,1,0,0,0,11577,11578,1,0,0, - 0,11578,11579,5,525,0,0,11579,11581,5,71,0,0,11580,11582,5,81,0, - 0,11581,11580,1,0,0,0,11581,11582,1,0,0,0,11582,11583,1,0,0,0,11583, - 11585,3,1406,703,0,11584,11586,5,9,0,0,11585,11584,1,0,0,0,11585, - 11586,1,0,0,0,11586,11591,1,0,0,0,11587,11589,5,36,0,0,11588,11587, - 1,0,0,0,11588,11589,1,0,0,0,11589,11590,1,0,0,0,11590,11592,3,1474, - 737,0,11591,11588,1,0,0,0,11591,11592,1,0,0,0,11592,11593,1,0,0, - 0,11593,11594,5,100,0,0,11594,11595,3,1684,842,0,11595,11596,5,80, - 0,0,11596,11598,3,1686,843,0,11597,11599,3,1688,844,0,11598,11597, - 1,0,0,0,11599,11600,1,0,0,0,11600,11598,1,0,0,0,11600,11601,1,0, - 0,0,11601,1683,1,0,0,0,11602,11604,5,81,0,0,11603,11602,1,0,0,0, - 11603,11604,1,0,0,0,11604,11605,1,0,0,0,11605,11607,3,1406,703,0, - 11606,11608,5,9,0,0,11607,11606,1,0,0,0,11607,11608,1,0,0,0,11608, - 11614,1,0,0,0,11609,11612,3,1004,502,0,11610,11612,3,1100,550,0, - 11611,11609,1,0,0,0,11611,11610,1,0,0,0,11612,11614,1,0,0,0,11613, - 11603,1,0,0,0,11613,11611,1,0,0,0,11614,11619,1,0,0,0,11615,11617, - 5,36,0,0,11616,11615,1,0,0,0,11616,11617,1,0,0,0,11617,11618,1,0, - 0,0,11618,11620,3,1474,737,0,11619,11616,1,0,0,0,11619,11620,1,0, - 0,0,11620,1685,1,0,0,0,11621,11622,3,1212,606,0,11622,1687,1,0,0, - 0,11623,11624,5,102,0,0,11624,11627,5,526,0,0,11625,11626,5,33,0, - 0,11626,11628,3,1212,606,0,11627,11625,1,0,0,0,11627,11628,1,0,0, - 0,11628,11629,1,0,0,0,11629,11634,5,93,0,0,11630,11635,3,1692,846, - 0,11631,11635,5,182,0,0,11632,11633,5,57,0,0,11633,11635,5,270,0, - 0,11634,11630,1,0,0,0,11634,11631,1,0,0,0,11634,11632,1,0,0,0,11635, - 11650,1,0,0,0,11636,11637,5,102,0,0,11637,11638,5,77,0,0,11638,11641, - 5,526,0,0,11639,11640,5,33,0,0,11640,11642,3,1212,606,0,11641,11639, - 1,0,0,0,11641,11642,1,0,0,0,11642,11643,1,0,0,0,11643,11647,5,93, - 0,0,11644,11648,3,1690,845,0,11645,11646,5,57,0,0,11646,11648,5, - 270,0,0,11647,11644,1,0,0,0,11647,11645,1,0,0,0,11648,11650,1,0, - 0,0,11649,11623,1,0,0,0,11649,11636,1,0,0,0,11650,1689,1,0,0,0,11651, - 11656,5,241,0,0,11652,11653,5,2,0,0,11653,11654,3,244,122,0,11654, - 11655,5,3,0,0,11655,11657,1,0,0,0,11656,11652,1,0,0,0,11656,11657, - 1,0,0,0,11657,11661,1,0,0,0,11658,11659,5,463,0,0,11659,11660,7, - 53,0,0,11660,11662,5,450,0,0,11661,11658,1,0,0,0,11661,11662,1,0, - 0,0,11662,11663,1,0,0,0,11663,11664,3,1694,847,0,11664,1691,1,0, - 0,0,11665,11666,5,369,0,0,11666,11679,5,333,0,0,11667,11668,3,1432, - 716,0,11668,11669,5,10,0,0,11669,11670,3,1698,849,0,11670,11680, - 1,0,0,0,11671,11672,5,2,0,0,11672,11673,3,244,122,0,11673,11674, - 5,3,0,0,11674,11675,5,10,0,0,11675,11676,5,2,0,0,11676,11677,3,1696, - 848,0,11677,11678,5,3,0,0,11678,11680,1,0,0,0,11679,11667,1,0,0, - 0,11679,11671,1,0,0,0,11680,11681,1,0,0,0,11681,11679,1,0,0,0,11681, - 11682,1,0,0,0,11682,1693,1,0,0,0,11683,11684,5,422,0,0,11684,11688, - 3,1696,848,0,11685,11686,5,53,0,0,11686,11688,5,422,0,0,11687,11683, - 1,0,0,0,11687,11685,1,0,0,0,11688,1695,1,0,0,0,11689,11690,5,2,0, - 0,11690,11695,3,1698,849,0,11691,11692,5,6,0,0,11692,11694,3,1698, - 849,0,11693,11691,1,0,0,0,11694,11697,1,0,0,0,11695,11693,1,0,0, - 0,11695,11696,1,0,0,0,11696,11698,1,0,0,0,11697,11695,1,0,0,0,11698, - 11699,5,3,0,0,11699,1697,1,0,0,0,11700,11703,3,1048,524,0,11701, - 11703,5,53,0,0,11702,11700,1,0,0,0,11702,11701,1,0,0,0,11703,1699, - 1,0,0,0,11704,11705,5,157,0,0,11705,11706,3,1712,856,0,11706,11707, - 5,7,0,0,11707,1701,1,0,0,0,11708,11709,5,78,0,0,11709,11710,5,7, - 0,0,11710,1703,1,0,0,0,11711,11713,5,161,0,0,11712,11714,3,1708, - 854,0,11713,11712,1,0,0,0,11713,11714,1,0,0,0,11714,11715,1,0,0, - 0,11715,11716,5,7,0,0,11716,1705,1,0,0,0,11717,11719,5,319,0,0,11718, - 11720,3,1708,854,0,11719,11718,1,0,0,0,11719,11720,1,0,0,0,11720, - 11721,1,0,0,0,11721,11722,5,7,0,0,11722,1707,1,0,0,0,11723,11725, - 5,33,0,0,11724,11726,5,269,0,0,11725,11724,1,0,0,0,11725,11726,1, - 0,0,0,11726,11727,1,0,0,0,11727,11728,5,153,0,0,11728,1709,1,0,0, - 0,11729,11730,5,333,0,0,11730,11731,3,558,279,0,11731,11732,5,94, - 0,0,11732,11733,5,53,0,0,11733,11734,5,7,0,0,11734,11742,1,0,0,0, - 11735,11738,5,313,0,0,11736,11739,3,558,279,0,11737,11739,5,30,0, - 0,11738,11736,1,0,0,0,11738,11737,1,0,0,0,11739,11740,1,0,0,0,11740, - 11742,5,7,0,0,11741,11729,1,0,0,0,11741,11735,1,0,0,0,11742,1711, - 1,0,0,0,11743,11746,3,1474,737,0,11744,11746,5,28,0,0,11745,11743, - 1,0,0,0,11745,11744,1,0,0,0,11746,1713,1,0,0,0,11747,11751,1,0,0, - 0,11748,11749,5,517,0,0,11749,11751,3,1716,858,0,11750,11747,1,0, - 0,0,11750,11748,1,0,0,0,11751,1715,1,0,0,0,11752,11754,3,1718,859, - 0,11753,11752,1,0,0,0,11754,11755,1,0,0,0,11755,11753,1,0,0,0,11755, - 11756,1,0,0,0,11756,1717,1,0,0,0,11757,11758,5,102,0,0,11758,11759, - 3,1720,860,0,11759,11760,5,93,0,0,11760,11761,3,1560,780,0,11761, - 1719,1,0,0,0,11762,11767,3,1722,861,0,11763,11764,5,82,0,0,11764, - 11766,3,1722,861,0,11765,11763,1,0,0,0,11766,11769,1,0,0,0,11767, - 11765,1,0,0,0,11767,11768,1,0,0,0,11768,1721,1,0,0,0,11769,11767, - 1,0,0,0,11770,11774,3,1732,866,0,11771,11772,5,511,0,0,11772,11774, - 3,1458,729,0,11773,11770,1,0,0,0,11773,11771,1,0,0,0,11774,1723, - 1,0,0,0,11775,11778,1,0,0,0,11776,11778,3,1524,762,0,11777,11775, - 1,0,0,0,11777,11776,1,0,0,0,11778,1725,1,0,0,0,11779,11782,1,0,0, - 0,11780,11782,3,1524,762,0,11781,11779,1,0,0,0,11781,11780,1,0,0, - 0,11782,1727,1,0,0,0,11783,11786,1,0,0,0,11784,11786,3,1732,866, - 0,11785,11783,1,0,0,0,11785,11784,1,0,0,0,11786,1729,1,0,0,0,11787, - 11788,5,102,0,0,11788,11789,3,1740,870,0,11789,1731,1,0,0,0,11790, - 11793,3,1474,737,0,11791,11793,3,1734,867,0,11792,11790,1,0,0,0, - 11792,11791,1,0,0,0,11793,1733,1,0,0,0,11794,11795,7,86,0,0,11795, - 1735,1,0,0,0,11796,11798,3,1384,692,0,11797,11796,1,0,0,0,11797, - 11798,1,0,0,0,11798,11800,1,0,0,0,11799,11801,3,1028,514,0,11800, - 11799,1,0,0,0,11800,11801,1,0,0,0,11801,11803,1,0,0,0,11802,11804, - 3,1102,551,0,11803,11802,1,0,0,0,11803,11804,1,0,0,0,11804,11806, - 1,0,0,0,11805,11807,3,1144,572,0,11806,11805,1,0,0,0,11806,11807, - 1,0,0,0,11807,11809,1,0,0,0,11808,11810,3,1072,536,0,11809,11808, - 1,0,0,0,11809,11810,1,0,0,0,11810,11812,1,0,0,0,11811,11813,3,1086, - 543,0,11812,11811,1,0,0,0,11812,11813,1,0,0,0,11813,11815,1,0,0, - 0,11814,11816,3,1288,644,0,11815,11814,1,0,0,0,11815,11816,1,0,0, - 0,11816,1737,1,0,0,0,11817,11818,3,1736,868,0,11818,1739,1,0,0,0, - 11819,11820,3,1736,868,0,11820,1741,1,0,0,0,11821,11822,3,1212,606, - 0,11822,1743,1,0,0,0,11823,11824,3,1212,606,0,11824,1745,1,0,0,0, - 11825,11827,3,6,3,0,11826,11828,3,1748,874,0,11827,11826,1,0,0,0, - 11827,11828,1,0,0,0,11828,1747,1,0,0,0,11829,11830,5,71,0,0,11830, - 11831,3,1030,515,0,11831,11832,3,1674,837,0,11832,1749,1,0,0,0,1282, - 1753,1762,1881,1885,1894,1903,1909,1915,1947,1959,1965,1973,1981, - 1987,1996,2002,2014,2020,2026,2033,2037,2042,2046,2059,2070,2076, - 2092,2095,2100,2106,2111,2120,2124,2136,2140,2143,2147,2158,2176, - 2183,2191,2196,2203,2209,2215,2222,2233,2237,2241,2245,2258,2262, - 2267,2272,2284,2293,2305,2310,2321,2327,2332,2342,2347,2354,2359, - 2364,2375,2381,2386,2394,2403,2418,2424,2430,2435,2442,2454,2462, - 2470,2488,2497,2511,2515,2530,2538,2548,2588,2591,2595,2599,2602, - 2607,2614,2623,2629,2633,2642,2650,2659,2668,2672,2679,2685,2689, - 2693,2698,2701,2705,2711,2718,2734,2748,2758,2760,2765,2769,2772, - 2778,2780,2808,2818,2831,2838,2843,2847,2853,2858,2861,2863,2868, - 2872,2876,2880,2884,2887,2891,2899,2903,2907,2916,2923,2928,2935, - 2940,2947,2952,2970,2975,2987,2992,3001,3008,3015,3019,3024,3028, - 3031,3034,3037,3040,3043,3048,3051,3054,3057,3060,3063,3069,3073, - 3076,3079,3082,3085,3087,3096,3111,3119,3125,3129,3134,3137,3140, - 3144,3148,3162,3167,3174,3179,3183,3186,3190,3193,3195,3202,3205, - 3209,3215,3218,3225,3234,3241,3246,3249,3252,3255,3259,3266,3271, - 3284,3294,3307,3310,3313,3320,3328,3331,3334,3341,3345,3351,3354, - 3357,3360,3372,3375,3378,3382,3400,3408,3424,3435,3450,3467,3469, - 3490,3495,3498,3502,3505,3511,3514,3516,3527,3536,3542,3545,3548, - 3562,3565,3568,3573,3581,3590,3594,3600,3604,3607,3610,3613,3616, - 3622,3626,3631,3637,3641,3644,3647,3650,3658,3662,3666,3670,3674, - 3679,3693,3702,3719,3724,3727,3729,3739,3746,3751,3754,3757,3764, - 3767,3769,3775,3784,3794,3799,3807,3811,3818,3828,3839,3947,3955, - 3958,3968,3973,3983,3994,4006,4019,4029,4041,4045,4048,4055,4063, - 4073,4075,4081,4086,4090,4095,4101,4108,4114,4116,4123,4131,4136, - 4147,4154,4158,4175,4178,4181,4184,4187,4195,4198,4201,4207,4215, - 4219,4231,4237,4240,4245,4249,4256,4267,4290,4310,4319,4322,4325, - 4335,4338,4347,4351,4354,4362,4368,4372,4383,4393,4401,4406,4418, - 4435,4439,4445,4452,4460,4474,4500,4507,4521,4532,4535,4548,4557, - 4582,4593,4635,4643,4649,4660,4666,4674,4685,4699,4708,4713,4724, - 4735,4743,4753,4760,4763,4769,4772,4787,4800,4829,4836,4851,4863, - 4867,4872,4876,4881,4885,4891,4895,4900,4904,4910,4914,4919,4923, - 4928,4932,4937,4941,4948,4952,4959,4963,4970,4974,4981,4985,4991, - 4995,5001,5005,5010,5014,5021,5025,5029,5033,5037,5042,5046,5051, - 5055,5060,5064,5069,5075,5080,5086,5091,5097,5102,5106,5111,5115, - 5121,5125,5130,5138,5144,5150,5156,5162,5169,5174,5178,5183,5187, - 5192,5198,5205,5210,5217,5227,5231,5237,5239,5246,5250,5255,5273, - 5288,5306,5315,5324,5328,5334,5341,5346,5353,5358,5361,5364,5368, - 5439,5535,5539,5544,5555,5566,5577,5588,5599,5611,5622,5633,5643, - 5650,5657,5663,5671,5676,5681,5686,5692,5699,5705,5711,5716,5722, - 5729,5734,5740,5747,5750,5763,5772,5784,5786,5804,5811,5821,5826, - 5830,5834,5838,5840,5900,5907,5913,5924,5927,5934,5937,5947,5950, - 5952,5971,5983,5992,6001,6013,6015,6021,6025,6028,6031,6036,6042, - 6045,6048,6051,6054,6070,6074,6077,6080,6083,6086,6091,6094,6096, - 6109,6121,6135,6139,6145,6155,6157,6162,6170,6180,6189,6197,6206, - 6208,6215,6224,6226,6233,6242,6244,6248,6257,6262,6268,6273,6277, - 6282,6300,6305,6320,6329,6340,6346,6383,6403,6410,6421,6435,6442, - 6450,6455,6462,6466,6471,6475,6480,6484,6486,6491,6495,6500,6504, - 6528,6535,6545,6557,6562,6575,6587,6599,6601,6607,6614,6659,6677, - 6681,6686,6689,6693,6698,6703,6706,6713,6730,6801,6832,6886,6896, - 6906,6917,6927,6938,6948,6953,6962,6967,6977,6982,6991,7004,7009, - 7121,7123,7132,7143,7154,7167,7179,7190,7197,7287,7340,7350,7361, - 7372,7386,7401,7412,7419,7473,7614,7620,7623,7633,7673,7683,7690, - 7713,7722,7731,7740,7773,7777,7787,7791,7801,7804,7808,7812,7820, - 7831,7843,7847,7850,7854,7857,7862,7866,7869,7875,7886,7889,7896, - 7900,7905,7908,7910,7924,7928,7933,7940,7947,7950,7955,7958,7967, - 7969,7974,7978,7990,7993,8000,8004,8009,8019,8029,8032,8035,8037, - 8043,8050,8070,8090,8094,8099,8168,8173,8179,8192,8196,8200,8206, - 8208,8216,8226,8229,8232,8235,8238,8245,8248,8250,8254,8257,8264, - 8266,8273,8280,8284,8288,8297,8303,8307,8311,8316,8328,8335,8345, - 8358,8369,8376,8381,8385,8389,8394,8407,8412,8416,8420,8427,8430, - 8432,8440,8444,8447,8454,8457,8462,8468,8474,8478,8487,8496,8503, - 8506,8512,8517,8523,8529,8532,8535,8542,8546,8549,8564,8567,8574, - 8577,8584,8587,8590,8597,8609,8616,8618,8628,8646,8648,8656,8660, - 8670,8674,8678,8682,8684,8689,8693,8697,8699,8701,8705,8709,8712, - 8715,8718,8721,8723,8726,8729,8732,8735,8738,8741,8750,8752,8757, - 8761,8767,8771,8775,8784,8789,8793,8799,8802,8821,8829,8838,8842, - 8845,8849,8854,8860,8872,8887,8894,8897,8901,8905,8909,8911,8919, - 8928,8934,8936,8943,8947,8956,8960,8969,8978,8990,9018,9025,9029, - 9032,9037,9041,9044,9060,9071,9076,9079,9082,9086,9090,9094,9099, - 9103,9107,9109,9118,9123,9129,9133,9135,9142,9147,9153,9155,9159, - 9166,9173,9176,9182,9186,9195,9198,9202,9210,9216,9218,9221,9225, - 9228,9231,9235,9239,9245,9248,9257,9264,9266,9273,9281,9286,9289, - 9297,9306,9314,9316,9320,9327,9346,9355,9361,9380,9389,9395,9399, - 9404,9414,9421,9430,9433,9442,9444,9450,9454,9459,9469,9475,9477, - 9483,9487,9490,9503,9509,9513,9517,9520,9528,9532,9536,9544,9551, - 9558,9562,9568,9570,9579,9582,9592,9608,9614,9619,9626,9635,9642, - 9650,9658,9663,9667,9670,9676,9681,9697,9700,9702,9714,9716,9720, - 9728,9730,9734,9736,9744,9748,9757,9765,9771,9774,9783,9788,9795, - 9805,9831,9842,9844,9846,9854,9876,9885,9895,9898,9903,9908,9912, - 9915,9919,9922,9925,9928,9932,9946,9953,9960,9967,9985,9993,10005, - 10011,10024,10063,10065,10085,10095,10106,10118,10125,10137,10149, - 10155,10163,10180,10205,10215,10219,10222,10225,10228,10241,10246, - 10251,10253,10261,10270,10279,10284,10293,10298,10312,10322,10330, - 10344,10351,10359,10367,10375,10379,10386,10394,10401,10407,10416, - 10431,10442,10475,10484,10491,10495,10499,10506,10520,10525,10530, - 10534,10536,10539,10546,10551,10561,10569,10572,10579,10587,10595, - 10603,10611,10616,10620,10624,10628,10632,10636,10640,10647,10655, - 10660,10664,10668,10678,10684,10690,10694,10708,10714,10720,10732, - 10737,10745,10752,10757,10769,10777,10782,10792,10803,10810,10817, - 10828,10831,10833,10837,10840,10846,10852,10856,10862,10870,10874, - 10882,10939,10952,10975,10983,10987,10999,11001,11008,11017,11035, - 11043,11052,11059,11069,11075,11082,11087,11093,11097,11104,11134, - 11147,11156,11160,11176,11183,11196,11204,11224,11230,11242,11247, - 11257,11289,11294,11303,11308,11312,11317,11333,11338,11353,11356, - 11362,11366,11375,11383,11392,11398,11407,11409,11414,11425,11436, - 11457,11464,11471,11477,11480,11491,11498,11500,11509,11516,11522, - 11528,11532,11536,11549,11564,11566,11570,11576,11581,11585,11588, - 11591,11600,11603,11607,11611,11613,11616,11619,11627,11634,11641, - 11647,11649,11656,11661,11679,11681,11687,11695,11702,11713,11719, - 11725,11738,11741,11745,11750,11755,11767,11773,11777,11781,11785, - 11792,11797,11800,11803,11806,11809,11812,11815,11827 - ]; - - private static __ATN: antlr.ATN; - public static get _ATN(): antlr.ATN { - if (!PostgreSqlParser.__ATN) { - PostgreSqlParser.__ATN = new antlr.ATNDeserializer().deserialize(PostgreSqlParser._serializedATN); - } - - return PostgreSqlParser.__ATN; - } - - - private static readonly vocabulary = new antlr.Vocabulary(PostgreSqlParser.literalNames, PostgreSqlParser.symbolicNames, []); - - public override get vocabulary(): antlr.Vocabulary { - return PostgreSqlParser.vocabulary; - } - - private static readonly decisionsToDFA = PostgreSqlParser._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) ); -} - -export class ProgramContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public EOF(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.EOF, 0)!; - } - public singleStmt(): SingleStmtContext[]; - public singleStmt(i: number): SingleStmtContext | null; - public singleStmt(i?: number): SingleStmtContext[] | SingleStmtContext | null { - if (i === undefined) { - return this.getRuleContexts(SingleStmtContext); - } - - return this.getRuleContext(i, SingleStmtContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_program; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterProgram) { - listener.enterProgram(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitProgram) { - listener.exitProgram(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitProgram) { - return visitor.visitProgram(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class PlsqlrootContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public pl_function(): Pl_functionContext { - return this.getRuleContext(0, Pl_functionContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_plsqlroot; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPlsqlroot) { - listener.enterPlsqlroot(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPlsqlroot) { - listener.exitPlsqlroot(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPlsqlroot) { - return visitor.visitPlsqlroot(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class SingleStmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public stmt(): StmtContext { - return this.getRuleContext(0, StmtContext)!; - } - public SEMI(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.SEMI, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_singleStmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSingleStmt) { - listener.enterSingleStmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSingleStmt) { - listener.exitSingleStmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSingleStmt) { - return visitor.visitSingleStmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class StmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public altereventtrigstmt(): AltereventtrigstmtContext | null { - return this.getRuleContext(0, AltereventtrigstmtContext); - } - public altercollationstmt(): AltercollationstmtContext | null { - return this.getRuleContext(0, AltercollationstmtContext); - } - public alterdatabasestmt(): AlterdatabasestmtContext | null { - return this.getRuleContext(0, AlterdatabasestmtContext); - } - public alterdatabasesetstmt(): AlterdatabasesetstmtContext | null { - return this.getRuleContext(0, AlterdatabasesetstmtContext); - } - public alterdefaultprivilegesstmt(): AlterdefaultprivilegesstmtContext | null { - return this.getRuleContext(0, AlterdefaultprivilegesstmtContext); - } - public alterdomainstmt(): AlterdomainstmtContext | null { - return this.getRuleContext(0, AlterdomainstmtContext); - } - public alterenumstmt(): AlterenumstmtContext | null { - return this.getRuleContext(0, AlterenumstmtContext); - } - public alterextensionstmt(): AlterextensionstmtContext | null { - return this.getRuleContext(0, AlterextensionstmtContext); - } - public alterextensioncontentsstmt(): AlterextensioncontentsstmtContext | null { - return this.getRuleContext(0, AlterextensioncontentsstmtContext); - } - public alterfdwstmt(): AlterfdwstmtContext | null { - return this.getRuleContext(0, AlterfdwstmtContext); - } - public alterforeignserverstmt(): AlterforeignserverstmtContext | null { - return this.getRuleContext(0, AlterforeignserverstmtContext); - } - public alterfunctionstmt(): AlterfunctionstmtContext | null { - return this.getRuleContext(0, AlterfunctionstmtContext); - } - public altergroupstmt(): AltergroupstmtContext | null { - return this.getRuleContext(0, AltergroupstmtContext); - } - public alterobjectdependsstmt(): AlterobjectdependsstmtContext | null { - return this.getRuleContext(0, AlterobjectdependsstmtContext); - } - public alterobjectschemastmt(): AlterobjectschemastmtContext | null { - return this.getRuleContext(0, AlterobjectschemastmtContext); - } - public alterownerstmt(): AlterownerstmtContext | null { - return this.getRuleContext(0, AlterownerstmtContext); - } - public alteroperatorstmt(): AlteroperatorstmtContext | null { - return this.getRuleContext(0, AlteroperatorstmtContext); - } - public altertypestmt(): AltertypestmtContext | null { - return this.getRuleContext(0, AltertypestmtContext); - } - public alterpolicystmt(): AlterpolicystmtContext | null { - return this.getRuleContext(0, AlterpolicystmtContext); - } - public alterprocedurestmt(): AlterprocedurestmtContext | null { - return this.getRuleContext(0, AlterprocedurestmtContext); - } - public alterseqstmt(): AlterseqstmtContext | null { - return this.getRuleContext(0, AlterseqstmtContext); - } - public altersystemstmt(): AltersystemstmtContext | null { - return this.getRuleContext(0, AltersystemstmtContext); - } - public altertablestmt(): AltertablestmtContext | null { - return this.getRuleContext(0, AltertablestmtContext); - } - public altertblspcstmt(): AltertblspcstmtContext | null { - return this.getRuleContext(0, AltertblspcstmtContext); - } - public altercompositetypestmt(): AltercompositetypestmtContext | null { - return this.getRuleContext(0, AltercompositetypestmtContext); - } - public alterpublicationstmt(): AlterpublicationstmtContext | null { - return this.getRuleContext(0, AlterpublicationstmtContext); - } - public alterrolesetstmt(): AlterrolesetstmtContext | null { - return this.getRuleContext(0, AlterrolesetstmtContext); - } - public alterroutinestmt(): AlterroutinestmtContext | null { - return this.getRuleContext(0, AlterroutinestmtContext); - } - public alterrolestmt(): AlterrolestmtContext | null { - return this.getRuleContext(0, AlterrolestmtContext); - } - public altersubscriptionstmt(): AltersubscriptionstmtContext | null { - return this.getRuleContext(0, AltersubscriptionstmtContext); - } - public alterstatsstmt(): AlterstatsstmtContext | null { - return this.getRuleContext(0, AlterstatsstmtContext); - } - public altertsconfigurationstmt(): AltertsconfigurationstmtContext | null { - return this.getRuleContext(0, AltertsconfigurationstmtContext); - } - public altertsdictionarystmt(): AltertsdictionarystmtContext | null { - return this.getRuleContext(0, AltertsdictionarystmtContext); - } - public alterusermappingstmt(): AlterusermappingstmtContext | null { - return this.getRuleContext(0, AlterusermappingstmtContext); - } - public analyzestmt(): AnalyzestmtContext | null { - return this.getRuleContext(0, AnalyzestmtContext); - } - public callstmt(): CallstmtContext | null { - return this.getRuleContext(0, CallstmtContext); - } - public checkpointstmt(): CheckpointstmtContext | null { - return this.getRuleContext(0, CheckpointstmtContext); - } - public closeportalstmt(): CloseportalstmtContext | null { - return this.getRuleContext(0, CloseportalstmtContext); - } - public clusterstmt(): ClusterstmtContext | null { - return this.getRuleContext(0, ClusterstmtContext); - } - public commentstmt(): CommentstmtContext | null { - return this.getRuleContext(0, CommentstmtContext); - } - public constraintssetstmt(): ConstraintssetstmtContext | null { - return this.getRuleContext(0, ConstraintssetstmtContext); - } - public copystmt(): CopystmtContext | null { - return this.getRuleContext(0, CopystmtContext); - } - public createamstmt(): CreateamstmtContext | null { - return this.getRuleContext(0, CreateamstmtContext); - } - public createasstmt(): CreateasstmtContext | null { - return this.getRuleContext(0, CreateasstmtContext); - } - public createassertionstmt(): CreateassertionstmtContext | null { - return this.getRuleContext(0, CreateassertionstmtContext); - } - public createcaststmt(): CreatecaststmtContext | null { - return this.getRuleContext(0, CreatecaststmtContext); - } - public createconversionstmt(): CreateconversionstmtContext | null { - return this.getRuleContext(0, CreateconversionstmtContext); - } - public createdomainstmt(): CreatedomainstmtContext | null { - return this.getRuleContext(0, CreatedomainstmtContext); - } - public createextensionstmt(): CreateextensionstmtContext | null { - return this.getRuleContext(0, CreateextensionstmtContext); - } - public createfdwstmt(): CreatefdwstmtContext | null { - return this.getRuleContext(0, CreatefdwstmtContext); - } - public createforeignserverstmt(): CreateforeignserverstmtContext | null { - return this.getRuleContext(0, CreateforeignserverstmtContext); - } - public createforeigntablestmt(): CreateforeigntablestmtContext | null { - return this.getRuleContext(0, CreateforeigntablestmtContext); - } - public createfunctionstmt(): CreatefunctionstmtContext | null { - return this.getRuleContext(0, CreatefunctionstmtContext); - } - public creategroupstmt(): CreategroupstmtContext | null { - return this.getRuleContext(0, CreategroupstmtContext); - } - public creatematviewstmt(): CreatematviewstmtContext | null { - return this.getRuleContext(0, CreatematviewstmtContext); - } - public createopclassstmt(): CreateopclassstmtContext | null { - return this.getRuleContext(0, CreateopclassstmtContext); - } - public createopfamilystmt(): CreateopfamilystmtContext | null { - return this.getRuleContext(0, CreateopfamilystmtContext); - } - public createpublicationstmt(): CreatepublicationstmtContext | null { - return this.getRuleContext(0, CreatepublicationstmtContext); - } - public alteropfamilystmt(): AlteropfamilystmtContext | null { - return this.getRuleContext(0, AlteropfamilystmtContext); - } - public createpolicystmt(): CreatepolicystmtContext | null { - return this.getRuleContext(0, CreatepolicystmtContext); - } - public createplangstmt(): CreateplangstmtContext | null { - return this.getRuleContext(0, CreateplangstmtContext); - } - public createschemastmt(): CreateschemastmtContext | null { - return this.getRuleContext(0, CreateschemastmtContext); - } - public createseqstmt(): CreateseqstmtContext | null { - return this.getRuleContext(0, CreateseqstmtContext); - } - public createstmt(): CreatestmtContext | null { - return this.getRuleContext(0, CreatestmtContext); - } - public createsubscriptionstmt(): CreatesubscriptionstmtContext | null { - return this.getRuleContext(0, CreatesubscriptionstmtContext); - } - public createstatsstmt(): CreatestatsstmtContext | null { - return this.getRuleContext(0, CreatestatsstmtContext); - } - public createtablespacestmt(): CreatetablespacestmtContext | null { - return this.getRuleContext(0, CreatetablespacestmtContext); - } - public createtransformstmt(): CreatetransformstmtContext | null { - return this.getRuleContext(0, CreatetransformstmtContext); - } - public createtrigstmt(): CreatetrigstmtContext | null { - return this.getRuleContext(0, CreatetrigstmtContext); - } - public createeventtrigstmt(): CreateeventtrigstmtContext | null { - return this.getRuleContext(0, CreateeventtrigstmtContext); - } - public createrolestmt(): CreaterolestmtContext | null { - return this.getRuleContext(0, CreaterolestmtContext); - } - public createuserstmt(): CreateuserstmtContext | null { - return this.getRuleContext(0, CreateuserstmtContext); - } - public createusermappingstmt(): CreateusermappingstmtContext | null { - return this.getRuleContext(0, CreateusermappingstmtContext); - } - public createdbstmt(): CreatedbstmtContext | null { - return this.getRuleContext(0, CreatedbstmtContext); - } - public deallocatestmt(): DeallocatestmtContext | null { - return this.getRuleContext(0, DeallocatestmtContext); - } - public declarecursorstmt(): DeclarecursorstmtContext | null { - return this.getRuleContext(0, DeclarecursorstmtContext); - } - public definestmt(): DefinestmtContext | null { - return this.getRuleContext(0, DefinestmtContext); - } - public deletestmt(): DeletestmtContext | null { - return this.getRuleContext(0, DeletestmtContext); - } - public discardstmt(): DiscardstmtContext | null { - return this.getRuleContext(0, DiscardstmtContext); - } - public dostmt(): DostmtContext | null { - return this.getRuleContext(0, DostmtContext); - } - public dropstmt(): DropstmtContext | null { - return this.getRuleContext(0, DropstmtContext); - } - public executestmt(): ExecutestmtContext | null { - return this.getRuleContext(0, ExecutestmtContext); - } - public explainstmt(): ExplainstmtContext | null { - return this.getRuleContext(0, ExplainstmtContext); - } - public fetchstmt(): FetchstmtContext | null { - return this.getRuleContext(0, FetchstmtContext); - } - public grantstmt(): GrantstmtContext | null { - return this.getRuleContext(0, GrantstmtContext); - } - public grantrolestmt(): GrantrolestmtContext | null { - return this.getRuleContext(0, GrantrolestmtContext); - } - public mergestmt(): MergestmtContext | null { - return this.getRuleContext(0, MergestmtContext); - } - public importforeignschemastmt(): ImportforeignschemastmtContext | null { - return this.getRuleContext(0, ImportforeignschemastmtContext); - } - public indexstmt(): IndexstmtContext | null { - return this.getRuleContext(0, IndexstmtContext); - } - public insertstmt(): InsertstmtContext | null { - return this.getRuleContext(0, InsertstmtContext); - } - public listenstmt(): ListenstmtContext | null { - return this.getRuleContext(0, ListenstmtContext); - } - public refreshmatviewstmt(): RefreshmatviewstmtContext | null { - return this.getRuleContext(0, RefreshmatviewstmtContext); - } - public loadstmt(): LoadstmtContext | null { - return this.getRuleContext(0, LoadstmtContext); - } - public lockstmt(): LockstmtContext | null { - return this.getRuleContext(0, LockstmtContext); - } - public notifystmt(): NotifystmtContext | null { - return this.getRuleContext(0, NotifystmtContext); - } - public preparestmt(): PreparestmtContext | null { - return this.getRuleContext(0, PreparestmtContext); - } - public reassignownedstmt(): ReassignownedstmtContext | null { - return this.getRuleContext(0, ReassignownedstmtContext); - } - public reindexstmt(): ReindexstmtContext | null { - return this.getRuleContext(0, ReindexstmtContext); - } - public removeaggrstmt(): RemoveaggrstmtContext | null { - return this.getRuleContext(0, RemoveaggrstmtContext); - } - public removefuncstmt(): RemovefuncstmtContext | null { - return this.getRuleContext(0, RemovefuncstmtContext); - } - public removeoperstmt(): RemoveoperstmtContext | null { - return this.getRuleContext(0, RemoveoperstmtContext); - } - public renamestmt(): RenamestmtContext | null { - return this.getRuleContext(0, RenamestmtContext); - } - public revokestmt(): RevokestmtContext | null { - return this.getRuleContext(0, RevokestmtContext); - } - public revokerolestmt(): RevokerolestmtContext | null { - return this.getRuleContext(0, RevokerolestmtContext); - } - public rulestmt(): RulestmtContext | null { - return this.getRuleContext(0, RulestmtContext); - } - public seclabelstmt(): SeclabelstmtContext | null { - return this.getRuleContext(0, SeclabelstmtContext); - } - public selectstmt(): SelectstmtContext | null { - return this.getRuleContext(0, SelectstmtContext); - } - public transactionstmt(): TransactionstmtContext | null { - return this.getRuleContext(0, TransactionstmtContext); - } - public truncatestmt(): TruncatestmtContext | null { - return this.getRuleContext(0, TruncatestmtContext); - } - public unlistenstmt(): UnlistenstmtContext | null { - return this.getRuleContext(0, UnlistenstmtContext); - } - public updatestmt(): UpdatestmtContext | null { - return this.getRuleContext(0, UpdatestmtContext); - } - public vacuumstmt(): VacuumstmtContext | null { - return this.getRuleContext(0, VacuumstmtContext); - } - public variableresetstmt(): VariableresetstmtContext | null { - return this.getRuleContext(0, VariableresetstmtContext); - } - public variablesetstmt(): VariablesetstmtContext | null { - return this.getRuleContext(0, VariablesetstmtContext); - } - public variableshowstmt(): VariableshowstmtContext | null { - return this.getRuleContext(0, VariableshowstmtContext); - } - public viewstmt(): ViewstmtContext | null { - return this.getRuleContext(0, ViewstmtContext); - } - public plsqlconsolecommand(): PlsqlconsolecommandContext | null { - return this.getRuleContext(0, PlsqlconsolecommandContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt) { - listener.enterStmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt) { - listener.exitStmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt) { - return visitor.visitStmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class PlsqlconsolecommandContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public MetaCommand(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.MetaCommand, 0)!; - } - public EndMetaCommand(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.EndMetaCommand, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_plsqlconsolecommand; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPlsqlconsolecommand) { - listener.enterPlsqlconsolecommand(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPlsqlconsolecommand) { - listener.exitPlsqlconsolecommand(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPlsqlconsolecommand) { - return visitor.visitPlsqlconsolecommand(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class CallstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CALL(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CALL, 0)!; - } - public func_application(): Func_applicationContext { - return this.getRuleContext(0, Func_applicationContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_callstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCallstmt) { - listener.enterCallstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCallstmt) { - listener.exitCallstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCallstmt) { - return visitor.visitCallstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class CreaterolestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_ROLE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ROLE, 0)!; - } - public roleid(): RoleidContext { - return this.getRuleContext(0, RoleidContext)!; - } - public optrolelist(): OptrolelistContext { - return this.getRuleContext(0, OptrolelistContext)!; - } - public opt_with(): Opt_withContext | null { - return this.getRuleContext(0, Opt_withContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createrolestmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreaterolestmt) { - listener.enterCreaterolestmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreaterolestmt) { - listener.exitCreaterolestmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreaterolestmt) { - return visitor.visitCreaterolestmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_withContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_with; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_with) { - listener.enterOpt_with(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_with) { - listener.exitOpt_with(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_with) { - return visitor.visitOpt_with(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class OptrolelistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public createoptroleelem(): CreateoptroleelemContext[]; - public createoptroleelem(i: number): CreateoptroleelemContext | null; - public createoptroleelem(i?: number): CreateoptroleelemContext[] | CreateoptroleelemContext | null { - if (i === undefined) { - return this.getRuleContexts(CreateoptroleelemContext); - } - - return this.getRuleContext(i, CreateoptroleelemContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_optrolelist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOptrolelist) { - listener.enterOptrolelist(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOptrolelist) { - listener.exitOptrolelist(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOptrolelist) { - return visitor.visitOptrolelist(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class AlteroptrolelistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public alteroptroleelem(): AlteroptroleelemContext[]; - public alteroptroleelem(i: number): AlteroptroleelemContext | null; - public alteroptroleelem(i?: number): AlteroptroleelemContext[] | AlteroptroleelemContext | null { - if (i === undefined) { - return this.getRuleContexts(AlteroptroleelemContext); - } - - return this.getRuleContext(i, AlteroptroleelemContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alteroptrolelist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlteroptrolelist) { - listener.enterAlteroptrolelist(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlteroptrolelist) { - listener.exitAlteroptrolelist(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlteroptrolelist) { - return visitor.visitAlteroptrolelist(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class AlteroptroleelemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_PASSWORD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PASSWORD, 0); - } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); - } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); - } - public KW_ENCRYPTED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ENCRYPTED, 0); - } - public KW_UNENCRYPTED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNENCRYPTED, 0); - } - public KW_INHERIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INHERIT, 0); - } - public KW_NOINHERIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOINHERIT, 0); - } - public KW_CREATEUSER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CREATEUSER, 0); - } - public KW_NOCREATEUSER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOCREATEUSER, 0); - } - public KW_CREATEROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CREATEROLE, 0); - } - public KW_NOCREATEROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOCREATEROLE, 0); - } - public KW_CREATEDB(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CREATEDB, 0); - } - public KW_NOCREATEDB(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOCREATEDB, 0); - } - public KW_SUPERUSER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SUPERUSER, 0); - } - public KW_NOSUPERUSER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOSUPERUSER, 0); - } - public KW_LOGIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LOGIN, 0); - } - public KW_NOLOGIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOLOGIN, 0); - } - public KW_REPLICATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REPLICATION, 0); - } - public KW_NOREPLICATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOREPLICATION, 0); - } - public KW_BYPASSRLS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BYPASSRLS, 0); - } - public KW_NOBYPASSRLS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOBYPASSRLS, 0); - } - public KW_CONNECTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONNECTION, 0); - } - public KW_LIMIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LIMIT, 0); - } - public signediconst(): SignediconstContext | null { - return this.getRuleContext(0, SignediconstContext); - } - public KW_VALID(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALID, 0); - } - public KW_UNTIL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNTIL, 0); - } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); - } - public KW_ROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLE, 0); - } - public name_list(): Name_listContext | null { - return this.getRuleContext(0, Name_listContext); - } - public KW_GROUP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GROUP, 0); - } - public role_list(): Role_listContext | null { - return this.getRuleContext(0, Role_listContext); - } - public KW_ADMIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADMIN, 0); - } - public KW_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USER, 0); - } - public identifier(): IdentifierContext | null { - return this.getRuleContext(0, IdentifierContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alteroptroleelem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlteroptroleelem) { - listener.enterAlteroptroleelem(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlteroptroleelem) { - listener.exitAlteroptroleelem(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlteroptroleelem) { - return visitor.visitAlteroptroleelem(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class CreateoptroleelemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public alteroptroleelem(): AlteroptroleelemContext | null { - return this.getRuleContext(0, AlteroptroleelemContext); - } - public KW_SYSID(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SYSID, 0); - } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); - } - public KW_ADMIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADMIN, 0); - } - public role_list(): Role_listContext | null { - return this.getRuleContext(0, Role_listContext); - } - public KW_ROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLE, 0); - } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); - } - public KW_GROUP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GROUP, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createoptroleelem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateoptroleelem) { - listener.enterCreateoptroleelem(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateoptroleelem) { - listener.exitCreateoptroleelem(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateoptroleelem) { - return visitor.visitCreateoptroleelem(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class CreateuserstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_USER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USER, 0)!; - } - public roleid(): RoleidContext { - return this.getRuleContext(0, RoleidContext)!; - } - public optrolelist(): OptrolelistContext { - return this.getRuleContext(0, OptrolelistContext)!; - } - public opt_with(): Opt_withContext | null { - return this.getRuleContext(0, Opt_withContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createuserstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateuserstmt) { - listener.enterCreateuserstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateuserstmt) { - listener.exitCreateuserstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateuserstmt) { - return visitor.visitCreateuserstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class AlterrolestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public rolespec(): RolespecContext { - return this.getRuleContext(0, RolespecContext)!; - } - public alteroptrolelist(): AlteroptrolelistContext { - return this.getRuleContext(0, AlteroptrolelistContext)!; - } - public KW_ROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLE, 0); - } - public KW_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USER, 0); - } - public opt_with(): Opt_withContext | null { - return this.getRuleContext(0, Opt_withContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterrolestmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterrolestmt) { - listener.enterAlterrolestmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterrolestmt) { - listener.exitAlterrolestmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterrolestmt) { - return visitor.visitAlterrolestmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_in_databaseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); - } - public KW_DATABASE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATABASE, 0); - } - public database_name(): Database_nameContext | null { - return this.getRuleContext(0, Database_nameContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_in_database; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_in_database) { - listener.enterOpt_in_database(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_in_database) { - listener.exitOpt_in_database(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_in_database) { - return visitor.visitOpt_in_database(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class AlterrolesetstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public opt_in_database(): Opt_in_databaseContext { - return this.getRuleContext(0, Opt_in_databaseContext)!; - } - public setresetclause(): SetresetclauseContext { - return this.getRuleContext(0, SetresetclauseContext)!; - } - public KW_ROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLE, 0); - } - public KW_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USER, 0); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public rolespec(): RolespecContext | null { - return this.getRuleContext(0, RolespecContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterrolesetstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterrolesetstmt) { - listener.enterAlterrolesetstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterrolesetstmt) { - listener.exitAlterrolesetstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterrolesetstmt) { - return visitor.visitAlterrolesetstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class AlterroutinestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_ROUTINE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0)!; - } - public routine_name(): Routine_nameContext { - return this.getRuleContext(0, Routine_nameContext)!; - } - public alter_routine_cluase(): Alter_routine_cluaseContext { - return this.getRuleContext(0, Alter_routine_cluaseContext)!; - } - public func_args(): Func_argsContext | null { - return this.getRuleContext(0, Func_argsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterroutinestmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterroutinestmt) { - listener.enterAlterroutinestmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterroutinestmt) { - listener.exitAlterroutinestmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterroutinestmt) { - return visitor.visitAlterroutinestmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Alter_routine_cluaseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public routine_action_list(): Routine_action_listContext | null { - return this.getRuleContext(0, Routine_action_listContext); - } - public KW_RESTRICT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESTRICT, 0); - } - public KW_RENAME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RENAME, 0); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public routine_name_create(): Routine_name_createContext | null { - return this.getRuleContext(0, Routine_name_createContext); - } - public KW_OWNER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OWNER, 0); - } - public rolespec(): RolespecContext | null { - return this.getRuleContext(0, RolespecContext); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); - } - public schema_name_create(): Schema_name_createContext | null { - return this.getRuleContext(0, Schema_name_createContext); - } - public KW_DEPENDS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEPENDS, 0); - } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); - } - public KW_EXTENSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXTENSION, 0); - } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); - } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_routine_cluase; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_routine_cluase) { - listener.enterAlter_routine_cluase(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_routine_cluase) { - listener.exitAlter_routine_cluase(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_routine_cluase) { - return visitor.visitAlter_routine_cluase(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Routine_action_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public routine_action(): Routine_actionContext[]; - public routine_action(i: number): Routine_actionContext | null; - public routine_action(i?: number): Routine_actionContext[] | Routine_actionContext | null { - if (i === undefined) { - return this.getRuleContexts(Routine_actionContext); - } - - return this.getRuleContext(i, Routine_actionContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_routine_action_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRoutine_action_list) { - listener.enterRoutine_action_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRoutine_action_list) { - listener.exitRoutine_action_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRoutine_action_list) { - return visitor.visitRoutine_action_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Routine_actionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_IMMUTABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IMMUTABLE, 0); - } - public KW_STABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STABLE, 0); - } - public KW_VOLATILE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VOLATILE, 0); - } - public KW_LEAKPROOF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LEAKPROOF, 0); - } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); - } - public KW_SECURITY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SECURITY, 0); - } - public KW_INVOKER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INVOKER, 0); - } - public KW_DEFINER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFINER, 0); - } - public KW_EXTERNAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXTERNAL, 0); - } - public KW_PARALLEL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARALLEL, 0); - } - public KW_UNSAFE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNSAFE, 0); - } - public KW_RESTRICTED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESTRICTED, 0); - } - public KW_SAFE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SAFE, 0); - } - public KW_COST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COST, 0); - } - public attr_name(): Attr_nameContext | null { - return this.getRuleContext(0, Attr_nameContext); - } - public KW_ROWS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROWS, 0); - } - public name(): NameContext[]; - public name(i: number): NameContext | null; - public name(i?: number): NameContext[] | NameContext | null { - if (i === undefined) { - return this.getRuleContexts(NameContext); - } - - return this.getRuleContext(i, NameContext); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public EQUAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.EQUAL, 0); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public KW_CURRENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT, 0); - } - public KW_RESET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESET, 0); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_routine_action; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRoutine_action) { - listener.enterRoutine_action(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRoutine_action) { - listener.exitRoutine_action(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRoutine_action) { - return visitor.visitRoutine_action(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class CreategroupstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_GROUP(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_GROUP, 0)!; - } - public groupname(): GroupnameContext { - return this.getRuleContext(0, GroupnameContext)!; - } - public optrolelist(): OptrolelistContext { - return this.getRuleContext(0, OptrolelistContext)!; - } - public opt_with(): Opt_withContext | null { - return this.getRuleContext(0, Opt_withContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_creategroupstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreategroupstmt) { - listener.enterCreategroupstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreategroupstmt) { - listener.exitCreategroupstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreategroupstmt) { - return visitor.visitCreategroupstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class AltergroupstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_GROUP(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_GROUP, 0)!; - } - public rolespec(): RolespecContext { - return this.getRuleContext(0, RolespecContext)!; - } - public add_drop(): Add_dropContext { - return this.getRuleContext(0, Add_dropContext)!; - } - public KW_USER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USER, 0)!; - } - public role_list(): Role_listContext { - return this.getRuleContext(0, Role_listContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_altergroupstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAltergroupstmt) { - listener.enterAltergroupstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAltergroupstmt) { - listener.exitAltergroupstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAltergroupstmt) { - return visitor.visitAltergroupstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Add_dropContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ADD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADD, 0); - } - public KW_DROP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DROP, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_add_drop; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAdd_drop) { - listener.enterAdd_drop(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAdd_drop) { - listener.exitAdd_drop(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAdd_drop) { - return visitor.visitAdd_drop(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class CreateschemastmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_SCHEMA(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0)!; - } - public optschemaeltlist(): OptschemaeltlistContext { - return this.getRuleContext(0, OptschemaeltlistContext)!; - } - public KW_AUTHORIZATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AUTHORIZATION, 0); - } - public rolespec(): RolespecContext | null { - return this.getRuleContext(0, RolespecContext); - } - public schema_name_create(): Schema_name_createContext | null { - return this.getRuleContext(0, Schema_name_createContext); - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createschemastmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateschemastmt) { - listener.enterCreateschemastmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateschemastmt) { - listener.exitCreateschemastmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateschemastmt) { - return visitor.visitCreateschemastmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Schema_name_createContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_schema_name_create; - } - public override copyFrom(ctx: Schema_name_createContext): void { - super.copyFrom(ctx); - } -} -export class SchemaNameCreateContext extends Schema_name_createContext { - public constructor(ctx: Schema_name_createContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); - } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public attrs(): AttrsContext | null { - return this.getRuleContext(0, AttrsContext); - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSchemaNameCreate) { - listener.enterSchemaNameCreate(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSchemaNameCreate) { - listener.exitSchemaNameCreate(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSchemaNameCreate) { - return visitor.visitSchemaNameCreate(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class OptschemaeltlistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public schema_stmt(): Schema_stmtContext[]; - public schema_stmt(i: number): Schema_stmtContext | null; - public schema_stmt(i?: number): Schema_stmtContext[] | Schema_stmtContext | null { - if (i === undefined) { - return this.getRuleContexts(Schema_stmtContext); - } - - return this.getRuleContext(i, Schema_stmtContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_optschemaeltlist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOptschemaeltlist) { - listener.enterOptschemaeltlist(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOptschemaeltlist) { - listener.exitOptschemaeltlist(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOptschemaeltlist) { - return visitor.visitOptschemaeltlist(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Schema_stmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public createstmt(): CreatestmtContext | null { - return this.getRuleContext(0, CreatestmtContext); - } - public indexstmt(): IndexstmtContext | null { - return this.getRuleContext(0, IndexstmtContext); - } - public createseqstmt(): CreateseqstmtContext | null { - return this.getRuleContext(0, CreateseqstmtContext); - } - public createtrigstmt(): CreatetrigstmtContext | null { - return this.getRuleContext(0, CreatetrigstmtContext); - } - public grantstmt(): GrantstmtContext | null { - return this.getRuleContext(0, GrantstmtContext); - } - public viewstmt(): ViewstmtContext | null { - return this.getRuleContext(0, ViewstmtContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_schema_stmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSchema_stmt) { - listener.enterSchema_stmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSchema_stmt) { - listener.exitSchema_stmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSchema_stmt) { - return visitor.visitSchema_stmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class VariablesetstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_SET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SET, 0)!; - } - public set_rest(): Set_restContext { - return this.getRuleContext(0, Set_restContext)!; - } - public KW_LOCAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LOCAL, 0); - } - public KW_SESSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SESSION, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_variablesetstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVariablesetstmt) { - listener.enterVariablesetstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVariablesetstmt) { - listener.exitVariablesetstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVariablesetstmt) { - return visitor.visitVariablesetstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Set_restContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_TRANSACTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); - } - public transaction_mode_list(): Transaction_mode_listContext | null { - return this.getRuleContext(0, Transaction_mode_listContext); - } - public KW_SESSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SESSION, 0); - } - public KW_CHARACTERISTICS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CHARACTERISTICS, 0); - } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); - } - public set_rest_more(): Set_rest_moreContext | null { - return this.getRuleContext(0, Set_rest_moreContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_set_rest; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSet_rest) { - listener.enterSet_rest(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSet_rest) { - listener.exitSet_rest(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSet_rest) { - return visitor.visitSet_rest(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Generic_setContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public var_name(): Var_nameContext | null { - return this.getRuleContext(0, Var_nameContext); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public var_list(): Var_listContext | null { - return this.getRuleContext(0, Var_listContext); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public EQUAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.EQUAL, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_generic_set; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGeneric_set) { - listener.enterGeneric_set(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGeneric_set) { - listener.exitGeneric_set(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGeneric_set) { - return visitor.visitGeneric_set(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Set_rest_moreContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_TIME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TIME, 0); - } - public KW_ZONE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ZONE, 0); - } - public zone_value(): Zone_valueContext | null { - return this.getRuleContext(0, Zone_valueContext); - } - public KW_CATALOG(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CATALOG, 0); - } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); - } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); - } - public schema_name(): Schema_nameContext | null { - return this.getRuleContext(0, Schema_nameContext); - } - public KW_NAMES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NAMES, 0); - } - public opt_encoding(): Opt_encodingContext | null { - return this.getRuleContext(0, Opt_encodingContext); - } - public KW_ROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLE, 0); - } - public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | null { - return this.getRuleContext(0, Nonreservedword_or_sconstContext); - } - public KW_SESSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SESSION, 0); - } - public KW_AUTHORIZATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AUTHORIZATION, 0); - } - public KW_XML(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XML, 0); - } - public KW_OPTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPTION, 0); - } - public document_or_content(): Document_or_contentContext | null { - return this.getRuleContext(0, Document_or_contentContext); - } - public KW_TRANSACTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); - } - public KW_SNAPSHOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SNAPSHOT, 0); - } - public var_name(): Var_nameContext | null { - return this.getRuleContext(0, Var_nameContext); - } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public KW_CURRENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT, 0); - } - public generic_set(): Generic_setContext | null { - return this.getRuleContext(0, Generic_setContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_set_rest_more; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSet_rest_more) { - listener.enterSet_rest_more(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSet_rest_more) { - listener.exitSet_rest_more(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSet_rest_more) { - return visitor.visitSet_rest_more(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Var_nameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public colid(): ColidContext[]; - public colid(i: number): ColidContext | null; - public colid(i?: number): ColidContext[] | ColidContext | null { - if (i === undefined) { - return this.getRuleContexts(ColidContext); - } - - return this.getRuleContext(i, ColidContext); - } - public DOT(): antlr.TerminalNode[]; - public DOT(i: number): antlr.TerminalNode | null; - public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.DOT); - } else { - return this.getToken(PostgreSqlParser.DOT, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_var_name; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVar_name) { - listener.enterVar_name(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVar_name) { - listener.exitVar_name(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVar_name) { - return visitor.visitVar_name(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Var_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public var_value(): Var_valueContext[]; - public var_value(i: number): Var_valueContext | null; - public var_value(i?: number): Var_valueContext[] | Var_valueContext | null { - if (i === undefined) { - return this.getRuleContexts(Var_valueContext); - } - - return this.getRuleContext(i, Var_valueContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_var_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVar_list) { - listener.enterVar_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVar_list) { - listener.exitVar_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVar_list) { - return visitor.visitVar_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Var_valueContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public opt_boolean_or_string(): Opt_boolean_or_stringContext | null { - return this.getRuleContext(0, Opt_boolean_or_stringContext); - } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_var_value; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVar_value) { - listener.enterVar_value(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVar_value) { - listener.exitVar_value(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVar_value) { - return visitor.visitVar_value(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Iso_levelContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_READ(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_READ, 0); - } - public KW_UNCOMMITTED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNCOMMITTED, 0); - } - public KW_COMMITTED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COMMITTED, 0); - } - public KW_REPEATABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REPEATABLE, 0); - } - public KW_SERIALIZABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SERIALIZABLE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_iso_level; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIso_level) { - listener.enterIso_level(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIso_level) { - listener.exitIso_level(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIso_level) { - return visitor.visitIso_level(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_boolean_or_string_columnContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_TRUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRUE, 0); - } - public KW_FALSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FALSE, 0); - } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); - } - public nonreservedword_or_sconst_column(): Nonreservedword_or_sconst_columnContext | null { - return this.getRuleContext(0, Nonreservedword_or_sconst_columnContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_boolean_or_string_column; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_boolean_or_string_column) { - listener.enterOpt_boolean_or_string_column(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_boolean_or_string_column) { - listener.exitOpt_boolean_or_string_column(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_boolean_or_string_column) { - return visitor.visitOpt_boolean_or_string_column(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_boolean_or_stringContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_TRUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRUE, 0); - } - public KW_FALSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FALSE, 0); - } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); - } - public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | null { - return this.getRuleContext(0, Nonreservedword_or_sconstContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_boolean_or_string; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_boolean_or_string) { - listener.enterOpt_boolean_or_string(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_boolean_or_string) { - listener.exitOpt_boolean_or_string(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_boolean_or_string) { - return visitor.visitOpt_boolean_or_string(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Zone_valueContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); - } - public identifier(): IdentifierContext | null { - return this.getRuleContext(0, IdentifierContext); - } - public constinterval(): ConstintervalContext | null { - return this.getRuleContext(0, ConstintervalContext); - } - public opt_interval(): Opt_intervalContext | null { - return this.getRuleContext(0, Opt_intervalContext); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public KW_LOCAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LOCAL, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_zone_value; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterZone_value) { - listener.enterZone_value(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitZone_value) { - listener.exitZone_value(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitZone_value) { - return visitor.visitZone_value(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_encodingContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_encoding; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_encoding) { - listener.enterOpt_encoding(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_encoding) { - listener.exitOpt_encoding(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_encoding) { - return visitor.visitOpt_encoding(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Nonreservedword_or_sconst_columnContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public nonreservedword_column(): Nonreservedword_columnContext | null { - return this.getRuleContext(0, Nonreservedword_columnContext); - } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_nonreservedword_or_sconst_column; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterNonreservedword_or_sconst_column) { - listener.enterNonreservedword_or_sconst_column(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitNonreservedword_or_sconst_column) { - listener.exitNonreservedword_or_sconst_column(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitNonreservedword_or_sconst_column) { - return visitor.visitNonreservedword_or_sconst_column(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Nonreservedword_or_sconstContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public nonreservedword(): NonreservedwordContext | null { - return this.getRuleContext(0, NonreservedwordContext); - } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_nonreservedword_or_sconst; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterNonreservedword_or_sconst) { - listener.enterNonreservedword_or_sconst(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitNonreservedword_or_sconst) { - listener.exitNonreservedword_or_sconst(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitNonreservedword_or_sconst) { - return visitor.visitNonreservedword_or_sconst(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class VariableresetstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_RESET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_RESET, 0)!; - } - public reset_rest(): Reset_restContext { - return this.getRuleContext(0, Reset_restContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_variableresetstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVariableresetstmt) { - listener.enterVariableresetstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVariableresetstmt) { - listener.exitVariableresetstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVariableresetstmt) { - return visitor.visitVariableresetstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Reset_restContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_TIME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TIME, 0); - } - public KW_ZONE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ZONE, 0); - } - public KW_TRANSACTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); - } - public KW_ISOLATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ISOLATION, 0); - } - public KW_LEVEL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LEVEL, 0); - } - public KW_SESSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SESSION, 0); - } - public KW_AUTHORIZATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AUTHORIZATION, 0); - } - public generic_reset(): Generic_resetContext | null { - return this.getRuleContext(0, Generic_resetContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_reset_rest; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReset_rest) { - listener.enterReset_rest(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReset_rest) { - listener.exitReset_rest(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReset_rest) { - return visitor.visitReset_rest(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Generic_resetContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public var_name(): Var_nameContext | null { - return this.getRuleContext(0, Var_nameContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_generic_reset; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGeneric_reset) { - listener.enterGeneric_reset(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGeneric_reset) { - listener.exitGeneric_reset(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGeneric_reset) { - return visitor.visitGeneric_reset(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class SetresetclauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public set_rest(): Set_restContext | null { - return this.getRuleContext(0, Set_restContext); - } - public variableresetstmt(): VariableresetstmtContext | null { - return this.getRuleContext(0, VariableresetstmtContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_setresetclause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSetresetclause) { - listener.enterSetresetclause(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSetresetclause) { - listener.exitSetresetclause(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSetresetclause) { - return visitor.visitSetresetclause(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class FunctionsetresetclauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public set_rest_more(): Set_rest_moreContext | null { - return this.getRuleContext(0, Set_rest_moreContext); - } - public variableresetstmt(): VariableresetstmtContext | null { - return this.getRuleContext(0, VariableresetstmtContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_functionsetresetclause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunctionsetresetclause) { - listener.enterFunctionsetresetclause(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunctionsetresetclause) { - listener.exitFunctionsetresetclause(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunctionsetresetclause) { - return visitor.visitFunctionsetresetclause(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class VariableshowstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_SHOW(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SHOW, 0)!; - } - public var_name(): Var_nameContext | null { - return this.getRuleContext(0, Var_nameContext); - } - public KW_TIME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TIME, 0); - } - public KW_ZONE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ZONE, 0); - } - public KW_TRANSACTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); - } - public KW_ISOLATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ISOLATION, 0); - } - public KW_LEVEL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LEVEL, 0); - } - public KW_SESSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SESSION, 0); - } - public KW_AUTHORIZATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AUTHORIZATION, 0); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_variableshowstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVariableshowstmt) { - listener.enterVariableshowstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVariableshowstmt) { - listener.exitVariableshowstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVariableshowstmt) { - return visitor.visitVariableshowstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class ConstraintssetstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_SET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SET, 0)!; - } - public KW_CONSTRAINTS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CONSTRAINTS, 0)!; - } - public constraints_set_list(): Constraints_set_listContext { - return this.getRuleContext(0, Constraints_set_listContext)!; - } - public constraints_set_mode(): Constraints_set_modeContext { - return this.getRuleContext(0, Constraints_set_modeContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_constraintssetstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterConstraintssetstmt) { - listener.enterConstraintssetstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitConstraintssetstmt) { - listener.exitConstraintssetstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitConstraintssetstmt) { - return visitor.visitConstraintssetstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Constraints_set_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public qualified_name_list(): Qualified_name_listContext | null { - return this.getRuleContext(0, Qualified_name_listContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_constraints_set_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterConstraints_set_list) { - listener.enterConstraints_set_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitConstraints_set_list) { - listener.exitConstraints_set_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitConstraints_set_list) { - return visitor.visitConstraints_set_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Constraints_set_modeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_DEFERRED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFERRED, 0); - } - public KW_IMMEDIATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IMMEDIATE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_constraints_set_mode; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterConstraints_set_mode) { - listener.enterConstraints_set_mode(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitConstraints_set_mode) { - listener.exitConstraints_set_mode(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitConstraints_set_mode) { - return visitor.visitConstraints_set_mode(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class CheckpointstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CHECKPOINT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CHECKPOINT, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_checkpointstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCheckpointstmt) { - listener.enterCheckpointstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCheckpointstmt) { - listener.exitCheckpointstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCheckpointstmt) { - return visitor.visitCheckpointstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class DiscardstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_DISCARD(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DISCARD, 0)!; - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public KW_TEMP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMP, 0); - } - public KW_TEMPORARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPORARY, 0); - } - public KW_PLANS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PLANS, 0); - } - public KW_SEQUENCES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCES, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_discardstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDiscardstmt) { - listener.enterDiscardstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDiscardstmt) { - listener.exitDiscardstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDiscardstmt) { - return visitor.visitDiscardstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class AltertablestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); - } - public relation_expr(): Relation_exprContext | null { - return this.getRuleContext(0, Relation_exprContext); - } - public alter_table_cmds(): Alter_table_cmdsContext | null { - return this.getRuleContext(0, Alter_table_cmdsContext); - } - public partition_cmd(): Partition_cmdContext | null { - return this.getRuleContext(0, Partition_cmdContext); - } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); - } - public KW_TABLESPACE(): antlr.TerminalNode[]; - public KW_TABLESPACE(i: number): antlr.TerminalNode | null; - public KW_TABLESPACE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_TABLESPACE); - } else { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, i); - } - } - public tablespace_name(): Tablespace_nameContext[]; - public tablespace_name(i: number): Tablespace_nameContext | null; - public tablespace_name(i?: number): Tablespace_nameContext[] | Tablespace_nameContext | null { - if (i === undefined) { - return this.getRuleContexts(Tablespace_nameContext); - } - - return this.getRuleContext(i, Tablespace_nameContext); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public tablespace_name_create(): Tablespace_name_createContext | null { - return this.getRuleContext(0, Tablespace_name_createContext); - } - public KW_OWNED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OWNED, 0); - } - public KW_BY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BY, 0); - } - public role_list(): Role_listContext | null { - return this.getRuleContext(0, Role_listContext); - } - public opt_nowait(): Opt_nowaitContext | null { - return this.getRuleContext(0, Opt_nowaitContext); - } - public table_name(): Table_nameContext | null { - return this.getRuleContext(0, Table_nameContext); - } - public KW_ATTACH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ATTACH, 0); - } - public KW_PARTITION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARTITION, 0); - } - public qualified_name(): Qualified_nameContext | null { - return this.getRuleContext(0, Qualified_nameContext); - } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); - } - public KW_VALUES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALUES, 0); - } - public partition_bound_spec(): Partition_bound_specContext | null { - return this.getRuleContext(0, Partition_bound_specContext); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public KW_DETACH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DETACH, 0); - } - public KW_CONCURRENTLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONCURRENTLY, 0); - } - public KW_FINALIZE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FINALIZE, 0); - } - public KW_INDEX(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INDEX, 0); - } - public index_partition_cmd(): Index_partition_cmdContext | null { - return this.getRuleContext(0, Index_partition_cmdContext); - } - public KW_SEQUENCE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); - } - public KW_VIEW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VIEW, 0); - } - public view_name(): View_nameContext | null { - return this.getRuleContext(0, View_nameContext); - } - public KW_MATERIALIZED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); - } - public KW_FOREIGN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_altertablestmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAltertablestmt) { - listener.enterAltertablestmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAltertablestmt) { - listener.exitAltertablestmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAltertablestmt) { - return visitor.visitAltertablestmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Alter_table_cmdsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public alter_table_cmd(): Alter_table_cmdContext[]; - public alter_table_cmd(i: number): Alter_table_cmdContext | null; - public alter_table_cmd(i?: number): Alter_table_cmdContext[] | Alter_table_cmdContext | null { - if (i === undefined) { - return this.getRuleContexts(Alter_table_cmdContext); - } - - return this.getRuleContext(i, Alter_table_cmdContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_table_cmds; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_table_cmds) { - listener.enterAlter_table_cmds(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_table_cmds) { - listener.exitAlter_table_cmds(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_table_cmds) { - return visitor.visitAlter_table_cmds(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Partition_bound_specContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); - } - public opt_type_modifiers(): Opt_type_modifiersContext | null { - return this.getRuleContext(0, Opt_type_modifiersContext); - } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public partition_bound_cluase(): Partition_bound_cluaseContext[]; - public partition_bound_cluase(i: number): Partition_bound_cluaseContext | null; - public partition_bound_cluase(i?: number): Partition_bound_cluaseContext[] | Partition_bound_cluaseContext | null { - if (i === undefined) { - return this.getRuleContexts(Partition_bound_cluaseContext); - } - - return this.getRuleContext(i, Partition_bound_cluaseContext); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); - } - public partition_with_cluase(): Partition_with_cluaseContext | null { - return this.getRuleContext(0, Partition_with_cluaseContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_partition_bound_spec; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPartition_bound_spec) { - listener.enterPartition_bound_spec(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPartition_bound_spec) { - listener.exitPartition_bound_spec(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPartition_bound_spec) { - return visitor.visitPartition_bound_spec(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Partition_bound_cluaseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public partition_bound_choose(): Partition_bound_chooseContext[]; - public partition_bound_choose(i: number): Partition_bound_chooseContext | null; - public partition_bound_choose(i?: number): Partition_bound_chooseContext[] | Partition_bound_chooseContext | null { - if (i === undefined) { - return this.getRuleContexts(Partition_bound_chooseContext); - } - - return this.getRuleContext(i, Partition_bound_chooseContext); - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_partition_bound_cluase; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPartition_bound_cluase) { - listener.enterPartition_bound_cluase(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPartition_bound_cluase) { - listener.exitPartition_bound_cluase(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPartition_bound_cluase) { - return visitor.visitPartition_bound_cluase(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Partition_bound_chooseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public opt_type_modifiers(): Opt_type_modifiersContext | null { - return this.getRuleContext(0, Opt_type_modifiersContext); - } - public KW_MINVALUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MINVALUE, 0); - } - public KW_MAXVALUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MAXVALUE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_partition_bound_choose; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPartition_bound_choose) { - listener.enterPartition_bound_choose(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPartition_bound_choose) { - listener.exitPartition_bound_choose(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPartition_bound_choose) { - return visitor.visitPartition_bound_choose(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Partition_with_cluaseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public KW_MODULUS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_MODULUS, 0)!; - } - public numericonly(): NumericonlyContext[]; - public numericonly(i: number): NumericonlyContext | null; - public numericonly(i?: number): NumericonlyContext[] | NumericonlyContext | null { - if (i === undefined) { - return this.getRuleContexts(NumericonlyContext); - } - - return this.getRuleContext(i, NumericonlyContext); - } - public COMMA(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.COMMA, 0)!; - } - public KW_REMAINDER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_REMAINDER, 0)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_partition_with_cluase; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPartition_with_cluase) { - listener.enterPartition_with_cluase(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPartition_with_cluase) { - listener.exitPartition_with_cluase(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPartition_with_cluase) { - return visitor.visitPartition_with_cluase(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Partition_cmdContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ATTACH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ATTACH, 0); - } - public KW_PARTITION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PARTITION, 0)!; - } - public qualified_name(): Qualified_nameContext { - return this.getRuleContext(0, Qualified_nameContext)!; - } - public partitionboundspec(): PartitionboundspecContext | null { - return this.getRuleContext(0, PartitionboundspecContext); - } - public KW_DETACH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DETACH, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_partition_cmd; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPartition_cmd) { - listener.enterPartition_cmd(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPartition_cmd) { - listener.exitPartition_cmd(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPartition_cmd) { - return visitor.visitPartition_cmd(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Index_partition_cmdContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ATTACH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ATTACH, 0)!; - } - public KW_PARTITION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PARTITION, 0)!; - } - public qualified_name(): Qualified_nameContext { - return this.getRuleContext(0, Qualified_nameContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_index_partition_cmd; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIndex_partition_cmd) { - listener.enterIndex_partition_cmd(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIndex_partition_cmd) { - listener.exitIndex_partition_cmd(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIndex_partition_cmd) { - return visitor.visitIndex_partition_cmd(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Alter_table_cmdContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ADD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADD, 0); - } - public constraintelem(): ConstraintelemContext | null { - return this.getRuleContext(0, ConstraintelemContext); - } - public KW_CONSTRAINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); - } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); - } - public KW_ALTER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALTER, 0); - } - public constraintattributespec(): ConstraintattributespecContext | null { - return this.getRuleContext(0, ConstraintattributespecContext); - } - public KW_VALIDATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALIDATE, 0); - } - public KW_DROP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DROP, 0); - } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); - } - public opt_drop_behavior(): Opt_drop_behaviorContext | null { - return this.getRuleContext(0, Opt_drop_behaviorContext); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public KW_WITHOUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); - } - public KW_OIDS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OIDS, 0); - } - public KW_CLUSTER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CLUSTER, 0); - } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); - } - public KW_LOGGED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LOGGED, 0); - } - public KW_UNLOGGED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNLOGGED, 0); - } - public KW_ENABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ENABLE, 0); - } - public KW_TRIGGER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); - } - public KW_REPLICA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REPLICA, 0); - } - public KW_ALWAYS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALWAYS, 0); - } - public KW_DISABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DISABLE, 0); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public KW_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USER, 0); - } - public KW_RULE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RULE, 0); - } - public KW_INHERIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INHERIT, 0); - } - public qualified_name(): Qualified_nameContext | null { - return this.getRuleContext(0, Qualified_nameContext); - } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); - } - public KW_OF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OF, 0); - } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); - } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); - } - public KW_OWNER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OWNER, 0); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public rolespec(): RolespecContext | null { - return this.getRuleContext(0, RolespecContext); - } - public KW_TABLESPACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); - } - public tablespace_name_create(): Tablespace_name_createContext | null { - return this.getRuleContext(0, Tablespace_name_createContext); - } - public reloptions(): ReloptionsContext | null { - return this.getRuleContext(0, ReloptionsContext); - } - public KW_RESET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESET, 0); - } - public KW_IDENTITY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IDENTITY, 0); - } - public replica_identity(): Replica_identityContext | null { - return this.getRuleContext(0, Replica_identityContext); - } - public KW_ROW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROW, 0); - } - public KW_LEVEL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LEVEL, 0); - } - public KW_SECURITY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SECURITY, 0); - } - public KW_FORCE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FORCE, 0); - } - public column_name(): Column_nameContext | null { - return this.getRuleContext(0, Column_nameContext); - } - public KW_COLUMN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLUMN, 0); - } - public column_def(): Column_defContext | null { - return this.getRuleContext(0, Column_defContext); - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public alter_column_default(): Alter_column_defaultContext | null { - return this.getRuleContext(0, Alter_column_defaultContext); - } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); - } - public KW_EXPRESSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXPRESSION, 0); - } - public KW_STATISTICS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); - } - public signediconst(): SignediconstContext | null { - return this.getRuleContext(0, SignediconstContext); - } - public KW_STORAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STORAGE, 0); - } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); - } - public KW_GENERATED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GENERATED, 0); - } - public generated_when(): Generated_whenContext | null { - return this.getRuleContext(0, Generated_whenContext); - } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); - } - public optparenthesizedseqoptlist(): OptparenthesizedseqoptlistContext | null { - return this.getRuleContext(0, OptparenthesizedseqoptlistContext); - } - public alter_identity_column_option_list(): Alter_identity_column_option_listContext | null { - return this.getRuleContext(0, Alter_identity_column_option_listContext); - } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); - } - public typename(): TypenameContext | null { - return this.getRuleContext(0, TypenameContext); - } - public opt_set_data(): Opt_set_dataContext | null { - return this.getRuleContext(0, Opt_set_dataContext); - } - public opt_collate_clause(): Opt_collate_clauseContext | null { - return this.getRuleContext(0, Opt_collate_clauseContext); - } - public alter_using(): Alter_usingContext | null { - return this.getRuleContext(0, Alter_usingContext); - } - public alter_generic_options(): Alter_generic_optionsContext | null { - return this.getRuleContext(0, Alter_generic_optionsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_table_cmd; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_table_cmd) { - listener.enterAlter_table_cmd(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_table_cmd) { - listener.exitAlter_table_cmd(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_table_cmd) { - return visitor.visitAlter_table_cmd(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Alter_column_defaultContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public KW_DEFAULT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0)!; - } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } - public KW_DROP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DROP, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_column_default; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_column_default) { - listener.enterAlter_column_default(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_column_default) { - listener.exitAlter_column_default(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_column_default) { - return visitor.visitAlter_column_default(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_drop_behaviorContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CASCADE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CASCADE, 0); - } - public KW_RESTRICT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESTRICT, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_drop_behavior; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_drop_behavior) { - listener.enterOpt_drop_behavior(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_drop_behavior) { - listener.exitOpt_drop_behavior(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_drop_behavior) { - return visitor.visitOpt_drop_behavior(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_collate_clauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_COLLATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_COLLATE, 0)!; - } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_collate_clause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_collate_clause) { - listener.enterOpt_collate_clause(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_collate_clause) { - listener.exitOpt_collate_clause(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_collate_clause) { - return visitor.visitOpt_collate_clause(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Alter_usingContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_using; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_using) { - listener.enterAlter_using(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_using) { - listener.exitAlter_using(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_using) { - return visitor.visitAlter_using(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Replica_identityContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_NOTHING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOTHING, 0); - } - public KW_FULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FULL, 0); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); - } - public KW_INDEX(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INDEX, 0); - } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_replica_identity; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReplica_identity) { - listener.enterReplica_identity(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReplica_identity) { - listener.exitReplica_identity(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReplica_identity) { - return visitor.visitReplica_identity(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class ReloptionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public reloption_list(): Reloption_listContext { - return this.getRuleContext(0, Reloption_listContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_reloptions; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReloptions) { - listener.enterReloptions(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReloptions) { - listener.exitReloptions(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReloptions) { - return visitor.visitReloptions(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_reloptionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; - } - public reloptions(): ReloptionsContext { - return this.getRuleContext(0, ReloptionsContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_reloptions; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_reloptions) { - listener.enterOpt_reloptions(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_reloptions) { - listener.exitOpt_reloptions(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_reloptions) { - return visitor.visitOpt_reloptions(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Reloption_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public reloption_elem(): Reloption_elemContext[]; - public reloption_elem(i: number): Reloption_elemContext | null; - public reloption_elem(i?: number): Reloption_elemContext[] | Reloption_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Reloption_elemContext); - } - - return this.getRuleContext(i, Reloption_elemContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_reloption_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReloption_list) { - listener.enterReloption_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReloption_list) { - listener.exitReloption_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReloption_list) { - return visitor.visitReloption_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Reloption_elemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public collabel(): CollabelContext[]; - public collabel(i: number): CollabelContext | null; - public collabel(i?: number): CollabelContext[] | CollabelContext | null { - if (i === undefined) { - return this.getRuleContexts(CollabelContext); - } - - return this.getRuleContext(i, CollabelContext); - } - public EQUAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.EQUAL, 0); - } - public def_arg(): Def_argContext | null { - return this.getRuleContext(0, Def_argContext); - } - public DOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.DOT, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_reloption_elem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReloption_elem) { - listener.enterReloption_elem(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReloption_elem) { - listener.exitReloption_elem(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReloption_elem) { - return visitor.visitReloption_elem(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Alter_identity_column_option_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public alter_identity_column_option(): Alter_identity_column_optionContext[]; - public alter_identity_column_option(i: number): Alter_identity_column_optionContext | null; - public alter_identity_column_option(i?: number): Alter_identity_column_optionContext[] | Alter_identity_column_optionContext | null { - if (i === undefined) { - return this.getRuleContexts(Alter_identity_column_optionContext); - } - - return this.getRuleContext(i, Alter_identity_column_optionContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_identity_column_option_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_identity_column_option_list) { - listener.enterAlter_identity_column_option_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_identity_column_option_list) { - listener.exitAlter_identity_column_option_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_identity_column_option_list) { - return visitor.visitAlter_identity_column_option_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Alter_identity_column_optionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_RESTART(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESTART, 0); - } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); - } - public opt_with(): Opt_withContext | null { - return this.getRuleContext(0, Opt_withContext); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public seqoptelem(): SeqoptelemContext | null { - return this.getRuleContext(0, SeqoptelemContext); - } - public KW_GENERATED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GENERATED, 0); - } - public generated_when(): Generated_whenContext | null { - return this.getRuleContext(0, Generated_whenContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_identity_column_option; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_identity_column_option) { - listener.enterAlter_identity_column_option(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_identity_column_option) { - listener.exitAlter_identity_column_option(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_identity_column_option) { - return visitor.visitAlter_identity_column_option(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class PartitionboundspecContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); - } - public KW_VALUES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALUES, 0); - } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); - } - public OPEN_PAREN(): antlr.TerminalNode[]; - public OPEN_PAREN(i: number): antlr.TerminalNode | null; - public OPEN_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.OPEN_PAREN); - } else { - return this.getToken(PostgreSqlParser.OPEN_PAREN, i); - } - } - public hash_partbound(): Hash_partboundContext | null { - return this.getRuleContext(0, Hash_partboundContext); - } - public CLOSE_PAREN(): antlr.TerminalNode[]; - public CLOSE_PAREN(i: number): antlr.TerminalNode | null; - public CLOSE_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.CLOSE_PAREN); - } else { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, i); - } - } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); - } - public expr_list(): Expr_listContext[]; - public expr_list(i: number): Expr_listContext | null; - public expr_list(i?: number): Expr_listContext[] | Expr_listContext | null { - if (i === undefined) { - return this.getRuleContexts(Expr_listContext); - } - - return this.getRuleContext(i, Expr_listContext); - } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_partitionboundspec; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPartitionboundspec) { - listener.enterPartitionboundspec(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPartitionboundspec) { - listener.exitPartitionboundspec(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPartitionboundspec) { - return visitor.visitPartitionboundspec(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Hash_partbound_elemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public nonreservedword(): NonreservedwordContext { - return this.getRuleContext(0, NonreservedwordContext)!; - } - public iconst(): IconstContext { - return this.getRuleContext(0, IconstContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_hash_partbound_elem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterHash_partbound_elem) { - listener.enterHash_partbound_elem(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitHash_partbound_elem) { - listener.exitHash_partbound_elem(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitHash_partbound_elem) { - return visitor.visitHash_partbound_elem(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Hash_partboundContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public hash_partbound_elem(): Hash_partbound_elemContext[]; - public hash_partbound_elem(i: number): Hash_partbound_elemContext | null; - public hash_partbound_elem(i?: number): Hash_partbound_elemContext[] | Hash_partbound_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Hash_partbound_elemContext); - } - - return this.getRuleContext(i, Hash_partbound_elemContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_hash_partbound; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterHash_partbound) { - listener.enterHash_partbound(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitHash_partbound) { - listener.exitHash_partbound(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitHash_partbound) { - return visitor.visitHash_partbound(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class AltercompositetypestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_TYPE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TYPE, 0)!; - } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; - } - public alter_type_cmds(): Alter_type_cmdsContext { - return this.getRuleContext(0, Alter_type_cmdsContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_altercompositetypestmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAltercompositetypestmt) { - listener.enterAltercompositetypestmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAltercompositetypestmt) { - listener.exitAltercompositetypestmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAltercompositetypestmt) { - return visitor.visitAltercompositetypestmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Alter_type_cmdsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public alter_type_cmd(): Alter_type_cmdContext[]; - public alter_type_cmd(i: number): Alter_type_cmdContext | null; - public alter_type_cmd(i?: number): Alter_type_cmdContext[] | Alter_type_cmdContext | null { - if (i === undefined) { - return this.getRuleContexts(Alter_type_cmdContext); - } - - return this.getRuleContext(i, Alter_type_cmdContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_type_cmds; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_type_cmds) { - listener.enterAlter_type_cmds(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_type_cmds) { - listener.exitAlter_type_cmds(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_type_cmds) { - return visitor.visitAlter_type_cmds(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Alter_type_cmdContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ADD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADD, 0); - } - public KW_ATTRIBUTE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ATTRIBUTE, 0)!; - } - public tablefuncelement(): TablefuncelementContext | null { - return this.getRuleContext(0, TablefuncelementContext); - } - public opt_drop_behavior(): Opt_drop_behaviorContext | null { - return this.getRuleContext(0, Opt_drop_behaviorContext); - } - public KW_DROP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DROP, 0); - } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); - } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); - } - public KW_ALTER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALTER, 0); - } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); - } - public typename(): TypenameContext | null { - return this.getRuleContext(0, TypenameContext); - } - public opt_set_data(): Opt_set_dataContext | null { - return this.getRuleContext(0, Opt_set_dataContext); - } - public opt_collate_clause(): Opt_collate_clauseContext | null { - return this.getRuleContext(0, Opt_collate_clauseContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_type_cmd; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_type_cmd) { - listener.enterAlter_type_cmd(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_type_cmd) { - listener.exitAlter_type_cmd(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_type_cmd) { - return visitor.visitAlter_type_cmd(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class CloseportalstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CLOSE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CLOSE, 0)!; - } - public cursor_name(): Cursor_nameContext | null { - return this.getRuleContext(0, Cursor_nameContext); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_closeportalstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCloseportalstmt) { - listener.enterCloseportalstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCloseportalstmt) { - listener.exitCloseportalstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCloseportalstmt) { - return visitor.visitCloseportalstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class CopystmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_COPY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_COPY, 0)!; - } - public table_name(): Table_nameContext | null { - return this.getRuleContext(0, Table_nameContext); - } - public copy_from(): Copy_fromContext | null { - return this.getRuleContext(0, Copy_fromContext); - } - public copy_file_name(): Copy_file_nameContext { - return this.getRuleContext(0, Copy_file_nameContext)!; - } - public copy_options(): Copy_optionsContext { - return this.getRuleContext(0, Copy_optionsContext)!; - } - public opt_binary(): Opt_binaryContext | null { - return this.getRuleContext(0, Opt_binaryContext); - } - public opt_column_list(): Opt_column_listContext | null { - return this.getRuleContext(0, Opt_column_listContext); - } - public opt_program(): Opt_programContext | null { - return this.getRuleContext(0, Opt_programContext); - } - public copy_delimiter(): Copy_delimiterContext | null { - return this.getRuleContext(0, Copy_delimiterContext); - } - public opt_with(): Opt_withContext | null { - return this.getRuleContext(0, Opt_withContext); - } - public where_clause(): Where_clauseContext | null { - return this.getRuleContext(0, Where_clauseContext); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public preparablestmt(): PreparablestmtContext | null { - return this.getRuleContext(0, PreparablestmtContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copystmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopystmt) { - listener.enterCopystmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopystmt) { - listener.exitCopystmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopystmt) { - return visitor.visitCopystmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Copy_fromContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copy_from; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopy_from) { - listener.enterCopy_from(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopy_from) { - listener.exitCopy_from(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopy_from) { - return visitor.visitCopy_from(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_programContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_PROGRAM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PROGRAM, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_program; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_program) { - listener.enterOpt_program(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_program) { - listener.exitOpt_program(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_program) { - return visitor.visitOpt_program(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Copy_file_nameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); - } - public KW_STDIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STDIN, 0); - } - public KW_STDOUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STDOUT, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copy_file_name; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopy_file_name) { - listener.enterCopy_file_name(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopy_file_name) { - listener.exitCopy_file_name(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopy_file_name) { - return visitor.visitCopy_file_name(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Copy_optionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public copy_opt_list(): Copy_opt_listContext | null { - return this.getRuleContext(0, Copy_opt_listContext); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public copy_generic_opt_list(): Copy_generic_opt_listContext | null { - return this.getRuleContext(0, Copy_generic_opt_listContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copy_options; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopy_options) { - listener.enterCopy_options(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopy_options) { - listener.exitCopy_options(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopy_options) { - return visitor.visitCopy_options(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Copy_opt_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public copy_opt_item(): Copy_opt_itemContext[]; - public copy_opt_item(i: number): Copy_opt_itemContext | null; - public copy_opt_item(i?: number): Copy_opt_itemContext[] | Copy_opt_itemContext | null { - if (i === undefined) { - return this.getRuleContexts(Copy_opt_itemContext); - } - - return this.getRuleContext(i, Copy_opt_itemContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copy_opt_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopy_opt_list) { - listener.enterCopy_opt_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopy_opt_list) { - listener.exitCopy_opt_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopy_opt_list) { - return visitor.visitCopy_opt_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Copy_opt_itemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_BINARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BINARY, 0); - } - public KW_FREEZE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FREEZE, 0); - } - public KW_DELIMITER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DELIMITER, 0); - } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); - } - public opt_as(): Opt_asContext | null { - return this.getRuleContext(0, Opt_asContext); - } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); - } - public KW_CSV(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CSV, 0); - } - public KW_HEADER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_HEADER, 0); - } - public KW_QUOTE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_QUOTE, 0); - } - public KW_ESCAPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ESCAPE, 0); - } - public KW_FORCE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FORCE, 0); - } - public column_list(): Column_listContext | null { - return this.getRuleContext(0, Column_listContext); - } - public STAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.STAR, 0); - } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); - } - public KW_ENCODING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ENCODING, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copy_opt_item; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopy_opt_item) { - listener.enterCopy_opt_item(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopy_opt_item) { - listener.exitCopy_opt_item(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopy_opt_item) { - return visitor.visitCopy_opt_item(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_binaryContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_BINARY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BINARY, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_binary; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_binary) { - listener.enterOpt_binary(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_binary) { - listener.exitOpt_binary(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_binary) { - return visitor.visitOpt_binary(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Copy_delimiterContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_DELIMITERS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DELIMITERS, 0)!; - } - public sconst(): SconstContext { - return this.getRuleContext(0, SconstContext)!; - } - public opt_using(): Opt_usingContext | null { - return this.getRuleContext(0, Opt_usingContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copy_delimiter; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopy_delimiter) { - listener.enterCopy_delimiter(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopy_delimiter) { - listener.exitCopy_delimiter(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopy_delimiter) { - return visitor.visitCopy_delimiter(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_usingContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_using; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_using) { - listener.enterOpt_using(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_using) { - listener.exitOpt_using(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_using) { - return visitor.visitOpt_using(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Copy_generic_opt_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public copy_generic_opt_elem(): Copy_generic_opt_elemContext[]; - public copy_generic_opt_elem(i: number): Copy_generic_opt_elemContext | null; - public copy_generic_opt_elem(i?: number): Copy_generic_opt_elemContext[] | Copy_generic_opt_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Copy_generic_opt_elemContext); - } - - return this.getRuleContext(i, Copy_generic_opt_elemContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copy_generic_opt_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopy_generic_opt_list) { - listener.enterCopy_generic_opt_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopy_generic_opt_list) { - listener.exitCopy_generic_opt_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopy_generic_opt_list) { - return visitor.visitCopy_generic_opt_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Copy_generic_opt_elemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public collabel(): CollabelContext { - return this.getRuleContext(0, CollabelContext)!; - } - public copy_generic_opt_arg(): Copy_generic_opt_argContext | null { - return this.getRuleContext(0, Copy_generic_opt_argContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copy_generic_opt_elem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopy_generic_opt_elem) { - listener.enterCopy_generic_opt_elem(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopy_generic_opt_elem) { - listener.exitCopy_generic_opt_elem(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopy_generic_opt_elem) { - return visitor.visitCopy_generic_opt_elem(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Copy_generic_opt_argContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public opt_boolean_or_string(): Opt_boolean_or_stringContext | null { - return this.getRuleContext(0, Opt_boolean_or_stringContext); - } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); - } - public STAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.STAR, 0); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public copy_generic_opt_arg_list(): Copy_generic_opt_arg_listContext | null { - return this.getRuleContext(0, Copy_generic_opt_arg_listContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copy_generic_opt_arg; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopy_generic_opt_arg) { - listener.enterCopy_generic_opt_arg(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopy_generic_opt_arg) { - listener.exitCopy_generic_opt_arg(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopy_generic_opt_arg) { - return visitor.visitCopy_generic_opt_arg(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Copy_generic_opt_arg_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public copy_generic_opt_arg_list_item(): Copy_generic_opt_arg_list_itemContext[]; - public copy_generic_opt_arg_list_item(i: number): Copy_generic_opt_arg_list_itemContext | null; - public copy_generic_opt_arg_list_item(i?: number): Copy_generic_opt_arg_list_itemContext[] | Copy_generic_opt_arg_list_itemContext | null { - if (i === undefined) { - return this.getRuleContexts(Copy_generic_opt_arg_list_itemContext); - } - - return this.getRuleContext(i, Copy_generic_opt_arg_list_itemContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copy_generic_opt_arg_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopy_generic_opt_arg_list) { - listener.enterCopy_generic_opt_arg_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopy_generic_opt_arg_list) { - listener.exitCopy_generic_opt_arg_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopy_generic_opt_arg_list) { - return visitor.visitCopy_generic_opt_arg_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Copy_generic_opt_arg_list_itemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public opt_boolean_or_string_column(): Opt_boolean_or_string_columnContext { - return this.getRuleContext(0, Opt_boolean_or_string_columnContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_copy_generic_opt_arg_list_item; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCopy_generic_opt_arg_list_item) { - listener.enterCopy_generic_opt_arg_list_item(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCopy_generic_opt_arg_list_item) { - listener.exitCopy_generic_opt_arg_list_item(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCopy_generic_opt_arg_list_item) { - return visitor.visitCopy_generic_opt_arg_list_item(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class CreatestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createstmt; - } - public override copyFrom(ctx: CreatestmtContext): void { - super.copyFrom(ctx); - } -} -export class ColumnCreateTableContext extends CreatestmtContext { - public constructor(ctx: CreatestmtContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_TABLE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TABLE, 0)!; - } - public table_name_create(): Table_name_createContext { - return this.getRuleContext(0, Table_name_createContext)!; - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public KW_OF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OF, 0); - } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); - } - public KW_PARTITION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARTITION, 0); - } - public qualified_name(): Qualified_nameContext | null { - return this.getRuleContext(0, Qualified_nameContext); - } - public partitionboundspec(): PartitionboundspecContext | null { - return this.getRuleContext(0, PartitionboundspecContext); - } - public opttemp(): OpttempContext | null { - return this.getRuleContext(0, OpttempContext); - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public table_column_list(): Table_column_listContext | null { - return this.getRuleContext(0, Table_column_listContext); - } - public optinherit(): OptinheritContext | null { - return this.getRuleContext(0, OptinheritContext); - } - public optpartitionspec(): OptpartitionspecContext | null { - return this.getRuleContext(0, OptpartitionspecContext); - } - public table_access_method_clause(): Table_access_method_clauseContext | null { - return this.getRuleContext(0, Table_access_method_clauseContext); - } - public optwith(): OptwithContext | null { - return this.getRuleContext(0, OptwithContext); - } - public oncommitoption(): OncommitoptionContext | null { - return this.getRuleContext(0, OncommitoptionContext); - } - public opttablespace(): OpttablespaceContext | null { - return this.getRuleContext(0, OpttablespaceContext); - } - public opttypedtableelementlist(): OpttypedtableelementlistContext | null { - return this.getRuleContext(0, OpttypedtableelementlistContext); - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterColumnCreateTable) { - listener.enterColumnCreateTable(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitColumnCreateTable) { - listener.exitColumnCreateTable(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitColumnCreateTable) { - return visitor.visitColumnCreateTable(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class OpttempContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_TEMPORARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPORARY, 0); - } - public KW_TEMP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMP, 0); - } - public KW_LOCAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LOCAL, 0); - } - public KW_GLOBAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GLOBAL, 0); - } - public KW_UNLOGGED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNLOGGED, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opttemp; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpttemp) { - listener.enterOpttemp(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpttemp) { - listener.exitOpttemp(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpttemp) { - return visitor.visitOpttemp(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Table_column_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public tableelementlist(): TableelementlistContext { - return this.getRuleContext(0, TableelementlistContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_table_column_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTable_column_list) { - listener.enterTable_column_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTable_column_list) { - listener.exitTable_column_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTable_column_list) { - return visitor.visitTable_column_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class OpttableelementlistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public tableelementlist(): TableelementlistContext { - return this.getRuleContext(0, TableelementlistContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opttableelementlist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpttableelementlist) { - listener.enterOpttableelementlist(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpttableelementlist) { - listener.exitOpttableelementlist(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpttableelementlist) { - return visitor.visitOpttableelementlist(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class OpttypedtableelementlistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public typedtableelementlist(): TypedtableelementlistContext { - return this.getRuleContext(0, TypedtableelementlistContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opttypedtableelementlist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpttypedtableelementlist) { - listener.enterOpttypedtableelementlist(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpttypedtableelementlist) { - listener.exitOpttypedtableelementlist(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpttypedtableelementlist) { - return visitor.visitOpttypedtableelementlist(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class TableelementlistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public tableelement(): TableelementContext[]; - public tableelement(i: number): TableelementContext | null; - public tableelement(i?: number): TableelementContext[] | TableelementContext | null { - if (i === undefined) { - return this.getRuleContexts(TableelementContext); - } - - return this.getRuleContext(i, TableelementContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_tableelementlist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTableelementlist) { - listener.enterTableelementlist(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTableelementlist) { - listener.exitTableelementlist(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTableelementlist) { - return visitor.visitTableelementlist(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class TypedtableelementlistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public typedtableelement(): TypedtableelementContext[]; - public typedtableelement(i: number): TypedtableelementContext | null; - public typedtableelement(i?: number): TypedtableelementContext[] | TypedtableelementContext | null { - if (i === undefined) { - return this.getRuleContexts(TypedtableelementContext); - } - - return this.getRuleContext(i, TypedtableelementContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_typedtableelementlist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTypedtableelementlist) { - listener.enterTypedtableelementlist(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTypedtableelementlist) { - listener.exitTypedtableelementlist(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTypedtableelementlist) { - return visitor.visitTypedtableelementlist(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class TableelementContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public column_def(): Column_defContext | null { - return this.getRuleContext(0, Column_defContext); - } - public tablelikeclause(): TablelikeclauseContext | null { - return this.getRuleContext(0, TablelikeclauseContext); - } - public tableconstraint(): TableconstraintContext | null { - return this.getRuleContext(0, TableconstraintContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_tableelement; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTableelement) { - listener.enterTableelement(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTableelement) { - listener.exitTableelement(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTableelement) { - return visitor.visitTableelement(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class TypedtableelementContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public columnOptions(): ColumnOptionsContext | null { - return this.getRuleContext(0, ColumnOptionsContext); - } - public tableconstraint(): TableconstraintContext | null { - return this.getRuleContext(0, TableconstraintContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_typedtableelement; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTypedtableelement) { - listener.enterTypedtableelement(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTypedtableelement) { - listener.exitTypedtableelement(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTypedtableelement) { - return visitor.visitTypedtableelement(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Column_defContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public column_name_create(): Column_name_createContext { - return this.getRuleContext(0, Column_name_createContext)!; - } - public typename(): TypenameContext { - return this.getRuleContext(0, TypenameContext)!; - } - public colquallist(): ColquallistContext { - return this.getRuleContext(0, ColquallistContext)!; - } - public create_generic_options(): Create_generic_optionsContext | null { - return this.getRuleContext(0, Create_generic_optionsContext); - } - public storageCluase(): StorageCluaseContext | null { - return this.getRuleContext(0, StorageCluaseContext); - } - public compressionCluase(): CompressionCluaseContext | null { - return this.getRuleContext(0, CompressionCluaseContext); - } - public KW_COLLATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLLATE, 0); - } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); - } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); - } - public KW_OPTIONS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPTIONS, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_column_def; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterColumn_def) { - listener.enterColumn_def(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitColumn_def) { - listener.exitColumn_def(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitColumn_def) { - return visitor.visitColumn_def(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class CompressionCluaseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_COMPRESSION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_COMPRESSION, 0)!; - } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_compressionCluase; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCompressionCluase) { - listener.enterCompressionCluase(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCompressionCluase) { - listener.exitCompressionCluase(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCompressionCluase) { - return visitor.visitCompressionCluase(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class StorageCluaseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_STORAGE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_STORAGE, 0)!; - } - public KW_PLAIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PLAIN, 0); - } - public KW_EXTERNAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXTERNAL, 0); - } - public KW_EXTENDED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXTENDED, 0); - } - public KW_MAIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MAIN, 0); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_storageCluase; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStorageCluase) { - listener.enterStorageCluase(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStorageCluase) { - listener.exitStorageCluase(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStorageCluase) { - return visitor.visitStorageCluase(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class ColumnOptionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public column_name_create(): Column_name_createContext { - return this.getRuleContext(0, Column_name_createContext)!; - } - public colquallist(): ColquallistContext { - return this.getRuleContext(0, ColquallistContext)!; - } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); - } - public KW_OPTIONS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPTIONS, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_columnOptions; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterColumnOptions) { - listener.enterColumnOptions(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitColumnOptions) { - listener.exitColumnOptions(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitColumnOptions) { - return visitor.visitColumnOptions(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class ColquallistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public colconstraint(): ColconstraintContext[]; - public colconstraint(i: number): ColconstraintContext | null; - public colconstraint(i?: number): ColconstraintContext[] | ColconstraintContext | null { - if (i === undefined) { - return this.getRuleContexts(ColconstraintContext); - } - - return this.getRuleContext(i, ColconstraintContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_colquallist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterColquallist) { - listener.enterColquallist(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitColquallist) { - listener.exitColquallist(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitColquallist) { - return visitor.visitColquallist(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class ColconstraintContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public colconstraintelem(): ColconstraintelemContext { - return this.getRuleContext(0, ColconstraintelemContext)!; - } - public KW_CONSTRAINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); - } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); - } - public deferrable_trigger(): Deferrable_triggerContext | null { - return this.getRuleContext(0, Deferrable_triggerContext); - } - public initially_trigger(): Initially_triggerContext | null { - return this.getRuleContext(0, Initially_triggerContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_colconstraint; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterColconstraint) { - listener.enterColconstraint(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitColconstraint) { - listener.exitColconstraint(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitColconstraint) { - return visitor.visitColconstraint(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class ColconstraintelemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); - } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); - } - public KW_UNIQUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNIQUE, 0); - } - public opt_definition(): Opt_definitionContext | null { - return this.getRuleContext(0, Opt_definitionContext); - } - public optconstablespace(): OptconstablespaceContext | null { - return this.getRuleContext(0, OptconstablespaceContext); - } - public index_paramenters_create(): Index_paramenters_createContext | null { - return this.getRuleContext(0, Index_paramenters_createContext); - } - public nulls_distinct(): Nulls_distinctContext | null { - return this.getRuleContext(0, Nulls_distinctContext); - } - public KW_PRIMARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRIMARY, 0); - } - public KW_KEY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_KEY, 0); - } - public KW_CHECK(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CHECK, 0); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public opt_no_inherit(): Opt_no_inheritContext | null { - return this.getRuleContext(0, Opt_no_inheritContext); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public b_expr(): B_exprContext | null { - return this.getRuleContext(0, B_exprContext); - } - public KW_GENERATED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GENERATED, 0); - } - public generated_when(): Generated_whenContext | null { - return this.getRuleContext(0, Generated_whenContext); - } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); - } - public KW_IDENTITY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IDENTITY, 0); - } - public KW_STORED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STORED, 0); - } - public optparenthesizedseqoptlist(): OptparenthesizedseqoptlistContext | null { - return this.getRuleContext(0, OptparenthesizedseqoptlistContext); - } - public KW_REFERENCES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REFERENCES, 0); - } - public qualified_name(): Qualified_nameContext | null { - return this.getRuleContext(0, Qualified_nameContext); - } - public opt_column_list(): Opt_column_listContext | null { - return this.getRuleContext(0, Opt_column_listContext); - } - public key_match(): Key_matchContext | null { - return this.getRuleContext(0, Key_matchContext); - } - public key_actions(): Key_actionsContext | null { - return this.getRuleContext(0, Key_actionsContext); - } - public opt_collate(): Opt_collateContext | null { - return this.getRuleContext(0, Opt_collateContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_colconstraintelem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterColconstraintelem) { - listener.enterColconstraintelem(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitColconstraintelem) { - listener.exitColconstraintelem(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitColconstraintelem) { - return visitor.visitColconstraintelem(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Nulls_distinctContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_NULLS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_NULLS, 0)!; - } - public KW_DISTINCT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DISTINCT, 0)!; - } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_nulls_distinct; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterNulls_distinct) { - listener.enterNulls_distinct(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitNulls_distinct) { - listener.exitNulls_distinct(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitNulls_distinct) { - return visitor.visitNulls_distinct(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Generated_whenContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALWAYS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALWAYS, 0); - } - public KW_BY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BY, 0); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_generated_when; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGenerated_when) { - listener.enterGenerated_when(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGenerated_when) { - listener.exitGenerated_when(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGenerated_when) { - return visitor.visitGenerated_when(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Deferrable_triggerContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_DEFERRABLE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DEFERRABLE, 0)!; - } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_deferrable_trigger; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDeferrable_trigger) { - listener.enterDeferrable_trigger(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDeferrable_trigger) { - listener.exitDeferrable_trigger(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDeferrable_trigger) { - return visitor.visitDeferrable_trigger(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Initially_triggerContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_INITIALLY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INITIALLY, 0)!; - } - public KW_DEFERRED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFERRED, 0); - } - public KW_IMMEDIATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IMMEDIATE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_initially_trigger; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterInitially_trigger) { - listener.enterInitially_trigger(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitInitially_trigger) { - listener.exitInitially_trigger(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitInitially_trigger) { - return visitor.visitInitially_trigger(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class TablelikeclauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_LIKE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_LIKE, 0)!; - } - public qualified_name(): Qualified_nameContext { - return this.getRuleContext(0, Qualified_nameContext)!; - } - public tablelikeoptionlist(): TablelikeoptionlistContext { - return this.getRuleContext(0, TablelikeoptionlistContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_tablelikeclause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTablelikeclause) { - listener.enterTablelikeclause(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTablelikeclause) { - listener.exitTablelikeclause(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTablelikeclause) { - return visitor.visitTablelikeclause(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class TablelikeoptionlistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public tablelikeoption(): TablelikeoptionContext[]; - public tablelikeoption(i: number): TablelikeoptionContext | null; - public tablelikeoption(i?: number): TablelikeoptionContext[] | TablelikeoptionContext | null { - if (i === undefined) { - return this.getRuleContexts(TablelikeoptionContext); - } - - return this.getRuleContext(i, TablelikeoptionContext); - } - public KW_INCLUDING(): antlr.TerminalNode[]; - public KW_INCLUDING(i: number): antlr.TerminalNode | null; - public KW_INCLUDING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_INCLUDING); - } else { - return this.getToken(PostgreSqlParser.KW_INCLUDING, i); - } - } - public KW_EXCLUDING(): antlr.TerminalNode[]; - public KW_EXCLUDING(i: number): antlr.TerminalNode | null; - public KW_EXCLUDING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_EXCLUDING); - } else { - return this.getToken(PostgreSqlParser.KW_EXCLUDING, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_tablelikeoptionlist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTablelikeoptionlist) { - listener.enterTablelikeoptionlist(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTablelikeoptionlist) { - listener.exitTablelikeoptionlist(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTablelikeoptionlist) { - return visitor.visitTablelikeoptionlist(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class TablelikeoptionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_COMMENTS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COMMENTS, 0); - } - public KW_CONSTRAINTS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONSTRAINTS, 0); - } - public KW_DEFAULTS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULTS, 0); - } - public KW_IDENTITY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IDENTITY, 0); - } - public KW_GENERATED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GENERATED, 0); - } - public KW_INDEXES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INDEXES, 0); - } - public KW_STATISTICS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); - } - public KW_STORAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STORAGE, 0); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_tablelikeoption; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTablelikeoption) { - listener.enterTablelikeoption(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTablelikeoption) { - listener.exitTablelikeoption(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTablelikeoption) { - return visitor.visitTablelikeoption(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class TableconstraintContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CONSTRAINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); - } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); - } - public constraintelem(): ConstraintelemContext { - return this.getRuleContext(0, ConstraintelemContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_tableconstraint; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTableconstraint) { - listener.enterTableconstraint(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTableconstraint) { - listener.exitTableconstraint(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTableconstraint) { - return visitor.visitTableconstraint(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class ConstraintelemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CHECK(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CHECK, 0); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public constraintattributespec(): ConstraintattributespecContext | null { - return this.getRuleContext(0, ConstraintattributespecContext); - } - public KW_UNIQUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNIQUE, 0); - } - public column_list(): Column_listContext | null { - return this.getRuleContext(0, Column_listContext); - } - public existingindex(): ExistingindexContext | null { - return this.getRuleContext(0, ExistingindexContext); - } - public opt_c_include(): Opt_c_includeContext | null { - return this.getRuleContext(0, Opt_c_includeContext); - } - public opt_definition(): Opt_definitionContext | null { - return this.getRuleContext(0, Opt_definitionContext); - } - public optconstablespace(): OptconstablespaceContext | null { - return this.getRuleContext(0, OptconstablespaceContext); - } - public KW_PRIMARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRIMARY, 0); - } - public KW_KEY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_KEY, 0); - } - public KW_EXCLUDE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXCLUDE, 0); - } - public exclusionconstraintlist(): ExclusionconstraintlistContext | null { - return this.getRuleContext(0, ExclusionconstraintlistContext); - } - public access_method_clause(): Access_method_clauseContext | null { - return this.getRuleContext(0, Access_method_clauseContext); - } - public exclusionwhereclause(): ExclusionwhereclauseContext | null { - return this.getRuleContext(0, ExclusionwhereclauseContext); - } - public KW_FOREIGN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); - } - public KW_REFERENCES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REFERENCES, 0); - } - public qualified_name(): Qualified_nameContext | null { - return this.getRuleContext(0, Qualified_nameContext); - } - public opt_column_list(): Opt_column_listContext | null { - return this.getRuleContext(0, Opt_column_listContext); - } - public key_match(): Key_matchContext | null { - return this.getRuleContext(0, Key_matchContext); - } - public key_actions(): Key_actionsContext | null { - return this.getRuleContext(0, Key_actionsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_constraintelem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterConstraintelem) { - listener.enterConstraintelem(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitConstraintelem) { - listener.exitConstraintelem(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitConstraintelem) { - return visitor.visitConstraintelem(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_no_inheritContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_NO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_NO, 0)!; - } - public KW_INHERIT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INHERIT, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_no_inherit; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_no_inherit) { - listener.enterOpt_no_inherit(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_no_inherit) { - listener.exitOpt_no_inherit(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_no_inherit) { - return visitor.visitOpt_no_inherit(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_column_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public column_list(): Column_listContext { - return this.getRuleContext(0, Column_listContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_column_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_column_list) { - listener.enterOpt_column_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_column_list) { - listener.exitOpt_column_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_column_list) { - return visitor.visitOpt_column_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_column_list_createContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public column_list_create(): Column_list_createContext { - return this.getRuleContext(0, Column_list_createContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_column_list_create; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_column_list_create) { - listener.enterOpt_column_list_create(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_column_list_create) { - listener.exitOpt_column_list_create(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_column_list_create) { - return visitor.visitOpt_column_list_create(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Column_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public column_name(): Column_nameContext[]; - public column_name(i: number): Column_nameContext | null; - public column_name(i?: number): Column_nameContext[] | Column_nameContext | null { - if (i === undefined) { - return this.getRuleContexts(Column_nameContext); - } - - return this.getRuleContext(i, Column_nameContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_column_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterColumn_list) { - listener.enterColumn_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitColumn_list) { - listener.exitColumn_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitColumn_list) { - return visitor.visitColumn_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - + case PostgreSqlParser.KW_INNER: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_ISNULL: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_LIKE: + case PostgreSqlParser.KW_NATURAL: + case PostgreSqlParser.KW_NOTNULL: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_OVERLAPS: + case PostgreSqlParser.KW_RIGHT: + case PostgreSqlParser.KW_SIMILAR: + case PostgreSqlParser.KW_VERBOSE: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_END: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_TABLESAMPLE: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 7513; + this.collabel(); + } + break; + case PostgreSqlParser.STAR: + { + this.state = 7514; + this.match(PostgreSqlParser.STAR); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + case PostgreSqlParser.OPEN_BRACKET: + this.enterOuterAlt(localContext, 2); + { + this.state = 7517; + this.match(PostgreSqlParser.OPEN_BRACKET); + this.state = 7526; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1032, this.context) ) { + case 1: + { + this.state = 7518; + this.expression(); + } + break; + case 2: + { + this.state = 7520; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { + { + this.state = 7519; + this.expression(); + } + } -export class Column_list_createContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public column_name_create(): Column_name_createContext[]; - public column_name_create(i: number): Column_name_createContext | null; - public column_name_create(i?: number): Column_name_createContext[] | Column_name_createContext | null { - if (i === undefined) { - return this.getRuleContexts(Column_name_createContext); - } + this.state = 7522; + this.match(PostgreSqlParser.COLON); + this.state = 7524; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { + { + this.state = 7523; + this.expression(); + } + } - return this.getRuleContext(i, Column_name_createContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_column_list_create; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterColumn_list_create) { - listener.enterColumn_list_create(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitColumn_list_create) { - listener.exitColumn_list_create(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitColumn_list_create) { - return visitor.visitColumn_list_create(this); - } else { - return visitor.visitChildren(this); + } + break; + } + this.state = 7528; + this.match(PostgreSqlParser.CLOSE_BRACKET); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } - } -} - - -export class Opt_c_includeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_INCLUDE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INCLUDE, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public column_list(): Column_listContext { - return this.getRuleContext(0, Column_listContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_c_include; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_c_include) { - listener.enterOpt_c_include(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_c_include) { - listener.exitOpt_c_include(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_c_include) { - return visitor.visitOpt_c_include(this); - } else { - return visitor.visitChildren(this); + public indirection(): IndirectionContext { + let localContext = new IndirectionContext(this.context, this.state); + this.enterRule(localContext, 752, PostgreSqlParser.RULE_indirection); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 7532; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + { + this.state = 7531; + this.indirection_el(); + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 7534; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1034, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + } } - } -} - - -export class Key_matchContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_MATCH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_MATCH, 0)!; - } - public KW_FULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FULL, 0); - } - public KW_PARTIAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARTIAL, 0); - } - public KW_SIMPLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SIMPLE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_key_match; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterKey_match) { - listener.enterKey_match(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitKey_match) { - listener.exitKey_match(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitKey_match) { - return visitor.visitKey_match(this); - } else { - return visitor.visitChildren(this); + public opt_indirection(): Opt_indirectionContext { + let localContext = new Opt_indirectionContext(this.context, this.state); + this.enterRule(localContext, 754, PostgreSqlParser.RULE_opt_indirection); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 7539; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1035, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 7536; + this.indirection_el(); + } + } + } + this.state = 7541; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1035, this.context); + } + } } - } -} - - -export class ExclusionconstraintlistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public exclusionconstraintelem(): ExclusionconstraintelemContext[]; - public exclusionconstraintelem(i: number): ExclusionconstraintelemContext | null; - public exclusionconstraintelem(i?: number): ExclusionconstraintelemContext[] | ExclusionconstraintelemContext | null { - if (i === undefined) { - return this.getRuleContexts(ExclusionconstraintelemContext); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - - return this.getRuleContext(i, ExclusionconstraintelemContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_exclusionconstraintlist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExclusionconstraintlist) { - listener.enterExclusionconstraintlist(this); + finally { + this.exitRule(); } + return localContext; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExclusionconstraintlist) { - listener.exitExclusionconstraintlist(this); + public target_list(): Target_listContext { + let localContext = new Target_listContext(this.context, this.state); + this.enterRule(localContext, 756, PostgreSqlParser.RULE_target_list); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 7542; + this.target_el(); + this.state = 7547; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1036, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 7543; + this.match(PostgreSqlParser.COMMA); + this.state = 7544; + this.target_el(); + } + } + } + this.state = 7549; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1036, this.context); + } + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExclusionconstraintlist) { - return visitor.visitExclusionconstraintlist(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } -} - - -export class ExclusionconstraintelemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public index_elem(): Index_elemContext { - return this.getRuleContext(0, Index_elemContext)!; - } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; - } - public any_operator(): Any_operatorContext | null { - return this.getRuleContext(0, Any_operatorContext); - } - public KW_OPERATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_exclusionconstraintelem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExclusionconstraintelem) { - listener.enterExclusionconstraintelem(this); + finally { + this.exitRule(); } + return localContext; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExclusionconstraintelem) { - listener.exitExclusionconstraintelem(this); + public target_el(): Target_elContext { + let localContext = new Target_elContext(this.context, this.state); + this.enterRule(localContext, 758, PostgreSqlParser.RULE_target_el); + try { + this.state = 7558; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1038, this.context) ) { + case 1: + localContext = new Target_labelContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7550; + this.column_expr_noparen(); + this.state = 7555; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1037, this.context) ) { + case 1: + { + this.state = 7551; + this.match(PostgreSqlParser.KW_AS); + this.state = 7552; + this.collabel(); + } + break; + case 2: + { + this.state = 7553; + this.identifier(); + } + break; + case 3: + // tslint:disable-next-line:no-empty + { + } + break; + } + } + break; + case 2: + localContext = new Target_starContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 7557; + this.match(PostgreSqlParser.STAR); + } + break; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExclusionconstraintelem) { - return visitor.visitExclusionconstraintelem(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } -} - - -export class ExclusionwhereclauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_WHERE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WHERE, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_exclusionwhereclause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExclusionwhereclause) { - listener.enterExclusionwhereclause(this); + finally { + this.exitRule(); } + return localContext; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExclusionwhereclause) { - listener.exitExclusionwhereclause(this); + public qualified_name_list(): Qualified_name_listContext { + let localContext = new Qualified_name_listContext(this.context, this.state); + this.enterRule(localContext, 760, PostgreSqlParser.RULE_qualified_name_list); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7560; + this.qualified_name(); + this.state = 7565; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 7561; + this.match(PostgreSqlParser.COMMA); + this.state = 7562; + this.qualified_name(); + } + } + this.state = 7567; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExclusionwhereclause) { - return visitor.visitExclusionwhereclause(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } -} - - -export class Key_actionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public key_update(): Key_updateContext | null { - return this.getRuleContext(0, Key_updateContext); - } - public key_delete(): Key_deleteContext | null { - return this.getRuleContext(0, Key_deleteContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_key_actions; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterKey_actions) { - listener.enterKey_actions(this); + finally { + this.exitRule(); } + return localContext; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitKey_actions) { - listener.exitKey_actions(this); + public table_name_list(): Table_name_listContext { + let localContext = new Table_name_listContext(this.context, this.state); + this.enterRule(localContext, 762, PostgreSqlParser.RULE_table_name_list); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7568; + this.table_name(); + this.state = 7573; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 7569; + this.match(PostgreSqlParser.COMMA); + this.state = 7570; + this.table_name(); + } + } + this.state = 7575; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitKey_actions) { - return visitor.visitKey_actions(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } -} - - -export class Key_updateContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; - } - public KW_UPDATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_UPDATE, 0)!; - } - public key_action(): Key_actionContext { - return this.getRuleContext(0, Key_actionContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_key_update; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterKey_update) { - listener.enterKey_update(this); + finally { + this.exitRule(); } + return localContext; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitKey_update) { - listener.exitKey_update(this); + public schema_name_list(): Schema_name_listContext { + let localContext = new Schema_name_listContext(this.context, this.state); + this.enterRule(localContext, 764, PostgreSqlParser.RULE_schema_name_list); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7576; + this.schema_name(); + this.state = 7581; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 7577; + this.match(PostgreSqlParser.COMMA); + this.state = 7578; + this.schema_name(); + } + } + this.state = 7583; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitKey_update) { - return visitor.visitKey_update(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } -} - - -export class Key_deleteContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; - } - public KW_DELETE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DELETE, 0)!; - } - public key_action(): Key_actionContext { - return this.getRuleContext(0, Key_actionContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_key_delete; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterKey_delete) { - listener.enterKey_delete(this); + finally { + this.exitRule(); } + return localContext; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitKey_delete) { - listener.exitKey_delete(this); + public database_nameList(): Database_nameListContext { + let localContext = new Database_nameListContext(this.context, this.state); + this.enterRule(localContext, 766, PostgreSqlParser.RULE_database_nameList); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7584; + this.database_name(); + this.state = 7589; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 7585; + this.match(PostgreSqlParser.COMMA); + this.state = 7586; + this.database_name(); + } + } + this.state = 7591; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitKey_delete) { - return visitor.visitKey_delete(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Key_actionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); - } - public KW_ACTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ACTION, 0); - } - public KW_RESTRICT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESTRICT, 0); - } - public KW_CASCADE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CASCADE, 0); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public column_list(): Column_listContext | null { - return this.getRuleContext(0, Column_listContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_key_action; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterKey_action) { - listener.enterKey_action(this); + public tablespace_name_create(): Tablespace_name_createContext { + let localContext = new Tablespace_name_createContext(this.context, this.state); + this.enterRule(localContext, 768, PostgreSqlParser.RULE_tablespace_name_create); + try { + localContext = new TablespaceNameCreateContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7592; + this.qualified_name(); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitKey_action) { - listener.exitKey_action(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitKey_action) { - return visitor.visitKey_action(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class OptinheritContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_INHERITS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INHERITS, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public qualified_name_list(): Qualified_name_listContext { - return this.getRuleContext(0, Qualified_name_listContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_optinherit; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOptinherit) { - listener.enterOptinherit(this); + public tablespace_name(): Tablespace_nameContext { + let localContext = new Tablespace_nameContext(this.context, this.state); + this.enterRule(localContext, 770, PostgreSqlParser.RULE_tablespace_name); + try { + localContext = new TablespaceNameContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7594; + this.qualified_name(); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOptinherit) { - listener.exitOptinherit(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOptinherit) { - return visitor.visitOptinherit(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class OptpartitionspecContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public partitionspec(): PartitionspecContext { - return this.getRuleContext(0, PartitionspecContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_optpartitionspec; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOptpartitionspec) { - listener.enterOptpartitionspec(this); + public table_name_create(): Table_name_createContext { + let localContext = new Table_name_createContext(this.context, this.state); + this.enterRule(localContext, 772, PostgreSqlParser.RULE_table_name_create); + try { + localContext = new TableNameCreateContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7596; + this.qualified_name(); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOptpartitionspec) { - listener.exitOptpartitionspec(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOptpartitionspec) { - return visitor.visitOptpartitionspec(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class PartitionspecContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_PARTITION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PARTITION, 0)!; - } - public KW_BY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BY, 0)!; - } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public part_params(): Part_paramsContext { - return this.getRuleContext(0, Part_paramsContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_partitionspec; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPartitionspec) { - listener.enterPartitionspec(this); + public table_name(): Table_nameContext { + let localContext = new Table_nameContext(this.context, this.state); + this.enterRule(localContext, 774, PostgreSqlParser.RULE_table_name); + try { + localContext = new TableNameContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7598; + this.qualified_name(); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPartitionspec) { - listener.exitPartitionspec(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPartitionspec) { - return visitor.visitPartitionspec(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Part_paramsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public part_elem(): Part_elemContext[]; - public part_elem(i: number): Part_elemContext | null; - public part_elem(i?: number): Part_elemContext[] | Part_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Part_elemContext); + public view_name_create(): View_name_createContext { + let localContext = new View_name_createContext(this.context, this.state); + this.enterRule(localContext, 776, PostgreSqlParser.RULE_view_name_create); + try { + localContext = new ViewNameCreateContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7600; + this.qualified_name(); + } } - - return this.getRuleContext(i, Part_elemContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_part_params; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPart_params) { - listener.enterPart_params(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPart_params) { - listener.exitPart_params(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPart_params) { - return visitor.visitPart_params(this); - } else { - return visitor.visitChildren(this); + public view_name(): View_nameContext { + let localContext = new View_nameContext(this.context, this.state); + this.enterRule(localContext, 778, PostgreSqlParser.RULE_view_name); + try { + localContext = new ViewNameContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7602; + this.any_name(); + } } - } -} - - -export class Part_elemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public column_name(): Column_nameContext | null { - return this.getRuleContext(0, Column_nameContext); - } - public opt_collate(): Opt_collateContext | null { - return this.getRuleContext(0, Opt_collateContext); - } - public opt_class(): Opt_classContext | null { - return this.getRuleContext(0, Opt_classContext); - } - public func_expr_windowless(): Func_expr_windowlessContext | null { - return this.getRuleContext(0, Func_expr_windowlessContext); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_part_elem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPart_elem) { - listener.enterPart_elem(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPart_elem) { - listener.exitPart_elem(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPart_elem) { - return visitor.visitPart_elem(this); - } else { - return visitor.visitChildren(this); + public qualified_name(): Qualified_nameContext { + let localContext = new Qualified_nameContext(this.context, this.state); + this.enterRule(localContext, 780, PostgreSqlParser.RULE_qualified_name); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7604; + this.colid(); + this.state = 7606; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1043, this.context) ) { + case 1: + { + this.state = 7605; + this.indirection(); + } + break; + } + } } - } -} - - -export class Table_access_method_clauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_table_access_method_clause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTable_access_method_clause) { - listener.enterTable_access_method_clause(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTable_access_method_clause) { - listener.exitTable_access_method_clause(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTable_access_method_clause) { - return visitor.visitTable_access_method_clause(this); - } else { - return visitor.visitChildren(this); + public tablespace_name_list(): Tablespace_name_listContext { + let localContext = new Tablespace_name_listContext(this.context, this.state); + this.enterRule(localContext, 782, PostgreSqlParser.RULE_tablespace_name_list); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7608; + this.tablespace_name(); + this.state = 7613; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 7609; + this.match(PostgreSqlParser.COMMA); + this.state = 7610; + this.tablespace_name(); + } + } + this.state = 7615; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } } - } -} - - -export class OptwithContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); - } - public reloptions(): ReloptionsContext | null { - return this.getRuleContext(0, ReloptionsContext); - } - public KW_WITHOUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); - } - public KW_OIDS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OIDS, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_optwith; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOptwith) { - listener.enterOptwith(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOptwith) { - listener.exitOptwith(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOptwith) { - return visitor.visitOptwith(this); - } else { - return visitor.visitChildren(this); + public name_list(): Name_listContext { + let localContext = new Name_listContext(this.context, this.state); + this.enterRule(localContext, 784, PostgreSqlParser.RULE_name_list); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7616; + this.colid(); + this.state = 7621; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 7617; + this.match(PostgreSqlParser.COMMA); + this.state = 7618; + this.colid(); + } + } + this.state = 7623; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } } - } -} - - -export class OncommitoptionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; - } - public KW_COMMIT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_COMMIT, 0)!; - } - public KW_DROP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DROP, 0); - } - public KW_DELETE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DELETE, 0); - } - public KW_ROWS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROWS, 0); - } - public KW_PRESERVE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRESERVE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_oncommitoption; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOncommitoption) { - listener.enterOncommitoption(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOncommitoption) { - listener.exitOncommitoption(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOncommitoption) { - return visitor.visitOncommitoption(this); - } else { - return visitor.visitChildren(this); + public database_name_create(): Database_name_createContext { + let localContext = new Database_name_createContext(this.context, this.state); + this.enterRule(localContext, 786, PostgreSqlParser.RULE_database_name_create); + try { + localContext = new DatabaseNameCreateContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7624; + this.any_name(); + } } - } -} - - -export class OpttablespaceContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_TABLESPACE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0)!; - } - public tablespace_name(): Tablespace_nameContext { - return this.getRuleContext(0, Tablespace_nameContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opttablespace; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpttablespace) { - listener.enterOpttablespace(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpttablespace) { - listener.exitOpttablespace(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpttablespace) { - return visitor.visitOpttablespace(this); - } else { - return visitor.visitChildren(this); + public database_name(): Database_nameContext { + let localContext = new Database_nameContext(this.context, this.state); + this.enterRule(localContext, 788, PostgreSqlParser.RULE_database_name); + try { + localContext = new DatabaseNameContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7626; + this.any_name(); + } } - } -} - - -export class Index_paramenters_createContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public opt_include(): Opt_includeContext | null { - return this.getRuleContext(0, Opt_includeContext); - } - public with_clause(): With_clauseContext | null { - return this.getRuleContext(0, With_clauseContext); - } - public optconstablespace(): OptconstablespaceContext | null { - return this.getRuleContext(0, OptconstablespaceContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_index_paramenters_create; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIndex_paramenters_create) { - listener.enterIndex_paramenters_create(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIndex_paramenters_create) { - listener.exitIndex_paramenters_create(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIndex_paramenters_create) { - return visitor.visitIndex_paramenters_create(this); - } else { - return visitor.visitChildren(this); + public schema_name(): Schema_nameContext { + let localContext = new Schema_nameContext(this.context, this.state); + this.enterRule(localContext, 790, PostgreSqlParser.RULE_schema_name); + try { + localContext = new SchemaNameContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7628; + this.any_name(); + } } - } -} - - -export class OptconstablespaceContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; - } - public KW_INDEX(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INDEX, 0)!; - } - public KW_TABLESPACE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0)!; - } - public tablespace_name(): Tablespace_nameContext { - return this.getRuleContext(0, Tablespace_nameContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_optconstablespace; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOptconstablespace) { - listener.enterOptconstablespace(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOptconstablespace) { - listener.exitOptconstablespace(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOptconstablespace) { - return visitor.visitOptconstablespace(this); - } else { - return visitor.visitChildren(this); + public routine_name_create(): Routine_name_createContext { + let localContext = new Routine_name_createContext(this.context, this.state); + this.enterRule(localContext, 792, PostgreSqlParser.RULE_routine_name_create); + try { + localContext = new RoutineNameCreateContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7630; + this.colid(); + } } - } -} - - -export class ExistingindexContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; - } - public KW_INDEX(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INDEX, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_existingindex; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExistingindex) { - listener.enterExistingindex(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExistingindex) { - listener.exitExistingindex(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExistingindex) { - return visitor.visitExistingindex(this); - } else { - return visitor.visitChildren(this); + public routine_name(): Routine_nameContext { + let localContext = new Routine_nameContext(this.context, this.state); + this.enterRule(localContext, 794, PostgreSqlParser.RULE_routine_name); + try { + localContext = new RoutineNameContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7632; + this.colid(); + } } - } -} - - -export class CreatestatsstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_STATISTICS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_STATISTICS, 0)!; - } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; - } - public KW_FROM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FROM, 0)!; - } - public from_list(): From_listContext { - return this.getRuleContext(0, From_listContext)!; - } - public column_expr_list(): Column_expr_listContext | null { - return this.getRuleContext(0, Column_expr_listContext); - } - public expr_list(): Expr_listContext | null { - return this.getRuleContext(0, Expr_listContext); - } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); - } - public opt_name_list(): Opt_name_listContext | null { - return this.getRuleContext(0, Opt_name_listContext); - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createstatsstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatestatsstmt) { - listener.enterCreatestatsstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatestatsstmt) { - listener.exitCreatestatsstmt(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatestatsstmt) { - return visitor.visitCreatestatsstmt(this); - } else { - return visitor.visitChildren(this); + public procedure_name(): Procedure_nameContext { + let localContext = new Procedure_nameContext(this.context, this.state); + this.enterRule(localContext, 796, PostgreSqlParser.RULE_procedure_name); + try { + this.state = 7638; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1046, this.context) ) { + case 1: + localContext = new ProcedureNameContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7634; + this.type_function_name(); + } + break; + case 2: + localContext = new ProcedureNameContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 7635; + this.colid(); + this.state = 7636; + this.indirection(); + } + break; + } } - } -} - - -export class AlterstatsstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_STATISTICS(): antlr.TerminalNode[]; - public KW_STATISTICS(i: number): antlr.TerminalNode | null; - public KW_STATISTICS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_STATISTICS); - } else { - return this.getToken(PostgreSqlParser.KW_STATISTICS, i); - } - } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; - } - public KW_SET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SET, 0)!; - } - public signediconst(): SignediconstContext { - return this.getRuleContext(0, SignediconstContext)!; - } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterstatsstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterstatsstmt) { - listener.enterAlterstatsstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterstatsstmt) { - listener.exitAlterstatsstmt(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterstatsstmt) { - return visitor.visitAlterstatsstmt(this); - } else { - return visitor.visitChildren(this); + public procedure_name_create(): Procedure_name_createContext { + let localContext = new Procedure_name_createContext(this.context, this.state); + this.enterRule(localContext, 798, PostgreSqlParser.RULE_procedure_name_create); + try { + this.state = 7644; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1047, this.context) ) { + case 1: + localContext = new ProcedureNameCreateContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7640; + this.type_function_name(); + } + break; + case 2: + localContext = new ProcedureNameCreateContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 7641; + this.colid(); + this.state = 7642; + this.indirection(); + } + break; + } } - } -} - - -export class CreateasstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createasstmt; - } - public override copyFrom(ctx: CreateasstmtContext): void { - super.copyFrom(ctx); - } -} -export class QueryCreateTableContext extends CreateasstmtContext { - public constructor(ctx: CreateasstmtContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_TABLE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TABLE, 0)!; - } - public create_as_target(): Create_as_targetContext { - return this.getRuleContext(0, Create_as_targetContext)!; - } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; - } - public selectstmt(): SelectstmtContext { - return this.getRuleContext(0, SelectstmtContext)!; - } - public opttemp(): OpttempContext | null { - return this.getRuleContext(0, OpttempContext); - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public opt_with_data(): Opt_with_dataContext | null { - return this.getRuleContext(0, Opt_with_dataContext); - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterQueryCreateTable) { - listener.enterQueryCreateTable(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitQueryCreateTable) { - listener.exitQueryCreateTable(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitQueryCreateTable) { - return visitor.visitQueryCreateTable(this); - } else { - return visitor.visitChildren(this); + public column_name(): Column_nameContext { + let localContext = new Column_nameContext(this.context, this.state); + this.enterRule(localContext, 800, PostgreSqlParser.RULE_column_name); + try { + this.state = 7650; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1048, this.context) ) { + case 1: + localContext = new ColumnNameContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7646; + this.colid(); + this.state = 7647; + this.opt_indirection(); + } + break; + case 2: + localContext = new ColumnNameMatchContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 7649; + if (!(this.shouldMatchEmpty())) { + throw this.createFailedPredicateException("this.shouldMatchEmpty()"); + } + } + break; + } } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; } -} - - -export class Create_as_targetContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public table_name_create(): Table_name_createContext { - return this.getRuleContext(0, Table_name_createContext)!; - } - public opt_column_list_create(): Opt_column_list_createContext | null { - return this.getRuleContext(0, Opt_column_list_createContext); - } - public table_access_method_clause(): Table_access_method_clauseContext | null { - return this.getRuleContext(0, Table_access_method_clauseContext); - } - public optwith(): OptwithContext | null { - return this.getRuleContext(0, OptwithContext); - } - public oncommitoption(): OncommitoptionContext | null { - return this.getRuleContext(0, OncommitoptionContext); - } - public opttablespace(): OpttablespaceContext | null { - return this.getRuleContext(0, OpttablespaceContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_create_as_target; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreate_as_target) { - listener.enterCreate_as_target(this); + public column_name_create(): Column_name_createContext { + let localContext = new Column_name_createContext(this.context, this.state); + this.enterRule(localContext, 802, PostgreSqlParser.RULE_column_name_create); + try { + localContext = new ColumnNameCreateContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7652; + this.colid(); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreate_as_target) { - listener.exitCreate_as_target(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreate_as_target) { - return visitor.visitCreate_as_target(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Opt_with_dataContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; - } - public KW_DATA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATA, 0); - } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_with_data; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_with_data) { - listener.enterOpt_with_data(this); + public function_name_create(): Function_name_createContext { + let localContext = new Function_name_createContext(this.context, this.state); + this.enterRule(localContext, 804, PostgreSqlParser.RULE_function_name_create); + try { + this.state = 7658; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1049, this.context) ) { + case 1: + localContext = new FunctionNameCreateContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7654; + this.type_function_name(); + } + break; + case 2: + localContext = new FunctionNameCreateContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 7655; + this.colid(); + this.state = 7656; + this.indirection(); + } + break; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_with_data) { - listener.exitOpt_with_data(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_with_data) { - return visitor.visitOpt_with_data(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class CreatematviewstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_creatematviewstmt; - } - public override copyFrom(ctx: CreatematviewstmtContext): void { - super.copyFrom(ctx); - } -} -export class CreateMaterializedViewContext extends CreatematviewstmtContext { - public constructor(ctx: CreatematviewstmtContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_MATERIALIZED(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0)!; - } - public KW_VIEW(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VIEW, 0)!; - } - public create_mv_target(): Create_mv_targetContext { - return this.getRuleContext(0, Create_mv_targetContext)!; - } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; - } - public selectstmt(): SelectstmtContext { - return this.getRuleContext(0, SelectstmtContext)!; - } - public optnolog(): OptnologContext | null { - return this.getRuleContext(0, OptnologContext); - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public opt_with_data(): Opt_with_dataContext | null { - return this.getRuleContext(0, Opt_with_dataContext); - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateMaterializedView) { - listener.enterCreateMaterializedView(this); + public function_name(): Function_nameContext { + let localContext = new Function_nameContext(this.context, this.state); + this.enterRule(localContext, 806, PostgreSqlParser.RULE_function_name); + try { + this.state = 7664; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1050, this.context) ) { + case 1: + localContext = new FunctionNameContext(localContext); + this.enterOuterAlt(localContext, 1); + { + this.state = 7660; + this.type_function_name(); + } + break; + case 2: + localContext = new FunctionNameContext(localContext); + this.enterOuterAlt(localContext, 2); + { + this.state = 7661; + this.colid(); + this.state = 7662; + this.indirection(); + } + break; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateMaterializedView) { - listener.exitCreateMaterializedView(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateMaterializedView) { - return visitor.visitCreateMaterializedView(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Create_mv_targetContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public view_name_create(): View_name_createContext { - return this.getRuleContext(0, View_name_createContext)!; - } - public opt_column_list_create(): Opt_column_list_createContext | null { - return this.getRuleContext(0, Opt_column_list_createContext); - } - public table_access_method_clause(): Table_access_method_clauseContext | null { - return this.getRuleContext(0, Table_access_method_clauseContext); - } - public opt_reloptions(): Opt_reloptionsContext | null { - return this.getRuleContext(0, Opt_reloptionsContext); - } - public opttablespace(): OpttablespaceContext | null { - return this.getRuleContext(0, OpttablespaceContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_create_mv_target; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreate_mv_target) { - listener.enterCreate_mv_target(this); + public sconst(): SconstContext { + let localContext = new SconstContext(this.context, this.state); + this.enterRule(localContext, 808, PostgreSqlParser.RULE_sconst); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7666; + this.anysconst(); + this.state = 7669; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1051, this.context) ) { + case 1: + { + this.state = 7667; + this.match(PostgreSqlParser.KW_UESCAPE); + this.state = 7668; + this.anysconst(); + } + break; + } + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreate_mv_target) { - listener.exitCreate_mv_target(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreate_mv_target) { - return visitor.visitCreate_mv_target(this); - } else { - return visitor.visitChildren(this); + public anysconst(): AnysconstContext { + let localContext = new AnysconstContext(this.context, this.state); + this.enterRule(localContext, 810, PostgreSqlParser.RULE_anysconst); + let _la: number; + try { + this.state = 7682; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.StringConstant: + this.enterOuterAlt(localContext, 1); + { + this.state = 7671; + this.match(PostgreSqlParser.StringConstant); + } + break; + case PostgreSqlParser.UnicodeEscapeStringConstant: + this.enterOuterAlt(localContext, 2); + { + this.state = 7672; + this.match(PostgreSqlParser.UnicodeEscapeStringConstant); + } + break; + case PostgreSqlParser.BeginDollarStringConstant: + this.enterOuterAlt(localContext, 3); + { + this.state = 7673; + this.match(PostgreSqlParser.BeginDollarStringConstant); + this.state = 7677; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 588) { + { + { + this.state = 7674; + this.match(PostgreSqlParser.DollarText); + } + } + this.state = 7679; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 7680; + this.match(PostgreSqlParser.EndDollarStringConstant); + } + break; + case PostgreSqlParser.EscapeStringConstant: + this.enterOuterAlt(localContext, 4); + { + this.state = 7681; + this.match(PostgreSqlParser.EscapeStringConstant); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } + finally { + this.exitRule(); + } + return localContext; } -} - + public signediconst(): SignediconstContext { + let localContext = new SignediconstContext(this.context, this.state); + this.enterRule(localContext, 812, PostgreSqlParser.RULE_signediconst); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7685; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 12 || _la === 13) { + { + this.state = 7684; + _la = this.tokenStream.LA(1); + if(!(_la === 12 || _la === 13)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } -export class OptnologContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_UNLOGGED(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_UNLOGGED, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_optnolog; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOptnolog) { - listener.enterOptnolog(this); + this.state = 7687; + this.match(PostgreSqlParser.Integral); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOptnolog) { - listener.exitOptnolog(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOptnolog) { - return visitor.visitOptnolog(this); - } else { - return visitor.visitChildren(this); + public rolespec(): RolespecContext { + let localContext = new RolespecContext(this.context, this.state); + this.enterRule(localContext, 814, PostgreSqlParser.RULE_rolespec); + try { + this.state = 7694; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_AUTHORIZATION: + case PostgreSqlParser.KW_BINARY: + case PostgreSqlParser.KW_COLLATION: + case PostgreSqlParser.KW_CONCURRENTLY: + case PostgreSqlParser.KW_CROSS: + case PostgreSqlParser.KW_CURRENT_SCHEMA: + case PostgreSqlParser.KW_FREEZE: + case PostgreSqlParser.KW_FULL: + case PostgreSqlParser.KW_ILIKE: + case PostgreSqlParser.KW_INNER: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_ISNULL: + case PostgreSqlParser.KW_JOIN: + case PostgreSqlParser.KW_LEFT: + case PostgreSqlParser.KW_LIKE: + case PostgreSqlParser.KW_NATURAL: + case PostgreSqlParser.KW_NOTNULL: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_OVERLAPS: + case PostgreSqlParser.KW_RIGHT: + case PostgreSqlParser.KW_SIMILAR: + case PostgreSqlParser.KW_VERBOSE: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_TABLESAMPLE: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + this.enterOuterAlt(localContext, 1); + { + this.state = 7689; + this.nonreservedword(); + } + break; + case PostgreSqlParser.KW_CURRENT_USER: + this.enterOuterAlt(localContext, 2); + { + this.state = 7690; + this.match(PostgreSqlParser.KW_CURRENT_USER); + } + break; + case PostgreSqlParser.KW_CURRENT_ROLE: + this.enterOuterAlt(localContext, 3); + { + this.state = 7691; + this.match(PostgreSqlParser.KW_CURRENT_ROLE); + } + break; + case PostgreSqlParser.KW_SESSION_USER: + this.enterOuterAlt(localContext, 4); + { + this.state = 7692; + this.match(PostgreSqlParser.KW_SESSION_USER); + } + break; + case PostgreSqlParser.KW_PUBLIC: + this.enterOuterAlt(localContext, 5); + { + this.state = 7693; + this.match(PostgreSqlParser.KW_PUBLIC); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } - } -} - - -export class RefreshmatviewstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_REFRESH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_REFRESH, 0)!; - } - public KW_MATERIALIZED(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0)!; - } - public KW_VIEW(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VIEW, 0)!; - } - public view_name(): View_nameContext { - return this.getRuleContext(0, View_nameContext)!; - } - public opt_concurrently(): Opt_concurrentlyContext | null { - return this.getRuleContext(0, Opt_concurrentlyContext); - } - public opt_with_data(): Opt_with_dataContext | null { - return this.getRuleContext(0, Opt_with_dataContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_refreshmatviewstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRefreshmatviewstmt) { - listener.enterRefreshmatviewstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRefreshmatviewstmt) { - listener.exitRefreshmatviewstmt(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRefreshmatviewstmt) { - return visitor.visitRefreshmatviewstmt(this); - } else { - return visitor.visitChildren(this); + public role_list(): Role_listContext { + let localContext = new Role_listContext(this.context, this.state); + this.enterRule(localContext, 816, PostgreSqlParser.RULE_role_list); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7696; + this.rolespec(); + this.state = 7701; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 7697; + this.match(PostgreSqlParser.COMMA); + this.state = 7698; + this.rolespec(); + } + } + this.state = 7703; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } } - } -} - - -export class CreateseqstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_SEQUENCE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0)!; - } - public qualified_name(): Qualified_nameContext { - return this.getRuleContext(0, Qualified_nameContext)!; - } - public opttemp(): OpttempContext | null { - return this.getRuleContext(0, OpttempContext); - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public optseqoptlist(): OptseqoptlistContext | null { - return this.getRuleContext(0, OptseqoptlistContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createseqstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateseqstmt) { - listener.enterCreateseqstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateseqstmt) { - listener.exitCreateseqstmt(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateseqstmt) { - return visitor.visitCreateseqstmt(this); - } else { - return visitor.visitChildren(this); + public colid(): ColidContext { + let localContext = new ColidContext(this.context, this.state); + this.enterRule(localContext, 818, PostgreSqlParser.RULE_colid); + try { + this.state = 7708; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1057, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 7704; + this.identifier(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 7705; + this.unreserved_keyword(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 7706; + this.col_name_keyword(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 7707; + this.plsql_unreserved_keyword(); + } + break; + } } - } -} - - -export class AlterseqstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_SEQUENCE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0)!; - } - public qualified_name(): Qualified_nameContext { - return this.getRuleContext(0, Qualified_nameContext)!; - } - public seqoptlist(): SeqoptlistContext { - return this.getRuleContext(0, SeqoptlistContext)!; - } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterseqstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterseqstmt) { - listener.enterAlterseqstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterseqstmt) { - listener.exitAlterseqstmt(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterseqstmt) { - return visitor.visitAlterseqstmt(this); - } else { - return visitor.visitChildren(this); + public type_function_name(): Type_function_nameContext { + let localContext = new Type_function_nameContext(this.context, this.state); + this.enterRule(localContext, 820, PostgreSqlParser.RULE_type_function_name); + try { + this.state = 7714; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1058, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 7710; + this.identifier(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 7711; + this.unreserved_keyword(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 7712; + this.plsql_unreserved_keyword(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 7713; + this.type_func_name_keyword(); + } + break; + } } - } -} - - -export class OptseqoptlistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public seqoptlist(): SeqoptlistContext { - return this.getRuleContext(0, SeqoptlistContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_optseqoptlist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOptseqoptlist) { - listener.enterOptseqoptlist(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOptseqoptlist) { - listener.exitOptseqoptlist(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOptseqoptlist) { - return visitor.visitOptseqoptlist(this); - } else { - return visitor.visitChildren(this); + public nonreservedword(): NonreservedwordContext { + let localContext = new NonreservedwordContext(this.context, this.state); + this.enterRule(localContext, 822, PostgreSqlParser.RULE_nonreservedword); + try { + this.state = 7720; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1059, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 7716; + this.identifier(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 7717; + this.unreserved_keyword(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 7718; + this.col_name_keyword(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 7719; + this.type_func_name_keyword(); + } + break; + } } - } -} - - -export class OptparenthesizedseqoptlistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public seqoptlist(): SeqoptlistContext { - return this.getRuleContext(0, SeqoptlistContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_optparenthesizedseqoptlist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOptparenthesizedseqoptlist) { - listener.enterOptparenthesizedseqoptlist(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOptparenthesizedseqoptlist) { - listener.exitOptparenthesizedseqoptlist(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOptparenthesizedseqoptlist) { - return visitor.visitOptparenthesizedseqoptlist(this); - } else { - return visitor.visitChildren(this); + public collabel(): CollabelContext { + let localContext = new CollabelContext(this.context, this.state); + this.enterRule(localContext, 824, PostgreSqlParser.RULE_collabel); + try { + this.state = 7725; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1060, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 7722; + this.nonreservedword(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 7723; + this.plsql_unreserved_keyword(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 7724; + this.reserved_keyword(); + } + break; + } } - } -} - - -export class SeqoptlistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public seqoptelem(): SeqoptelemContext[]; - public seqoptelem(i: number): SeqoptelemContext | null; - public seqoptelem(i?: number): SeqoptelemContext[] | SeqoptelemContext | null { - if (i === undefined) { - return this.getRuleContexts(SeqoptelemContext); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - - return this.getRuleContext(i, SeqoptelemContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_seqoptlist; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSeqoptlist) { - listener.enterSeqoptlist(this); + finally { + this.exitRule(); } + return localContext; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSeqoptlist) { - listener.exitSeqoptlist(this); + public identifier(): IdentifierContext { + let localContext = new IdentifierContext(this.context, this.state); + this.enterRule(localContext, 826, PostgreSqlParser.RULE_identifier); + try { + this.state = 7738; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.Identifier: + this.enterOuterAlt(localContext, 1); + { + this.state = 7727; + this.match(PostgreSqlParser.Identifier); + this.state = 7730; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1061, this.context) ) { + case 1: + { + this.state = 7728; + this.match(PostgreSqlParser.KW_UESCAPE); + this.state = 7729; + this.anysconst(); + } + break; + } + } + break; + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.EscapeStringConstant: + this.enterOuterAlt(localContext, 2); + { + this.state = 7732; + this.sconst(); + } + break; + case PostgreSqlParser.QuotedIdentifier: + this.enterOuterAlt(localContext, 3); + { + this.state = 7733; + this.match(PostgreSqlParser.QuotedIdentifier); + } + break; + case PostgreSqlParser.UnicodeQuotedIdentifier: + this.enterOuterAlt(localContext, 4); + { + this.state = 7734; + this.match(PostgreSqlParser.UnicodeQuotedIdentifier); + } + break; + case PostgreSqlParser.PLSQLVARIABLENAME: + this.enterOuterAlt(localContext, 5); + { + this.state = 7735; + this.match(PostgreSqlParser.PLSQLVARIABLENAME); + } + break; + case PostgreSqlParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localContext, 6); + { + this.state = 7736; + this.match(PostgreSqlParser.PLSQLIDENTIFIER); + } + break; + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + this.enterOuterAlt(localContext, 7); + { + this.state = 7737; + this.plsql_unreserved_keyword(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSeqoptlist) { - return visitor.visitSeqoptlist(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } -} - - -export class SeqoptelemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); - } - public simpletypename(): SimpletypenameContext | null { - return this.getRuleContext(0, SimpletypenameContext); - } - public KW_CACHE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CACHE, 0); - } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); - } - public KW_CYCLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CYCLE, 0); - } - public KW_INCREMENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INCREMENT, 0); - } - public opt_by(): Opt_byContext | null { - return this.getRuleContext(0, Opt_byContext); - } - public KW_MAXVALUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MAXVALUE, 0); - } - public KW_MINVALUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MINVALUE, 0); - } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); - } - public KW_OWNED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OWNED, 0); - } - public KW_BY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BY, 0); - } - public column_name(): Column_nameContext | null { - return this.getRuleContext(0, Column_nameContext); - } - public KW_SEQUENCE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); - } - public KW_NAME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NAME, 0); - } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); - } - public KW_START(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_START, 0); - } - public opt_with(): Opt_withContext | null { - return this.getRuleContext(0, Opt_withContext); - } - public KW_RESTART(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESTART, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_seqoptelem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSeqoptelem) { - listener.enterSeqoptelem(this); + finally { + this.exitRule(); } + return localContext; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSeqoptelem) { - listener.exitSeqoptelem(this); + public unreserved_keyword(): Unreserved_keywordContext { + let localContext = new Unreserved_keywordContext(this.context, this.state); + this.enterRule(localContext, 828, PostgreSqlParser.RULE_unreserved_keyword); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7740; + _la = this.tokenStream.LA(1); + if(!(((((_la - 124)) & ~0x1F) === 0 && ((1 << (_la - 124)) & 4294967265) !== 0) || ((((_la - 156)) & ~0x1F) === 0 && ((1 << (_la - 156)) & 4294967295) !== 0) || ((((_la - 188)) & ~0x1F) === 0 && ((1 << (_la - 188)) & 4294967295) !== 0) || ((((_la - 220)) & ~0x1F) === 0 && ((1 << (_la - 220)) & 4294705663) !== 0) || ((((_la - 252)) & ~0x1F) === 0 && ((1 << (_la - 252)) & 4294967295) !== 0) || ((((_la - 284)) & ~0x1F) === 0 && ((1 << (_la - 284)) & 4294967295) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & 4294967295) !== 0) || ((((_la - 348)) & ~0x1F) === 0 && ((1 << (_la - 348)) & 4294967295) !== 0) || ((((_la - 380)) & ~0x1F) === 0 && ((1 << (_la - 380)) & 127) !== 0) || ((((_la - 433)) & ~0x1F) === 0 && ((1 << (_la - 433)) & 4291821567) !== 0) || ((((_la - 465)) & ~0x1F) === 0 && ((1 << (_la - 465)) & 16770399) !== 0) || _la === 547 || _la === 548)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSeqoptelem) { - return visitor.visitSeqoptelem(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } -} - - -export class Opt_byContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_BY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BY, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_by; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_by) { - listener.enterOpt_by(this); + finally { + this.exitRule(); } + return localContext; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_by) { - listener.exitOpt_by(this); + public col_name_keyword(): Col_name_keywordContext { + let localContext = new Col_name_keywordContext(this.context, this.state); + this.enterRule(localContext, 830, PostgreSqlParser.RULE_col_name_keyword); + try { + this.state = 7793; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1063, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 7742; + this.match(PostgreSqlParser.KW_BETWEEN); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 7743; + this.match(PostgreSqlParser.KW_BIGINT); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 7744; + this.bit(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 7745; + this.match(PostgreSqlParser.KW_BOOLEAN); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 7746; + this.match(PostgreSqlParser.KW_CHAR); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 7747; + this.character(); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 7748; + this.match(PostgreSqlParser.KW_COALESCE); + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 7749; + this.match(PostgreSqlParser.KW_DEC); + } + break; + case 9: + this.enterOuterAlt(localContext, 9); + { + this.state = 7750; + this.match(PostgreSqlParser.KW_DECIMAL); + } + break; + case 10: + this.enterOuterAlt(localContext, 10); + { + this.state = 7751; + this.match(PostgreSqlParser.KW_EXISTS); + } + break; + case 11: + this.enterOuterAlt(localContext, 11); + { + this.state = 7752; + this.match(PostgreSqlParser.KW_EXTRACT); + } + break; + case 12: + this.enterOuterAlt(localContext, 12); + { + this.state = 7753; + this.match(PostgreSqlParser.KW_FLOAT); + } + break; + case 13: + this.enterOuterAlt(localContext, 13); + { + this.state = 7754; + this.match(PostgreSqlParser.KW_GREATEST); + } + break; + case 14: + this.enterOuterAlt(localContext, 14); + { + this.state = 7755; + this.match(PostgreSqlParser.KW_GROUPING); + } + break; + case 15: + this.enterOuterAlt(localContext, 15); + { + this.state = 7756; + this.match(PostgreSqlParser.KW_INOUT); + } + break; + case 16: + this.enterOuterAlt(localContext, 16); + { + this.state = 7757; + this.match(PostgreSqlParser.KW_INT); + } + break; + case 17: + this.enterOuterAlt(localContext, 17); + { + this.state = 7758; + this.match(PostgreSqlParser.KW_INTEGER); + } + break; + case 18: + this.enterOuterAlt(localContext, 18); + { + this.state = 7759; + this.match(PostgreSqlParser.KW_INTERVAL); + } + break; + case 19: + this.enterOuterAlt(localContext, 19); + { + this.state = 7760; + this.match(PostgreSqlParser.KW_LEAST); + } + break; + case 20: + this.enterOuterAlt(localContext, 20); + { + this.state = 7761; + this.match(PostgreSqlParser.KW_NATIONAL); + } + break; + case 21: + this.enterOuterAlt(localContext, 21); + { + this.state = 7762; + this.match(PostgreSqlParser.KW_NCHAR); + } + break; + case 22: + this.enterOuterAlt(localContext, 22); + { + this.state = 7763; + this.match(PostgreSqlParser.KW_NONE); + } + break; + case 23: + this.enterOuterAlt(localContext, 23); + { + this.state = 7764; + this.match(PostgreSqlParser.KW_NORMALIZE); + } + break; + case 24: + this.enterOuterAlt(localContext, 24); + { + this.state = 7765; + this.match(PostgreSqlParser.KW_NULLIF); + } + break; + case 25: + this.enterOuterAlt(localContext, 25); + { + this.state = 7766; + this.numeric(); + } + break; + case 26: + this.enterOuterAlt(localContext, 26); + { + this.state = 7767; + this.match(PostgreSqlParser.KW_OUT); + } + break; + case 27: + this.enterOuterAlt(localContext, 27); + { + this.state = 7768; + this.match(PostgreSqlParser.KW_OVERLAY); + } + break; + case 28: + this.enterOuterAlt(localContext, 28); + { + this.state = 7769; + this.match(PostgreSqlParser.KW_POSITION); + } + break; + case 29: + this.enterOuterAlt(localContext, 29); + { + this.state = 7770; + this.match(PostgreSqlParser.KW_PRECISION); + } + break; + case 30: + this.enterOuterAlt(localContext, 30); + { + this.state = 7771; + this.match(PostgreSqlParser.KW_REAL); + } + break; + case 31: + this.enterOuterAlt(localContext, 31); + { + this.state = 7772; + this.match(PostgreSqlParser.KW_ROW); + } + break; + case 32: + this.enterOuterAlt(localContext, 32); + { + this.state = 7773; + this.match(PostgreSqlParser.KW_SETOF); + } + break; + case 33: + this.enterOuterAlt(localContext, 33); + { + this.state = 7774; + this.match(PostgreSqlParser.KW_SMALLINT); + } + break; + case 34: + this.enterOuterAlt(localContext, 34); + { + this.state = 7775; + this.match(PostgreSqlParser.KW_SUBSTRING); + } + break; + case 35: + this.enterOuterAlt(localContext, 35); + { + this.state = 7776; + this.match(PostgreSqlParser.KW_TIME); + } + break; + case 36: + this.enterOuterAlt(localContext, 36); + { + this.state = 7777; + this.match(PostgreSqlParser.KW_TIMESTAMP); + } + break; + case 37: + this.enterOuterAlt(localContext, 37); + { + this.state = 7778; + this.match(PostgreSqlParser.KW_TREAT); + } + break; + case 38: + this.enterOuterAlt(localContext, 38); + { + this.state = 7779; + this.match(PostgreSqlParser.KW_TRIM); + } + break; + case 39: + this.enterOuterAlt(localContext, 39); + { + this.state = 7780; + this.match(PostgreSqlParser.KW_VALUES); + } + break; + case 40: + this.enterOuterAlt(localContext, 40); + { + this.state = 7781; + this.match(PostgreSqlParser.KW_VARCHAR); + } + break; + case 41: + this.enterOuterAlt(localContext, 41); + { + this.state = 7782; + this.match(PostgreSqlParser.KW_XMLATTRIBUTES); + } + break; + case 42: + this.enterOuterAlt(localContext, 42); + { + this.state = 7783; + this.match(PostgreSqlParser.KW_XMLCONCAT); + } + break; + case 43: + this.enterOuterAlt(localContext, 43); + { + this.state = 7784; + this.match(PostgreSqlParser.KW_XMLELEMENT); + } + break; + case 44: + this.enterOuterAlt(localContext, 44); + { + this.state = 7785; + this.match(PostgreSqlParser.KW_XMLEXISTS); + } + break; + case 45: + this.enterOuterAlt(localContext, 45); + { + this.state = 7786; + this.match(PostgreSqlParser.KW_XMLFOREST); + } + break; + case 46: + this.enterOuterAlt(localContext, 46); + { + this.state = 7787; + this.match(PostgreSqlParser.KW_XMLNAMESPACES); + } + break; + case 47: + this.enterOuterAlt(localContext, 47); + { + this.state = 7788; + this.match(PostgreSqlParser.KW_XMLPARSE); + } + break; + case 48: + this.enterOuterAlt(localContext, 48); + { + this.state = 7789; + this.match(PostgreSqlParser.KW_XMLPI); + } + break; + case 49: + this.enterOuterAlt(localContext, 49); + { + this.state = 7790; + this.match(PostgreSqlParser.KW_XMLROOT); + } + break; + case 50: + this.enterOuterAlt(localContext, 50); + { + this.state = 7791; + this.match(PostgreSqlParser.KW_XMLSERIALIZE); + } + break; + case 51: + this.enterOuterAlt(localContext, 51); + { + this.state = 7792; + this.match(PostgreSqlParser.KW_XMLTABLE); + } + break; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_by) { - return visitor.visitOpt_by(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } -} - - -export class NumericonlyContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public fconst(): FconstContext | null { - return this.getRuleContext(0, FconstContext); - } - public PLUS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.PLUS, 0); - } - public MINUS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.MINUS, 0); - } - public signediconst(): SignediconstContext | null { - return this.getRuleContext(0, SignediconstContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_numericonly; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterNumericonly) { - listener.enterNumericonly(this); + finally { + this.exitRule(); } + return localContext; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitNumericonly) { - listener.exitNumericonly(this); + public type_func_name_keyword(): Type_func_name_keywordContext { + let localContext = new Type_func_name_keywordContext(this.context, this.state); + this.enterRule(localContext, 832, PostgreSqlParser.RULE_type_func_name_keyword); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7795; + _la = this.tokenStream.LA(1); + if(!(((((_la - 106)) & ~0x1F) === 0 && ((1 << (_la - 106)) & 8126463) !== 0) || _la === 472)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitNumericonly) { - return visitor.visitNumericonly(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } -} - - -export class Numericonly_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public numericonly(): NumericonlyContext[]; - public numericonly(i: number): NumericonlyContext | null; - public numericonly(i?: number): NumericonlyContext[] | NumericonlyContext | null { - if (i === undefined) { - return this.getRuleContexts(NumericonlyContext); + finally { + this.exitRule(); } - - return this.getRuleContext(i, NumericonlyContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_numericonly_list; + return localContext; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterNumericonly_list) { - listener.enterNumericonly_list(this); + public reserved_keyword(): Reserved_keywordContext { + let localContext = new Reserved_keywordContext(this.context, this.state); + this.enterRule(localContext, 834, PostgreSqlParser.RULE_reserved_keyword); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7797; + _la = this.tokenStream.LA(1); + if(!(((((_la - 30)) & ~0x1F) === 0 && ((1 << (_la - 30)) & 4286578687) !== 0) || ((((_la - 62)) & ~0x1F) === 0 && ((1 << (_la - 62)) & 4294966783) !== 0) || ((((_la - 94)) & ~0x1F) === 0 && ((1 << (_la - 94)) & 4095) !== 0) || _la === 454)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitNumericonly_list) { - listener.exitNumericonly_list(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitNumericonly_list) { - return visitor.visitNumericonly_list(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} + public pl_block(): Pl_blockContext { + let localContext = new Pl_blockContext(this.context, this.state); + this.enterRule(localContext, 836, PostgreSqlParser.RULE_pl_block); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + { + this.state = 7800; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 18) { + { + this.state = 7799; + this.label_decl(); + } + } + this.state = 7812; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 178) { + { + this.state = 7802; + this.match(PostgreSqlParser.KW_DECLARE); + this.state = 7810; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1067, this.context) ) { + case 1: + { + this.state = 7806; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + this.state = 7806; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1065, this.context) ) { + case 1: + { + this.state = 7803; + this.decl_statement(); + } + break; + case 2: + { + this.state = 7804; + this.match(PostgreSqlParser.KW_DECLARE); + } + break; + case 3: + { + this.state = 7805; + this.label_decl(); + } + break; + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 7808; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1066, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + } + break; + } + } + } -export class CreateplangstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_LANGUAGE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public opt_or_replace(): Opt_or_replaceContext | null { - return this.getRuleContext(0, Opt_or_replaceContext); - } - public opt_trusted(): Opt_trustedContext | null { - return this.getRuleContext(0, Opt_trustedContext); - } - public opt_procedural(): Opt_proceduralContext | null { - return this.getRuleContext(0, Opt_proceduralContext); - } - public KW_HANDLER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_HANDLER, 0); - } - public handler_name(): Handler_nameContext | null { - return this.getRuleContext(0, Handler_nameContext); - } - public opt_inline_handler(): Opt_inline_handlerContext | null { - return this.getRuleContext(0, Opt_inline_handlerContext); - } - public opt_validator(): Opt_validatorContext | null { - return this.getRuleContext(0, Opt_validatorContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createplangstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateplangstmt) { - listener.enterCreateplangstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateplangstmt) { - listener.exitCreateplangstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateplangstmt) { - return visitor.visitCreateplangstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} + } + this.state = 7814; + this.match(PostgreSqlParser.KW_BEGIN); + this.state = 7818; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1069, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 7815; + this.proc_stmt(); + } + } + } + this.state = 7820; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1069, this.context); + } + this.state = 7822; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 517) { + { + this.state = 7821; + this.exception_sect(); + } + } + this.state = 7824; + this.match(PostgreSqlParser.KW_END); + this.state = 7826; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { + { + this.state = 7825; + this.any_identifier(); + } + } -export class Opt_trustedContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_TRUSTED(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TRUSTED, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_trusted; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_trusted) { - listener.enterOpt_trusted(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_trusted) { - listener.exitOpt_trusted(this); + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_trusted) { - return visitor.visitOpt_trusted(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } -} - - -export class Handler_nameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public attrs(): AttrsContext | null { - return this.getRuleContext(0, AttrsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_handler_name; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterHandler_name) { - listener.enterHandler_name(this); + finally { + this.exitRule(); } + return localContext; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitHandler_name) { - listener.exitHandler_name(this); + public label_decl(): Label_declContext { + let localContext = new Label_declContext(this.context, this.state); + this.enterRule(localContext, 838, PostgreSqlParser.RULE_label_decl); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7828; + this.match(PostgreSqlParser.LESS_LESS); + this.state = 7829; + this.any_identifier(); + this.state = 7830; + this.match(PostgreSqlParser.GREATER_GREATER); + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitHandler_name) { - return visitor.visitHandler_name(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); } + return localContext; } -} + public decl_statement(): Decl_statementContext { + let localContext = new Decl_statementContext(this.context, this.state); + this.enterRule(localContext, 840, PostgreSqlParser.RULE_decl_statement); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7832; + this.any_identifier(); + this.state = 7879; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1082, this.context) ) { + case 1: + { + this.state = 7833; + this.match(PostgreSqlParser.KW_ALIAS); + this.state = 7834; + this.match(PostgreSqlParser.KW_FOR); + this.state = 7837; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.PARAM: + { + this.state = 7835; + this.match(PostgreSqlParser.PARAM); + } + break; + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 7836; + this.colid(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + case 2: + { + this.state = 7840; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1073, this.context) ) { + case 1: + { + this.state = 7839; + this.match(PostgreSqlParser.KW_CONSTANT); + } + break; + } + this.state = 7842; + this.typename(); + this.state = 7844; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 43) { + { + this.state = 7843; + this.opt_collate_clause(); + } + } + + this.state = 7848; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 77) { + { + this.state = 7846; + this.match(PostgreSqlParser.KW_NOT); + this.state = 7847; + this.match(PostgreSqlParser.KW_NULL); + } + } + + this.state = 7855; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 10 || _la === 20 || _la === 53) { + { + this.state = 7852; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.EQUAL: + case PostgreSqlParser.COLON_EQUALS: + { + this.state = 7850; + this.assign_operator(); + } + break; + case PostgreSqlParser.KW_DEFAULT: + { + this.state = 7851; + this.match(PostgreSqlParser.KW_DEFAULT); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 7854; + this.sql_expression(); + } + } + + } + break; + case 3: + { + this.state = 7861; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269 || _la === 324) { + { + this.state = 7858; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269) { + { + this.state = 7857; + this.match(PostgreSqlParser.KW_NO); + } + } + this.state = 7860; + this.match(PostgreSqlParser.KW_SCROLL); + } + } -export class Opt_inline_handlerContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_INLINE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INLINE, 0)!; - } - public handler_name(): Handler_nameContext { - return this.getRuleContext(0, Handler_nameContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_inline_handler; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_inline_handler) { - listener.enterOpt_inline_handler(this); + this.state = 7863; + this.match(PostgreSqlParser.KW_CURSOR); + this.state = 7875; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 7864; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7865; + this.decl_cursor_arg(); + this.state = 7870; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 7866; + this.match(PostgreSqlParser.COMMA); + this.state = 7867; + this.decl_cursor_arg(); + } + } + this.state = 7872; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 7873; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + } + + this.state = 7877; + _la = this.tokenStream.LA(1); + if(!(_la === 62 || _la === 116)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 7878; + this.selectstmt(); + } + break; + } + this.state = 7881; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_inline_handler) { - listener.exitOpt_inline_handler(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_inline_handler) { - return visitor.visitOpt_inline_handler(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Validator_clauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_VALIDATOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VALIDATOR, 0)!; - } - public handler_name(): Handler_nameContext | null { - return this.getRuleContext(0, Handler_nameContext); - } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_validator_clause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterValidator_clause) { - listener.enterValidator_clause(this); + public decl_cursor_arg(): Decl_cursor_argContext { + let localContext = new Decl_cursor_argContext(this.context, this.state); + this.enterRule(localContext, 842, PostgreSqlParser.RULE_decl_cursor_arg); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7883; + this.any_identifier(); + this.state = 7884; + this.typename(); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitValidator_clause) { - listener.exitValidator_clause(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitValidator_clause) { - return visitor.visitValidator_clause(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Opt_validatorContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public validator_clause(): Validator_clauseContext { - return this.getRuleContext(0, Validator_clauseContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_validator; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_validator) { - listener.enterOpt_validator(this); + public assign_operator(): Assign_operatorContext { + let localContext = new Assign_operatorContext(this.context, this.state); + this.enterRule(localContext, 844, PostgreSqlParser.RULE_assign_operator); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7886; + _la = this.tokenStream.LA(1); + if(!(_la === 10 || _la === 20)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_validator) { - listener.exitOpt_validator(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_validator) { - return visitor.visitOpt_validator(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Opt_proceduralContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_PROCEDURAL(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PROCEDURAL, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_procedural; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_procedural) { - listener.enterOpt_procedural(this); + public proc_stmt(): Proc_stmtContext { + let localContext = new Proc_stmtContext(this.context, this.state); + this.enterRule(localContext, 846, PostgreSqlParser.RULE_proc_stmt); + try { + this.state = 7912; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1083, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 7888; + this.pl_block(); + this.state = 7889; + this.match(PostgreSqlParser.SEMI); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 7891; + this.stmt_return(); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 7892; + this.stmt_raise(); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 7893; + this.stmt_assign(); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 7894; + this.stmt_if(); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 7895; + this.stmt_case(); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 7896; + this.stmt_loop_while_for(); + } + break; + case 8: + this.enterOuterAlt(localContext, 8); + { + this.state = 7897; + this.stmt_foreach_a(); + } + break; + case 9: + this.enterOuterAlt(localContext, 9); + { + this.state = 7898; + this.stmt_exit(); + } + break; + case 10: + this.enterOuterAlt(localContext, 10); + { + this.state = 7899; + this.stmt_assert(); + } + break; + case 11: + this.enterOuterAlt(localContext, 11); + { + this.state = 7900; + this.stmt_execsql(); + } + break; + case 12: + this.enterOuterAlt(localContext, 12); + { + this.state = 7901; + this.stmt_dynexecute(); + } + break; + case 13: + this.enterOuterAlt(localContext, 13); + { + this.state = 7902; + this.stmt_perform(); + } + break; + case 14: + this.enterOuterAlt(localContext, 14); + { + this.state = 7903; + this.stmt_call(); + } + break; + case 15: + this.enterOuterAlt(localContext, 15); + { + this.state = 7904; + this.stmt_getdiag(); + } + break; + case 16: + this.enterOuterAlt(localContext, 16); + { + this.state = 7905; + this.stmt_open(); + } + break; + case 17: + this.enterOuterAlt(localContext, 17); + { + this.state = 7906; + this.stmt_fetch(); + } + break; + case 18: + this.enterOuterAlt(localContext, 18); + { + this.state = 7907; + this.stmt_move(); + } + break; + case 19: + this.enterOuterAlt(localContext, 19); + { + this.state = 7908; + this.stmt_close(); + } + break; + case 20: + this.enterOuterAlt(localContext, 20); + { + this.state = 7909; + this.stmt_null(); + } + break; + case 21: + this.enterOuterAlt(localContext, 21); + { + this.state = 7910; + this.stmt_commit_or_rollback(); + } + break; + case 22: + this.enterOuterAlt(localContext, 22); + { + this.state = 7911; + this.stmt_set(); + } + break; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_procedural) { - listener.exitOpt_procedural(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_procedural) { - return visitor.visitOpt_procedural(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class CreatetablespacestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_TABLESPACE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0)!; - } - public tablespace_name(): Tablespace_nameContext { - return this.getRuleContext(0, Tablespace_nameContext)!; - } - public KW_LOCATION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_LOCATION, 0)!; - } - public sconst(): SconstContext { - return this.getRuleContext(0, SconstContext)!; - } - public opttablespaceowner(): OpttablespaceownerContext | null { - return this.getRuleContext(0, OpttablespaceownerContext); - } - public opt_reloptions(): Opt_reloptionsContext | null { - return this.getRuleContext(0, Opt_reloptionsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createtablespacestmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatetablespacestmt) { - listener.enterCreatetablespacestmt(this); + public stmt_perform(): Stmt_performContext { + let localContext = new Stmt_performContext(this.context, this.state); + this.enterRule(localContext, 848, PostgreSqlParser.RULE_stmt_perform); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7914; + this.match(PostgreSqlParser.KW_PERFORM); + this.state = 7915; + this.sql_expression(); + this.state = 7916; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatetablespacestmt) { - listener.exitCreatetablespacestmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatetablespacestmt) { - return visitor.visitCreatetablespacestmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} + public stmt_call(): Stmt_callContext { + let localContext = new Stmt_callContext(this.context, this.state); + this.enterRule(localContext, 850, PostgreSqlParser.RULE_stmt_call); + let _la: number; + try { + this.state = 7937; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_CALL: + this.enterOuterAlt(localContext, 1); + { + this.state = 7918; + this.match(PostgreSqlParser.KW_CALL); + this.state = 7919; + this.any_identifier(); + this.state = 7926; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1085, this.context) ) { + case 1: + { + this.state = 7920; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7922; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { + { + this.state = 7921; + this.expr_list(); + } + } + this.state = 7924; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 7925; + this.match(PostgreSqlParser.SEMI); + } + break; + } + } + break; + case PostgreSqlParser.KW_DO: + this.enterOuterAlt(localContext, 2); + { + this.state = 7928; + this.match(PostgreSqlParser.KW_DO); + this.state = 7929; + this.any_identifier(); + this.state = 7930; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 7932; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 805318660) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 421516677) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & 2174763023) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & 4294967295) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & 4294967295) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & 4294967295) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & 67108863) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 4294967295) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & 4294967295) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & 4294967295) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & 4294967295) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & 4294967295) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & 4294967295) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & 4278190079) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & 4294967295) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & 100660735) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 487696527) !== 0) || _la === 584) { + { + this.state = 7931; + this.expr_list(); + } + } -export class OpttablespaceownerContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_OWNER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OWNER, 0)!; - } - public rolespec(): RolespecContext { - return this.getRuleContext(0, RolespecContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opttablespaceowner; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpttablespaceowner) { - listener.enterOpttablespaceowner(this); + this.state = 7934; + this.match(PostgreSqlParser.CLOSE_PAREN); + this.state = 7935; + this.match(PostgreSqlParser.SEMI); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpttablespaceowner) { - listener.exitOpttablespaceowner(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpttablespaceowner) { - return visitor.visitOpttablespaceowner(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class CreateextensionstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_EXTENSION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXTENSION, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public create_extension_opt_list(): Create_extension_opt_listContext { - return this.getRuleContext(0, Create_extension_opt_listContext)!; - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public opt_with(): Opt_withContext | null { - return this.getRuleContext(0, Opt_withContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createextensionstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateextensionstmt) { - listener.enterCreateextensionstmt(this); + public stmt_assign(): Stmt_assignContext { + let localContext = new Stmt_assignContext(this.context, this.state); + this.enterRule(localContext, 852, PostgreSqlParser.RULE_stmt_assign); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7939; + this.assign_var(); + this.state = 7940; + this.assign_operator(); + this.state = 7941; + this.sql_expression(); + this.state = 7942; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateextensionstmt) { - listener.exitCreateextensionstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateextensionstmt) { - return visitor.visitCreateextensionstmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - + public stmt_getdiag(): Stmt_getdiagContext { + let localContext = new Stmt_getdiagContext(this.context, this.state); + this.enterRule(localContext, 854, PostgreSqlParser.RULE_stmt_getdiag); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7944; + this.match(PostgreSqlParser.KW_GET); + this.state = 7946; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 434 || _la === 501) { + { + this.state = 7945; + _la = this.tokenStream.LA(1); + if(!(_la === 434 || _la === 501)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + } -export class Create_extension_opt_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public create_extension_opt_item(): Create_extension_opt_itemContext[]; - public create_extension_opt_item(i: number): Create_extension_opt_itemContext | null; - public create_extension_opt_item(i?: number): Create_extension_opt_itemContext[] | Create_extension_opt_itemContext | null { - if (i === undefined) { - return this.getRuleContexts(Create_extension_opt_itemContext); + this.state = 7948; + this.match(PostgreSqlParser.KW_DIAGNOSTICS); + { + this.state = 7949; + this.getdiag_list_item(); + this.state = 7954; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 7950; + this.match(PostgreSqlParser.COMMA); + this.state = 7951; + this.getdiag_list_item(); + } + } + this.state = 7956; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + this.state = 7957; + this.match(PostgreSqlParser.SEMI); + } } - - return this.getRuleContext(i, Create_extension_opt_itemContext); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_create_extension_opt_list; + public getdiag_list_item(): Getdiag_list_itemContext { + let localContext = new Getdiag_list_itemContext(this.context, this.state); + this.enterRule(localContext, 856, PostgreSqlParser.RULE_getdiag_list_item); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7959; + this.assign_var(); + this.state = 7960; + this.assign_operator(); + this.state = 7961; + this.colid(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreate_extension_opt_list) { - listener.enterCreate_extension_opt_list(this); + public assign_var(): Assign_varContext { + let localContext = new Assign_varContext(this.context, this.state); + this.enterRule(localContext, 858, PostgreSqlParser.RULE_assign_var); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 7965; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 7963; + this.any_name(); + } + break; + case PostgreSqlParser.PARAM: + { + this.state = 7964; + this.match(PostgreSqlParser.PARAM); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 7973; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 4) { + { + { + this.state = 7967; + this.match(PostgreSqlParser.OPEN_BRACKET); + this.state = 7968; + this.expression(); + this.state = 7969; + this.match(PostgreSqlParser.CLOSE_BRACKET); + } + } + this.state = 7975; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreate_extension_opt_list) { - listener.exitCreate_extension_opt_list(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreate_extension_opt_list) { - return visitor.visitCreate_extension_opt_list(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - + public stmt_if(): Stmt_ifContext { + let localContext = new Stmt_ifContext(this.context, this.state); + this.enterRule(localContext, 860, PostgreSqlParser.RULE_stmt_if); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 7976; + this.match(PostgreSqlParser.KW_IF); + this.state = 7977; + this.sql_expression(); + this.state = 7978; + this.match(PostgreSqlParser.KW_THEN); + this.state = 7982; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1092, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 7979; + this.proc_stmt(); + } + } + } + this.state = 7984; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1092, this.context); + } + { + this.state = 7996; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 502) { + { + { + this.state = 7985; + this.match(PostgreSqlParser.KW_ELSIF); + this.state = 7986; + this.expression(); + this.state = 7987; + this.match(PostgreSqlParser.KW_THEN); + this.state = 7991; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1093, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 7988; + this.proc_stmt(); + } + } + } + this.state = 7993; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1093, this.context); + } + } + } + this.state = 7998; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + this.state = 8000; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 58) { + { + this.state = 7999; + this.stmt_else(); + } + } -export class Create_extension_opt_itemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); - } - public schema_name(): Schema_nameContext | null { - return this.getRuleContext(0, Schema_nameContext); - } - public KW_VERSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VERSION, 0); - } - public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | null { - return this.getRuleContext(0, Nonreservedword_or_sconstContext); - } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public KW_CASCADE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CASCADE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_create_extension_opt_item; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreate_extension_opt_item) { - listener.enterCreate_extension_opt_item(this); + this.state = 8002; + this.match(PostgreSqlParser.KW_END); + this.state = 8003; + this.match(PostgreSqlParser.KW_IF); + this.state = 8004; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreate_extension_opt_item) { - listener.exitCreate_extension_opt_item(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreate_extension_opt_item) { - return visitor.visitCreate_extension_opt_item(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class AlterextensionstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_EXTENSION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXTENSION, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public KW_UPDATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_UPDATE, 0)!; - } - public alter_extension_opt_list(): Alter_extension_opt_listContext { - return this.getRuleContext(0, Alter_extension_opt_listContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterextensionstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterextensionstmt) { - listener.enterAlterextensionstmt(this); + public stmt_else(): Stmt_elseContext { + let localContext = new Stmt_elseContext(this.context, this.state); + this.enterRule(localContext, 862, PostgreSqlParser.RULE_stmt_else); + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 8006; + this.match(PostgreSqlParser.KW_ELSE); + this.state = 8010; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1096, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 8007; + this.proc_stmt(); + } + } + } + this.state = 8012; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1096, this.context); + } + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterextensionstmt) { - listener.exitAlterextensionstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterextensionstmt) { - return visitor.visitAlterextensionstmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Alter_extension_opt_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public alter_extension_opt_item(): Alter_extension_opt_itemContext[]; - public alter_extension_opt_item(i: number): Alter_extension_opt_itemContext | null; - public alter_extension_opt_item(i?: number): Alter_extension_opt_itemContext[] | Alter_extension_opt_itemContext | null { - if (i === undefined) { - return this.getRuleContexts(Alter_extension_opt_itemContext); - } + public stmt_case(): Stmt_caseContext { + let localContext = new Stmt_caseContext(this.context, this.state); + this.enterRule(localContext, 864, PostgreSqlParser.RULE_stmt_case); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 8013; + this.match(PostgreSqlParser.KW_CASE); + this.state = 8015; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1097, this.context) ) { + case 1: + { + this.state = 8014; + this.sql_expression(); + } + break; + } + this.state = 8026; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 8017; + this.match(PostgreSqlParser.KW_WHEN); + this.state = 8018; + this.expr_list(); + this.state = 8019; + this.match(PostgreSqlParser.KW_THEN); + this.state = 8023; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1098, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 8020; + this.proc_stmt(); + } + } + } + this.state = 8025; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1098, this.context); + } + } + } + this.state = 8028; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 102); + this.state = 8031; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 58) { + { + this.state = 8030; + this.stmt_else(); + } + } - return this.getRuleContext(i, Alter_extension_opt_itemContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_extension_opt_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_extension_opt_list) { - listener.enterAlter_extension_opt_list(this); + this.state = 8033; + this.match(PostgreSqlParser.KW_END); + this.state = 8034; + this.match(PostgreSqlParser.KW_CASE); + this.state = 8035; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_extension_opt_list) { - listener.exitAlter_extension_opt_list(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_extension_opt_list) { - return visitor.visitAlter_extension_opt_list(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - + public stmt_loop_while_for(): Stmt_loop_while_forContext { + let localContext = new Stmt_loop_while_forContext(this.context, this.state); + this.enterRule(localContext, 866, PostgreSqlParser.RULE_stmt_loop_while_for); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8038; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 18) { + { + this.state = 8037; + this.label_decl(); + } + } -export class Alter_extension_opt_itemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_TO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TO, 0)!; - } - public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext { - return this.getRuleContext(0, Nonreservedword_or_sconstContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_extension_opt_item; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_extension_opt_item) { - listener.enterAlter_extension_opt_item(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_extension_opt_item) { - listener.exitAlter_extension_opt_item(this); + this.state = 8044; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_WHILE: + { + { + this.state = 8040; + this.match(PostgreSqlParser.KW_WHILE); + this.state = 8041; + this.expression(); + } + } + break; + case PostgreSqlParser.KW_FOR: + { + { + this.state = 8042; + this.match(PostgreSqlParser.KW_FOR); + this.state = 8043; + this.for_control(); + } + } + break; + case PostgreSqlParser.KW_LOOP: + break; + default: + break; + } + this.state = 8046; + this.loop_body(); + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_extension_opt_item) { - return visitor.visitAlter_extension_opt_item(this); - } else { - return visitor.visitChildren(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } -} - - -export class AlterextensioncontentsstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_EXTENSION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXTENSION, 0)!; - } - public name(): NameContext[]; - public name(i: number): NameContext | null; - public name(i?: number): NameContext[] | NameContext | null { - if (i === undefined) { - return this.getRuleContexts(NameContext); + finally { + this.exitRule(); } - - return this.getRuleContext(i, NameContext); - } - public add_drop(): Add_dropContext { - return this.getRuleContext(0, Add_dropContext)!; - } - public object_type_name(): Object_type_nameContext | null { - return this.getRuleContext(0, Object_type_nameContext); - } - public object_type_any_name(): Object_type_any_nameContext | null { - return this.getRuleContext(0, Object_type_any_nameContext); - } - public KW_AGGREGATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); - } - public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { - return this.getRuleContext(0, Aggregate_with_argtypesContext); - } - public KW_CAST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CAST, 0); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + return localContext; } - public typename(): TypenameContext[]; - public typename(i: number): TypenameContext | null; - public typename(i?: number): TypenameContext[] | TypenameContext | null { - if (i === undefined) { - return this.getRuleContexts(TypenameContext); - } + public for_control(): For_controlContext { + let localContext = new For_controlContext(this.context, this.state); + this.enterRule(localContext, 868, PostgreSqlParser.RULE_for_control); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8048; + this.any_name_list(); + this.state = 8049; + this.match(PostgreSqlParser.KW_IN); + this.state = 8072; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1107, this.context) ) { + case 1: + { + this.state = 8050; + this.colid(); + this.state = 8052; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 8051; + this.execute_param_clause(); + } + } - return this.getRuleContext(i, TypenameContext); - } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public KW_DOMAIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); - } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); - } - public function_with_argtypes(): Function_with_argtypesContext | null { - return this.getRuleContext(0, Function_with_argtypesContext); - } - public KW_OPERATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); - } - public operator_with_argtypes(): Operator_with_argtypesContext | null { - return this.getRuleContext(0, Operator_with_argtypesContext); - } - public KW_CLASS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CLASS, 0); - } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); - } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); - } - public KW_FAMILY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FAMILY, 0); - } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); - } - public procedure_with_argtypes(): Procedure_with_argtypesContext | null { - return this.getRuleContext(0, Procedure_with_argtypesContext); - } - public KW_ROUTINE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); - } - public routine_with_argtypes(): Routine_with_argtypesContext | null { - return this.getRuleContext(0, Routine_with_argtypesContext); - } - public KW_TRANSFORM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0); - } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); - } - public KW_LANGUAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); - } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterextensioncontentsstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterextensioncontentsstmt) { - listener.enterAlterextensioncontentsstmt(this); + } + break; + case 2: + { + this.state = 8054; + this.selectstmt(); + } + break; + case 3: + { + this.state = 8055; + this.explainstmt(); + } + break; + case 4: + { + this.state = 8056; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 8057; + this.expression(); + this.state = 8060; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 100) { + { + this.state = 8058; + this.match(PostgreSqlParser.KW_USING); + this.state = 8059; + this.expr_list(); + } + } + + } + break; + case 5: + { + this.state = 8063; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1105, this.context) ) { + case 1: + { + this.state = 8062; + this.match(PostgreSqlParser.KW_REVERSE); + } + break; + } + this.state = 8065; + this.expression(); + this.state = 8066; + this.match(PostgreSqlParser.DOT_DOT); + this.state = 8067; + this.expression(); + this.state = 8070; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 147) { + { + this.state = 8068; + this.match(PostgreSqlParser.KW_BY); + this.state = 8069; + this.expression(); + } + } + + } + break; + } + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterextensioncontentsstmt) { - listener.exitAlterextensioncontentsstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterextensioncontentsstmt) { - return visitor.visitAlterextensioncontentsstmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} + public stmt_foreach_a(): Stmt_foreach_aContext { + let localContext = new Stmt_foreach_aContext(this.context, this.state); + this.enterRule(localContext, 870, PostgreSqlParser.RULE_stmt_foreach_a); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8075; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 18) { + { + this.state = 8074; + this.label_decl(); + } + } + this.state = 8077; + this.match(PostgreSqlParser.KW_FOREACH); + this.state = 8078; + this.any_name_list(); + this.state = 8081; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 506) { + { + this.state = 8079; + this.match(PostgreSqlParser.KW_SLICE); + this.state = 8080; + this.match(PostgreSqlParser.Integral); + } + } -export class CreatefdwstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_FOREIGN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; - } - public KW_DATA(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DATA, 0)!; - } - public KW_WRAPPER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WRAPPER, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public opt_fdw_options(): Opt_fdw_optionsContext | null { - return this.getRuleContext(0, Opt_fdw_optionsContext); - } - public create_generic_options(): Create_generic_optionsContext | null { - return this.getRuleContext(0, Create_generic_optionsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createfdwstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatefdwstmt) { - listener.enterCreatefdwstmt(this); + this.state = 8083; + this.match(PostgreSqlParser.KW_IN); + this.state = 8084; + this.match(PostgreSqlParser.KW_ARRAY); + this.state = 8085; + this.expression(); + this.state = 8086; + this.loop_body(); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatefdwstmt) { - listener.exitCreatefdwstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatefdwstmt) { - return visitor.visitCreatefdwstmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} + public stmt_exit(): Stmt_exitContext { + let localContext = new Stmt_exitContext(this.context, this.state); + this.enterRule(localContext, 872, PostgreSqlParser.RULE_stmt_exit); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8088; + _la = this.tokenStream.LA(1); + if(!(_la === 167 || _la === 507)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 8090; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { + { + this.state = 8089; + this.any_identifier(); + } + } + this.state = 8094; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 102) { + { + this.state = 8092; + this.match(PostgreSqlParser.KW_WHEN); + this.state = 8093; + this.sql_expression(); + } + } -export class Fdw_optionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_HANDLER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_HANDLER, 0); - } - public handler_name(): Handler_nameContext | null { - return this.getRuleContext(0, Handler_nameContext); - } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); - } - public KW_VALIDATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALIDATOR, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_fdw_option; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFdw_option) { - listener.enterFdw_option(this); + this.state = 8096; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFdw_option) { - listener.exitFdw_option(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } + finally { + this.exitRule(); + } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFdw_option) { - return visitor.visitFdw_option(this); - } else { - return visitor.visitChildren(this); + public stmt_return(): Stmt_returnContext { + let localContext = new Stmt_returnContext(this.context, this.state); + this.enterRule(localContext, 874, PostgreSqlParser.RULE_stmt_return); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8098; + this.match(PostgreSqlParser.KW_RETURN); + this.state = 8113; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1114, this.context) ) { + case 1: + { + this.state = 8099; + this.match(PostgreSqlParser.KW_NEXT); + this.state = 8100; + this.sql_expression(); + } + break; + case 2: + { + this.state = 8101; + this.match(PostgreSqlParser.KW_QUERY); + this.state = 8108; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_EXECUTE: + { + this.state = 8102; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 8103; + this.expression(); + this.state = 8104; + this.match(PostgreSqlParser.KW_USING); + this.state = 8105; + this.expr_list(); + } + break; + case PostgreSqlParser.OPEN_PAREN: + case PostgreSqlParser.KW_SELECT: + case PostgreSqlParser.KW_TABLE: + case PostgreSqlParser.KW_WITH: + case PostgreSqlParser.KW_VALUES: + { + this.state = 8107; + this.selectstmt(); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + case 3: + { + this.state = 8111; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1113, this.context) ) { + case 1: + { + this.state = 8110; + this.sql_expression(); + } + break; + } + } + break; + } + this.state = 8115; + this.match(PostgreSqlParser.SEMI); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); } + return localContext; } -} + public stmt_raise(): Stmt_raiseContext { + let localContext = new Stmt_raiseContext(this.context, this.state); + this.enterRule(localContext, 876, PostgreSqlParser.RULE_stmt_raise); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8117; + this.match(PostgreSqlParser.KW_RAISE); + this.state = 8147; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1121, this.context) ) { + case 1: + { + this.state = 8119; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1115, this.context) ) { + case 1: + { + this.state = 8118; + _la = this.tokenStream.LA(1); + if(!(((((_la - 512)) & ~0x1F) === 0 && ((1 << (_la - 512)) & 63) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + this.state = 8133; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1118, this.context) ) { + case 1: + { + this.state = 8121; + this.identifier(); + } + break; + case 2: + { + { + this.state = 8122; + this.match(PostgreSqlParser.KW_SQLSTATE); + this.state = 8123; + this.sconst(); + } + } + break; + case 3: + { + { + this.state = 8124; + this.sconst(); + this.state = 8131; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 6) { + { + this.state = 8127; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 8125; + this.match(PostgreSqlParser.COMMA); + this.state = 8126; + this.expression(); + } + } + this.state = 8129; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 6); + } + } + } + } + break; + } + this.state = 8144; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 100) { + { + this.state = 8135; + this.match(PostgreSqlParser.KW_USING); + { + this.state = 8136; + this.opt_raise_using_elem(); + this.state = 8141; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 8137; + this.match(PostgreSqlParser.COMMA); + this.state = 8138; + this.opt_raise_using_elem(); + } + } + this.state = 8143; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + } + } -export class Fdw_optionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public fdw_option(): Fdw_optionContext[]; - public fdw_option(i: number): Fdw_optionContext | null; - public fdw_option(i?: number): Fdw_optionContext[] | Fdw_optionContext | null { - if (i === undefined) { - return this.getRuleContexts(Fdw_optionContext); + this.state = 8146; + this.match(PostgreSqlParser.SEMI); + } + break; + } + } } - - return this.getRuleContext(i, Fdw_optionContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_fdw_options; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFdw_options) { - listener.enterFdw_options(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFdw_options) { - listener.exitFdw_options(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFdw_options) { - return visitor.visitFdw_options(this); - } else { - return visitor.visitChildren(this); + public opt_raise_using_elem(): Opt_raise_using_elemContext { + let localContext = new Opt_raise_using_elemContext(this.context, this.state); + this.enterRule(localContext, 878, PostgreSqlParser.RULE_opt_raise_using_elem); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8149; + this.identifier(); + this.state = 8150; + this.match(PostgreSqlParser.EQUAL); + this.state = 8151; + this.expression(); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } + finally { + this.exitRule(); + } + return localContext; } -} - + public stmt_assert(): Stmt_assertContext { + let localContext = new Stmt_assertContext(this.context, this.state); + this.enterRule(localContext, 880, PostgreSqlParser.RULE_stmt_assert); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8153; + this.match(PostgreSqlParser.KW_ASSERT); + this.state = 8154; + this.sql_expression(); + this.state = 8157; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 6) { + { + this.state = 8155; + this.match(PostgreSqlParser.COMMA); + this.state = 8156; + this.sql_expression(); + } + } -export class Opt_fdw_optionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public fdw_options(): Fdw_optionsContext { - return this.getRuleContext(0, Fdw_optionsContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_fdw_options; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_fdw_options) { - listener.enterOpt_fdw_options(this); + this.state = 8159; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_fdw_options) { - listener.exitOpt_fdw_options(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_fdw_options) { - return visitor.visitOpt_fdw_options(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - + public loop_body(): Loop_bodyContext { + let localContext = new Loop_bodyContext(this.context, this.state); + this.enterRule(localContext, 882, PostgreSqlParser.RULE_loop_body); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 8161; + this.match(PostgreSqlParser.KW_LOOP); + this.state = 8165; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1123, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 8162; + this.proc_stmt(); + } + } + } + this.state = 8167; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1123, this.context); + } + this.state = 8168; + this.match(PostgreSqlParser.KW_END); + this.state = 8169; + this.match(PostgreSqlParser.KW_LOOP); + this.state = 8171; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { + { + this.state = 8170; + this.any_identifier(); + } + } -export class AlterfdwstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_FOREIGN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; - } - public KW_DATA(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DATA, 0)!; - } - public KW_WRAPPER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WRAPPER, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public alter_generic_options(): Alter_generic_optionsContext | null { - return this.getRuleContext(0, Alter_generic_optionsContext); - } - public opt_fdw_options(): Opt_fdw_optionsContext | null { - return this.getRuleContext(0, Opt_fdw_optionsContext); - } - public fdw_options(): Fdw_optionsContext | null { - return this.getRuleContext(0, Fdw_optionsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterfdwstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterfdwstmt) { - listener.enterAlterfdwstmt(this); + this.state = 8173; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterfdwstmt) { - listener.exitAlterfdwstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterfdwstmt) { - return visitor.visitAlterfdwstmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - + public stmt_execsql(): Stmt_execsqlContext { + let localContext = new Stmt_execsqlContext(this.context, this.state); + this.enterRule(localContext, 884, PostgreSqlParser.RULE_stmt_execsql); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8175; + this.stmt(); + this.state = 8177; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 71) { + { + this.state = 8176; + this.opt_execute_into(); + } + } -export class Create_generic_optionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_OPTIONS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OPTIONS, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public generic_option_list(): Generic_option_listContext { - return this.getRuleContext(0, Generic_option_listContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_create_generic_options; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreate_generic_options) { - listener.enterCreate_generic_options(this); + this.state = 8179; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreate_generic_options) { - listener.exitCreate_generic_options(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreate_generic_options) { - return visitor.visitCreate_generic_options(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} + public stmt_dynexecute(): Stmt_dynexecuteContext { + let localContext = new Stmt_dynexecuteContext(this.context, this.state); + this.enterRule(localContext, 886, PostgreSqlParser.RULE_stmt_dynexecute); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8181; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 8182; + this.expression(); + this.state = 8198; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1130, this.context) ) { + case 1: + { + this.state = 8184; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 71) { + { + this.state = 8183; + this.opt_execute_into(); + } + } + this.state = 8188; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 100) { + { + this.state = 8186; + this.match(PostgreSqlParser.KW_USING); + this.state = 8187; + this.expr_list(); + } + } -export class Generic_option_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public generic_option_elem(): Generic_option_elemContext[]; - public generic_option_elem(i: number): Generic_option_elemContext | null; - public generic_option_elem(i?: number): Generic_option_elemContext[] | Generic_option_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Generic_option_elemContext); - } + } + break; + case 2: + { + this.state = 8192; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 100) { + { + this.state = 8190; + this.match(PostgreSqlParser.KW_USING); + this.state = 8191; + this.expr_list(); + } + } - return this.getRuleContext(i, Generic_option_elemContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_generic_option_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGeneric_option_list) { - listener.enterGeneric_option_list(this); + this.state = 8195; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 71) { + { + this.state = 8194; + this.opt_execute_into(); + } + } + + } + break; + case 3: + // tslint:disable-next-line:no-empty + { + } + break; + } + this.state = 8200; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGeneric_option_list) { - listener.exitGeneric_option_list(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGeneric_option_list) { - return visitor.visitGeneric_option_list(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Alter_generic_optionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_OPTIONS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OPTIONS, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public alter_generic_option_list(): Alter_generic_option_listContext { - return this.getRuleContext(0, Alter_generic_option_listContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_generic_options; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_generic_options) { - listener.enterAlter_generic_options(this); + public opt_execute_into(): Opt_execute_intoContext { + let localContext = new Opt_execute_intoContext(this.context, this.state); + this.enterRule(localContext, 888, PostgreSqlParser.RULE_opt_execute_into); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8202; + this.match(PostgreSqlParser.KW_INTO); + this.state = 8204; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1131, this.context) ) { + case 1: + { + this.state = 8203; + this.match(PostgreSqlParser.KW_STRICT); + } + break; + } + this.state = 8206; + this.expr_list(); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_generic_options) { - listener.exitAlter_generic_options(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_generic_options) { - return visitor.visitAlter_generic_options(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} + public stmt_open(): Stmt_openContext { + let localContext = new Stmt_openContext(this.context, this.state); + this.enterRule(localContext, 890, PostgreSqlParser.RULE_stmt_open); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8208; + this.match(PostgreSqlParser.KW_OPEN); + this.state = 8240; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1138, this.context) ) { + case 1: + { + this.state = 8209; + this.cursor_variable(); + this.state = 8214; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269 || _la === 324) { + { + this.state = 8211; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269) { + { + this.state = 8210; + this.match(PostgreSqlParser.KW_NO); + } + } + + this.state = 8213; + this.match(PostgreSqlParser.KW_SCROLL); + } + } + this.state = 8216; + this.match(PostgreSqlParser.KW_FOR); + this.state = 8224; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.OPEN_PAREN: + case PostgreSqlParser.KW_SELECT: + case PostgreSqlParser.KW_TABLE: + case PostgreSqlParser.KW_WITH: + case PostgreSqlParser.KW_VALUES: + { + this.state = 8217; + this.selectstmt(); + } + break; + case PostgreSqlParser.KW_EXECUTE: + { + this.state = 8218; + this.match(PostgreSqlParser.KW_EXECUTE); + this.state = 8219; + this.sql_expression(); + this.state = 8222; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 100) { + { + this.state = 8220; + this.match(PostgreSqlParser.KW_USING); + this.state = 8221; + this.expr_list(); + } + } -export class Alter_generic_option_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public alter_generic_option_elem(): Alter_generic_option_elemContext[]; - public alter_generic_option_elem(i: number): Alter_generic_option_elemContext | null; - public alter_generic_option_elem(i?: number): Alter_generic_option_elemContext[] | Alter_generic_option_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Alter_generic_option_elemContext); - } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + case 2: + { + this.state = 8226; + this.colid(); + this.state = 8238; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 8227; + this.match(PostgreSqlParser.OPEN_PAREN); + { + this.state = 8228; + this.opt_open_bound_list_item(); + this.state = 8233; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 8229; + this.match(PostgreSqlParser.COMMA); + this.state = 8230; + this.opt_open_bound_list_item(); + } + } + this.state = 8235; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + this.state = 8236; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + } - return this.getRuleContext(i, Alter_generic_option_elemContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_generic_option_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_generic_option_list) { - listener.enterAlter_generic_option_list(this); + } + break; + } + this.state = 8242; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_generic_option_list) { - listener.exitAlter_generic_option_list(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_generic_option_list) { - return visitor.visitAlter_generic_option_list(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Alter_generic_option_elemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public generic_option_elem(): Generic_option_elemContext { - return this.getRuleContext(0, Generic_option_elemContext)!; - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public KW_ADD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADD, 0); - } - public KW_DROP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DROP, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alter_generic_option_elem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlter_generic_option_elem) { - listener.enterAlter_generic_option_elem(this); + public opt_open_bound_list_item(): Opt_open_bound_list_itemContext { + let localContext = new Opt_open_bound_list_itemContext(this.context, this.state); + this.enterRule(localContext, 892, PostgreSqlParser.RULE_opt_open_bound_list_item); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8247; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1139, this.context) ) { + case 1: + { + this.state = 8244; + this.colid(); + this.state = 8245; + this.match(PostgreSqlParser.COLON_EQUALS); + } + break; + } + this.state = 8249; + this.expression(); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlter_generic_option_elem) { - listener.exitAlter_generic_option_elem(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlter_generic_option_elem) { - return visitor.visitAlter_generic_option_elem(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - + public stmt_fetch(): Stmt_fetchContext { + let localContext = new Stmt_fetchContext(this.context, this.state); + this.enterRule(localContext, 894, PostgreSqlParser.RULE_stmt_fetch); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8251; + this.match(PostgreSqlParser.KW_FETCH); + this.state = 8253; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1140, this.context) ) { + case 1: + { + this.state = 8252; + localContext._direction = this.opt_fetch_direction(); + } + break; + } + this.state = 8256; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 64 || _la === 68) { + { + this.state = 8255; + this.from_in(); + } + } -export class Generic_option_elemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public generic_option_name(): Generic_option_nameContext { - return this.getRuleContext(0, Generic_option_nameContext)!; - } - public generic_option_arg(): Generic_option_argContext { - return this.getRuleContext(0, Generic_option_argContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_generic_option_elem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGeneric_option_elem) { - listener.enterGeneric_option_elem(this); + this.state = 8258; + this.cursor_variable(); + this.state = 8259; + this.match(PostgreSqlParser.KW_INTO); + this.state = 8260; + this.expr_list(); + this.state = 8261; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGeneric_option_elem) { - listener.exitGeneric_option_elem(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGeneric_option_elem) { - return visitor.visitGeneric_option_elem(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Generic_option_nameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public collabel(): CollabelContext { - return this.getRuleContext(0, CollabelContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_generic_option_name; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGeneric_option_name) { - listener.enterGeneric_option_name(this); + public opt_fetch_direction(): Opt_fetch_directionContext { + let localContext = new Opt_fetch_directionContext(this.context, this.state); + this.enterRule(localContext, 896, PostgreSqlParser.RULE_opt_fetch_direction); + let _la: number; + try { + this.state = 8277; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1144, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 8263; + this.match(PostgreSqlParser.KW_NEXT); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 8264; + this.match(PostgreSqlParser.KW_PRIOR); + } + break; + case 3: + this.enterOuterAlt(localContext, 3); + { + this.state = 8265; + this.match(PostgreSqlParser.KW_FIRST); + } + break; + case 4: + this.enterOuterAlt(localContext, 4); + { + this.state = 8266; + this.match(PostgreSqlParser.KW_LAST); + } + break; + case 5: + this.enterOuterAlt(localContext, 5); + { + this.state = 8268; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1142, this.context) ) { + case 1: + { + this.state = 8267; + _la = this.tokenStream.LA(1); + if(!(_la === 130 || _la === 307)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } + break; + } + this.state = 8270; + this.expression(); + } + break; + case 6: + this.enterOuterAlt(localContext, 6); + { + this.state = 8271; + this.match(PostgreSqlParser.KW_ALL); + } + break; + case 7: + this.enterOuterAlt(localContext, 7); + { + this.state = 8272; + _la = this.tokenStream.LA(1); + if(!(_la === 144 || _la === 210)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 8275; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1143, this.context) ) { + case 1: + { + this.state = 8273; + this.expression(); + } + break; + case 2: + { + this.state = 8274; + this.match(PostgreSqlParser.KW_ALL); + } + break; + } + } + break; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGeneric_option_name) { - listener.exitGeneric_option_name(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGeneric_option_name) { - return visitor.visitGeneric_option_name(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Generic_option_argContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public sconst(): SconstContext { - return this.getRuleContext(0, SconstContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_generic_option_arg; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGeneric_option_arg) { - listener.enterGeneric_option_arg(this); + public stmt_move(): Stmt_moveContext { + let localContext = new Stmt_moveContext(this.context, this.state); + this.enterRule(localContext, 898, PostgreSqlParser.RULE_stmt_move); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8279; + this.match(PostgreSqlParser.KW_MOVE); + this.state = 8281; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1145, this.context) ) { + case 1: + { + this.state = 8280; + this.opt_fetch_direction(); + } + break; + } + this.state = 8283; + this.cursor_variable(); + this.state = 8284; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGeneric_option_arg) { - listener.exitGeneric_option_arg(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGeneric_option_arg) { - return visitor.visitGeneric_option_arg(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} + public mergestmt(): MergestmtContext { + let localContext = new MergestmtContext(this.context, this.state); + this.enterRule(localContext, 900, PostgreSqlParser.RULE_mergestmt); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8287; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 105) { + { + this.state = 8286; + this.with_clause(); + } + } + this.state = 8289; + this.match(PostgreSqlParser.KW_MERGE); + this.state = 8290; + this.match(PostgreSqlParser.KW_INTO); + this.state = 8292; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 81) { + { + this.state = 8291; + this.match(PostgreSqlParser.KW_ONLY); + } + } -export class CreateforeignserverstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_SERVER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; - } - public name(): NameContext[]; - public name(i: number): NameContext | null; - public name(i?: number): NameContext[] | NameContext | null { - if (i === undefined) { - return this.getRuleContexts(NameContext); - } + this.state = 8294; + this.table_name(); + this.state = 8296; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 9) { + { + this.state = 8295; + this.match(PostgreSqlParser.STAR); + } + } - return this.getRuleContext(i, NameContext); - } - public KW_FOREIGN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; - } - public KW_DATA(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DATA, 0)!; - } - public KW_WRAPPER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WRAPPER, 0)!; - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public opt_type(): Opt_typeContext | null { - return this.getRuleContext(0, Opt_typeContext); - } - public opt_foreign_server_version(): Opt_foreign_server_versionContext | null { - return this.getRuleContext(0, Opt_foreign_server_versionContext); - } - public create_generic_options(): Create_generic_optionsContext | null { - return this.getRuleContext(0, Create_generic_optionsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createforeignserverstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateforeignserverstmt) { - listener.enterCreateforeignserverstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateforeignserverstmt) { - listener.exitCreateforeignserverstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateforeignserverstmt) { - return visitor.visitCreateforeignserverstmt(this); - } else { - return visitor.visitChildren(this); - } - } -} + this.state = 8302; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266381) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { + { + this.state = 8299; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 36) { + { + this.state = 8298; + this.match(PostgreSqlParser.KW_AS); + } + } + this.state = 8301; + this.colid(); + } + } -export class Opt_typeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_TYPE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TYPE, 0)!; - } - public sconst(): SconstContext { - return this.getRuleContext(0, SconstContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_type; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_type) { - listener.enterOpt_type(this); + this.state = 8304; + this.match(PostgreSqlParser.KW_USING); + this.state = 8305; + this.data_source(); + this.state = 8306; + this.match(PostgreSqlParser.KW_ON); + this.state = 8307; + this.expression(); + this.state = 8309; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 8308; + this.merge_when_clause(); + } + } + this.state = 8311; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 102); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_type) { - listener.exitOpt_type(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_type) { - return visitor.visitOpt_type(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} + public data_source(): Data_sourceContext { + let localContext = new Data_sourceContext(this.context, this.state); + this.enterRule(localContext, 902, PostgreSqlParser.RULE_data_source); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8324; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1155, this.context) ) { + case 1: + { + this.state = 8314; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 81) { + { + this.state = 8313; + this.match(PostgreSqlParser.KW_ONLY); + } + } + this.state = 8316; + this.table_name(); + this.state = 8318; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 9) { + { + this.state = 8317; + this.match(PostgreSqlParser.STAR); + } + } -export class Foreign_server_versionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_VERSION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VERSION, 0)!; - } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); - } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_foreign_server_version; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterForeign_server_version) { - listener.enterForeign_server_version(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitForeign_server_version) { - listener.exitForeign_server_version(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitForeign_server_version) { - return visitor.visitForeign_server_version(this); - } else { - return visitor.visitChildren(this); - } - } -} + } + break; + case 2: + { + this.state = 8322; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1154, this.context) ) { + case 1: + { + this.state = 8320; + this.select_no_parens(); + } + break; + case 2: + { + this.state = 8321; + this.values_clause(); + } + break; + } + } + break; + } + this.state = 8330; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266381) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 4294959489) !== 0) || ((((_la - 148)) & ~0x1F) === 0 && ((1 << (_la - 148)) & 4294967295) !== 0) || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 4294967295) !== 0) || ((((_la - 212)) & ~0x1F) === 0 && ((1 << (_la - 212)) & 4227989503) !== 0) || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & 4294967295) !== 0) || ((((_la - 276)) & ~0x1F) === 0 && ((1 << (_la - 276)) & 4294967295) !== 0) || ((((_la - 308)) & ~0x1F) === 0 && ((1 << (_la - 308)) & 4294967295) !== 0) || ((((_la - 340)) & ~0x1F) === 0 && ((1 << (_la - 340)) & 4294967295) !== 0) || ((((_la - 372)) & ~0x1F) === 0 && ((1 << (_la - 372)) & 4294967295) !== 0) || ((((_la - 404)) & ~0x1F) === 0 && ((1 << (_la - 404)) & 4294967295) !== 0) || ((((_la - 436)) & ~0x1F) === 0 && ((1 << (_la - 436)) & 4294705151) !== 0) || ((((_la - 468)) & ~0x1F) === 0 && ((1 << (_la - 468)) & 4294967279) !== 0) || ((((_la - 500)) & ~0x1F) === 0 && ((1 << (_la - 500)) & 1572823) !== 0) || ((((_la - 547)) & ~0x1F) === 0 && ((1 << (_la - 547)) & 402696335) !== 0) || _la === 584) { + { + this.state = 8327; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 36) { + { + this.state = 8326; + this.match(PostgreSqlParser.KW_AS); + } + } + this.state = 8329; + this.colid(); + } + } -export class Opt_foreign_server_versionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public foreign_server_version(): Foreign_server_versionContext { - return this.getRuleContext(0, Foreign_server_versionContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_foreign_server_version; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_foreign_server_version) { - listener.enterOpt_foreign_server_version(this); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_foreign_server_version) { - listener.exitOpt_foreign_server_version(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_foreign_server_version) { - return visitor.visitOpt_foreign_server_version(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} + public merge_when_clause(): Merge_when_clauseContext { + let localContext = new Merge_when_clauseContext(this.context, this.state); + this.enterRule(localContext, 904, PostgreSqlParser.RULE_merge_when_clause); + let _la: number; + try { + this.state = 8358; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1162, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 8332; + this.match(PostgreSqlParser.KW_WHEN); + this.state = 8333; + this.match(PostgreSqlParser.KW_MATCHED); + this.state = 8336; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 33) { + { + this.state = 8334; + this.match(PostgreSqlParser.KW_AND); + this.state = 8335; + this.expression(); + } + } + this.state = 8338; + this.match(PostgreSqlParser.KW_THEN); + this.state = 8343; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_UPDATE: + { + this.state = 8339; + this.merge_update(); + } + break; + case PostgreSqlParser.KW_DELETE: + { + this.state = 8340; + this.match(PostgreSqlParser.KW_DELETE); + } + break; + case PostgreSqlParser.KW_DO: + { + this.state = 8341; + this.match(PostgreSqlParser.KW_DO); + this.state = 8342; + this.match(PostgreSqlParser.KW_NOTHING); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 8345; + this.match(PostgreSqlParser.KW_WHEN); + this.state = 8346; + this.match(PostgreSqlParser.KW_NOT); + this.state = 8347; + this.match(PostgreSqlParser.KW_MATCHED); + this.state = 8350; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 33) { + { + this.state = 8348; + this.match(PostgreSqlParser.KW_AND); + this.state = 8349; + this.expression(); + } + } -export class AlterforeignserverstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_SERVER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public alter_generic_options(): Alter_generic_optionsContext | null { - return this.getRuleContext(0, Alter_generic_optionsContext); - } - public foreign_server_version(): Foreign_server_versionContext | null { - return this.getRuleContext(0, Foreign_server_versionContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterforeignserverstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterforeignserverstmt) { - listener.enterAlterforeignserverstmt(this); + this.state = 8352; + this.match(PostgreSqlParser.KW_THEN); + this.state = 8356; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_INSERT: + { + this.state = 8353; + this.merge_insert(); + } + break; + case PostgreSqlParser.KW_DO: + { + this.state = 8354; + this.match(PostgreSqlParser.KW_DO); + this.state = 8355; + this.match(PostgreSqlParser.KW_NOTHING); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + break; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterforeignserverstmt) { - listener.exitAlterforeignserverstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterforeignserverstmt) { - return visitor.visitAlterforeignserverstmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} + public merge_insert(): Merge_insertContext { + let localContext = new Merge_insertContext(this.context, this.state); + this.enterRule(localContext, 906, PostgreSqlParser.RULE_merge_insert); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8360; + this.match(PostgreSqlParser.KW_INSERT); + this.state = 8362; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 2) { + { + this.state = 8361; + this.opt_column_list(); + } + } + this.state = 8367; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 463) { + { + this.state = 8364; + this.match(PostgreSqlParser.KW_OVERRIDING); + this.state = 8365; + _la = this.tokenStream.LA(1); + if(!(_la === 99 || _la === 349)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 8366; + this.match(PostgreSqlParser.KW_VALUE); + } + } -export class CreateforeigntablestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createforeigntablestmt; - } - public override copyFrom(ctx: CreateforeigntablestmtContext): void { - super.copyFrom(ctx); - } -} -export class CreateForeignTableContext extends CreateforeigntablestmtContext { - public constructor(ctx: CreateforeigntablestmtContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_FOREIGN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; - } - public KW_TABLE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TABLE, 0)!; - } - public table_name_create(): Table_name_createContext { - return this.getRuleContext(0, Table_name_createContext)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public KW_SERVER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public opttableelementlist(): OpttableelementlistContext | null { - return this.getRuleContext(0, OpttableelementlistContext); - } - public optinherit(): OptinheritContext | null { - return this.getRuleContext(0, OptinheritContext); - } - public create_generic_options(): Create_generic_optionsContext | null { - return this.getRuleContext(0, Create_generic_optionsContext); - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateForeignTable) { - listener.enterCreateForeignTable(this); + this.state = 8369; + this.default_values_or_values(); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateForeignTable) { - listener.exitCreateForeignTable(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateForeignTable) { - return visitor.visitCreateForeignTable(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} -export class CreatePartitionForeignTableContext extends CreateforeigntablestmtContext { - public constructor(ctx: CreateforeigntablestmtContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_FOREIGN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; - } - public KW_TABLE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TABLE, 0)!; - } - public table_name_create(): Table_name_createContext { - return this.getRuleContext(0, Table_name_createContext)!; - } - public KW_PARTITION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PARTITION, 0)!; - } - public KW_OF(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OF, 0)!; - } - public table_name(): Table_nameContext { - return this.getRuleContext(0, Table_nameContext)!; - } - public partitionboundspec(): PartitionboundspecContext { - return this.getRuleContext(0, PartitionboundspecContext)!; - } - public KW_SERVER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public opttypedtableelementlist(): OpttypedtableelementlistContext | null { - return this.getRuleContext(0, OpttypedtableelementlistContext); - } - public create_generic_options(): Create_generic_optionsContext | null { - return this.getRuleContext(0, Create_generic_optionsContext); - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatePartitionForeignTable) { - listener.enterCreatePartitionForeignTable(this); + public merge_update(): Merge_updateContext { + let localContext = new Merge_updateContext(this.context, this.state); + this.enterRule(localContext, 908, PostgreSqlParser.RULE_merge_update); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 8371; + this.match(PostgreSqlParser.KW_UPDATE); + this.state = 8372; + this.match(PostgreSqlParser.KW_SET); + this.state = 8390; + this.errorHandler.sync(this); + alternative = 1; + do { + switch (alternative) { + case 1: + { + this.state = 8390; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1166, this.context) ) { + case 1: + { + this.state = 8373; + this.column_name(); + this.state = 8374; + this.match(PostgreSqlParser.EQUAL); + this.state = 8375; + this.exprofdefault(); + } + break; + case 2: + { + this.state = 8377; + this.opt_column_list(); + this.state = 8378; + this.match(PostgreSqlParser.EQUAL); + this.state = 8379; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 8380; + this.exprofdefault(); + this.state = 8385; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 8381; + this.match(PostgreSqlParser.COMMA); + this.state = 8382; + this.exprofdefault(); + } + } + this.state = 8387; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 8388; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + } + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 8392; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1167, this.context); + } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatePartitionForeignTable) { - listener.exitCreatePartitionForeignTable(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatePartitionForeignTable) { - return visitor.visitCreatePartitionForeignTable(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class ImportforeignschemastmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_IMPORT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_IMPORT, 0)!; - } - public KW_FOREIGN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; - } - public KW_SCHEMA(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0)!; - } - public schema_name(): Schema_nameContext { - return this.getRuleContext(0, Schema_nameContext)!; - } - public KW_FROM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FROM, 0)!; - } - public KW_SERVER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; - } - public name(): NameContext[]; - public name(i: number): NameContext | null; - public name(i?: number): NameContext[] | NameContext | null { - if (i === undefined) { - return this.getRuleContexts(NameContext); + public default_values_or_values(): Default_values_or_valuesContext { + let localContext = new Default_values_or_valuesContext(this.context, this.state); + this.enterRule(localContext, 910, PostgreSqlParser.RULE_default_values_or_values); + let _la: number; + try { + this.state = 8408; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_VALUES: + this.enterOuterAlt(localContext, 1); + { + this.state = 8394; + this.match(PostgreSqlParser.KW_VALUES); + this.state = 8395; + this.match(PostgreSqlParser.OPEN_PAREN); + this.state = 8396; + this.exprofdefault(); + this.state = 8401; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 6) { + { + { + this.state = 8397; + this.match(PostgreSqlParser.COMMA); + this.state = 8398; + this.exprofdefault(); + } + } + this.state = 8403; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + this.state = 8404; + this.match(PostgreSqlParser.CLOSE_PAREN); + } + break; + case PostgreSqlParser.KW_DEFAULT: + this.enterOuterAlt(localContext, 2); + { + this.state = 8406; + this.match(PostgreSqlParser.KW_DEFAULT); + this.state = 8407; + this.match(PostgreSqlParser.KW_VALUES); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } - - return this.getRuleContext(i, NameContext); - } - public KW_INTO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INTO, 0)!; - } - public import_qualification(): Import_qualificationContext | null { - return this.getRuleContext(0, Import_qualificationContext); - } - public create_generic_options(): Create_generic_optionsContext | null { - return this.getRuleContext(0, Create_generic_optionsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_importforeignschemastmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterImportforeignschemastmt) { - listener.enterImportforeignschemastmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitImportforeignschemastmt) { - listener.exitImportforeignschemastmt(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitImportforeignschemastmt) { - return visitor.visitImportforeignschemastmt(this); - } else { - return visitor.visitChildren(this); + public exprofdefault(): ExprofdefaultContext { + let localContext = new ExprofdefaultContext(this.context, this.state); + this.enterRule(localContext, 912, PostgreSqlParser.RULE_exprofdefault); + try { + this.state = 8412; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1170, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 8410; + this.sortby(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 8411; + this.match(PostgreSqlParser.KW_DEFAULT); + } + break; + } } - } -} - - -export class Import_qualification_typeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_LIMIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LIMIT, 0); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public KW_EXCEPT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXCEPT, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_import_qualification_type; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterImport_qualification_type) { - listener.enterImport_qualification_type(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitImport_qualification_type) { - listener.exitImport_qualification_type(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitImport_qualification_type) { - return visitor.visitImport_qualification_type(this); - } else { - return visitor.visitChildren(this); + public stmt_close(): Stmt_closeContext { + let localContext = new Stmt_closeContext(this.context, this.state); + this.enterRule(localContext, 914, PostgreSqlParser.RULE_stmt_close); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8414; + this.match(PostgreSqlParser.KW_CLOSE); + this.state = 8415; + this.cursor_variable(); + this.state = 8416; + this.match(PostgreSqlParser.SEMI); + } } - } -} - - -export class Import_qualificationContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public import_qualification_type(): Import_qualification_typeContext { - return this.getRuleContext(0, Import_qualification_typeContext)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public relation_expr_list(): Relation_expr_listContext { - return this.getRuleContext(0, Relation_expr_listContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_import_qualification; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterImport_qualification) { - listener.enterImport_qualification(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitImport_qualification) { - listener.exitImport_qualification(this); + finally { + this.exitRule(); } + return localContext; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitImport_qualification) { - return visitor.visitImport_qualification(this); - } else { - return visitor.visitChildren(this); + public stmt_null(): Stmt_nullContext { + let localContext = new Stmt_nullContext(this.context, this.state); + this.enterRule(localContext, 916, PostgreSqlParser.RULE_stmt_null); + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8418; + this.match(PostgreSqlParser.KW_NULL); + this.state = 8419; + this.match(PostgreSqlParser.SEMI); + } } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; } -} - - -export class CreateusermappingstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_USER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USER, 0)!; - } - public KW_MAPPING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_MAPPING, 0)!; - } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; - } - public auth_ident(): Auth_identContext { - return this.getRuleContext(0, Auth_identContext)!; - } - public KW_SERVER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public create_generic_options(): Create_generic_optionsContext | null { - return this.getRuleContext(0, Create_generic_optionsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createusermappingstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateusermappingstmt) { - listener.enterCreateusermappingstmt(this); + public stmt_commit_or_rollback(): Stmt_commit_or_rollbackContext { + let localContext = new Stmt_commit_or_rollbackContext(this.context, this.state); + this.enterRule(localContext, 918, PostgreSqlParser.RULE_stmt_commit_or_rollback); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8421; + _la = this.tokenStream.LA(1); + if(!(_la === 161 || _la === 319)) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + this.state = 8427; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 33) { + { + this.state = 8422; + this.match(PostgreSqlParser.KW_AND); + this.state = 8424; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 269) { + { + this.state = 8423; + this.match(PostgreSqlParser.KW_NO); + } + } + + this.state = 8426; + this.match(PostgreSqlParser.KW_CHAIN); + } + } + + this.state = 8429; + this.match(PostgreSqlParser.SEMI); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateusermappingstmt) { - listener.exitCreateusermappingstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateusermappingstmt) { - return visitor.visitCreateusermappingstmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Auth_identContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public rolespec(): RolespecContext | null { - return this.getRuleContext(0, RolespecContext); - } - public KW_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USER, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_auth_ident; + public stmt_set(): Stmt_setContext { + let localContext = new Stmt_setContext(this.context, this.state); + this.enterRule(localContext, 920, PostgreSqlParser.RULE_stmt_set); + try { + this.state = 8443; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_SET: + this.enterOuterAlt(localContext, 1); + { + this.state = 8431; + this.match(PostgreSqlParser.KW_SET); + this.state = 8432; + this.any_name(); + this.state = 8433; + this.match(PostgreSqlParser.KW_TO); + this.state = 8434; + this.match(PostgreSqlParser.KW_DEFAULT); + this.state = 8435; + this.match(PostgreSqlParser.SEMI); + } + break; + case PostgreSqlParser.KW_RESET: + this.enterOuterAlt(localContext, 2); + { + this.state = 8437; + this.match(PostgreSqlParser.KW_RESET); + this.state = 8440; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + { + this.state = 8438; + this.any_name(); + } + break; + case PostgreSqlParser.KW_ALL: + { + this.state = 8439; + this.match(PostgreSqlParser.KW_ALL); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + this.state = 8442; + this.match(PostgreSqlParser.SEMI); + } + break; + default: + throw new antlr.NoViableAltException(this); + } + } + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return localContext; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAuth_ident) { - listener.enterAuth_ident(this); + public cursor_variable(): Cursor_variableContext { + let localContext = new Cursor_variableContext(this.context, this.state); + this.enterRule(localContext, 922, PostgreSqlParser.RULE_cursor_variable); + try { + this.state = 8447; + this.errorHandler.sync(this); + switch (this.tokenStream.LA(1)) { + case PostgreSqlParser.KW_AND: + case PostgreSqlParser.KW_ARRAY: + case PostgreSqlParser.KW_COLLATE: + case PostgreSqlParser.KW_CONSTRAINT: + case PostgreSqlParser.KW_DEFAULT: + case PostgreSqlParser.KW_DO: + case PostgreSqlParser.KW_FETCH: + case PostgreSqlParser.KW_IS: + case PostgreSqlParser.KW_OUTER: + case PostgreSqlParser.KW_OVER: + case PostgreSqlParser.KW_ABORT: + case PostgreSqlParser.KW_ABSOLUTE: + case PostgreSqlParser.KW_ACCESS: + case PostgreSqlParser.KW_ACTION: + case PostgreSqlParser.KW_ADD: + case PostgreSqlParser.KW_ADMIN: + case PostgreSqlParser.KW_AFTER: + case PostgreSqlParser.KW_AGGREGATE: + case PostgreSqlParser.KW_ALSO: + case PostgreSqlParser.KW_ALTER: + case PostgreSqlParser.KW_ALWAYS: + case PostgreSqlParser.KW_ASSERTION: + case PostgreSqlParser.KW_ASSIGNMENT: + case PostgreSqlParser.KW_AT: + case PostgreSqlParser.KW_ATTRIBUTE: + case PostgreSqlParser.KW_BACKWARD: + case PostgreSqlParser.KW_BEFORE: + case PostgreSqlParser.KW_BEGIN: + case PostgreSqlParser.KW_BY: + case PostgreSqlParser.KW_CACHE: + case PostgreSqlParser.KW_CALLED: + case PostgreSqlParser.KW_CASCADE: + case PostgreSqlParser.KW_CASCADED: + case PostgreSqlParser.KW_CATALOG: + case PostgreSqlParser.KW_CHAIN: + case PostgreSqlParser.KW_CHARACTERISTICS: + case PostgreSqlParser.KW_CHECKPOINT: + case PostgreSqlParser.KW_CLASS: + case PostgreSqlParser.KW_CLOSE: + case PostgreSqlParser.KW_CLUSTER: + case PostgreSqlParser.KW_COMMENT: + case PostgreSqlParser.KW_COMMENTS: + case PostgreSqlParser.KW_COMMIT: + case PostgreSqlParser.KW_COMMITTED: + case PostgreSqlParser.KW_CONFIGURATION: + case PostgreSqlParser.KW_CONNECTION: + case PostgreSqlParser.KW_CONSTRAINTS: + case PostgreSqlParser.KW_CONTENT: + case PostgreSqlParser.KW_CONTINUE: + case PostgreSqlParser.KW_CONVERSION: + case PostgreSqlParser.KW_COPY: + case PostgreSqlParser.KW_COST: + case PostgreSqlParser.KW_CSV: + case PostgreSqlParser.KW_CURSOR: + case PostgreSqlParser.KW_CYCLE: + case PostgreSqlParser.KW_DATA: + case PostgreSqlParser.KW_DATABASE: + case PostgreSqlParser.KW_DAY: + case PostgreSqlParser.KW_DEALLOCATE: + case PostgreSqlParser.KW_DECLARE: + case PostgreSqlParser.KW_DEFAULTS: + case PostgreSqlParser.KW_DEFERRED: + case PostgreSqlParser.KW_DEFINER: + case PostgreSqlParser.KW_DELETE: + case PostgreSqlParser.KW_DELIMITER: + case PostgreSqlParser.KW_DELIMITERS: + case PostgreSqlParser.KW_DICTIONARY: + case PostgreSqlParser.KW_DISABLE: + case PostgreSqlParser.KW_DISCARD: + case PostgreSqlParser.KW_DOCUMENT: + case PostgreSqlParser.KW_DOMAIN: + case PostgreSqlParser.KW_DOUBLE: + case PostgreSqlParser.KW_DROP: + case PostgreSqlParser.KW_EACH: + case PostgreSqlParser.KW_ENABLE: + case PostgreSqlParser.KW_ENCODING: + case PostgreSqlParser.KW_ENCRYPTED: + case PostgreSqlParser.KW_ENUM: + case PostgreSqlParser.KW_ESCAPE: + case PostgreSqlParser.KW_EVENT: + case PostgreSqlParser.KW_EXCLUDE: + case PostgreSqlParser.KW_EXCLUDING: + case PostgreSqlParser.KW_EXCLUSIVE: + case PostgreSqlParser.KW_EXECUTE: + case PostgreSqlParser.KW_EXPLAIN: + case PostgreSqlParser.KW_EXTENSION: + case PostgreSqlParser.KW_EXTERNAL: + case PostgreSqlParser.KW_FAMILY: + case PostgreSqlParser.KW_FIRST: + case PostgreSqlParser.KW_FOLLOWING: + case PostgreSqlParser.KW_FORCE: + case PostgreSqlParser.KW_FORWARD: + case PostgreSqlParser.KW_FUNCTION: + case PostgreSqlParser.KW_FUNCTIONS: + case PostgreSqlParser.KW_GLOBAL: + case PostgreSqlParser.KW_GRANTED: + case PostgreSqlParser.KW_HANDLER: + case PostgreSqlParser.KW_HEADER: + case PostgreSqlParser.KW_HOLD: + case PostgreSqlParser.KW_HOUR: + case PostgreSqlParser.KW_IDENTITY: + case PostgreSqlParser.KW_IF: + case PostgreSqlParser.KW_IMMEDIATE: + case PostgreSqlParser.KW_IMMUTABLE: + case PostgreSqlParser.KW_IMPLICIT: + case PostgreSqlParser.KW_INCLUDING: + case PostgreSqlParser.KW_INCREMENT: + case PostgreSqlParser.KW_INDEX: + case PostgreSqlParser.KW_INDEXES: + case PostgreSqlParser.KW_INHERIT: + case PostgreSqlParser.KW_INHERITS: + case PostgreSqlParser.KW_INLINE: + case PostgreSqlParser.KW_INSENSITIVE: + case PostgreSqlParser.KW_INSERT: + case PostgreSqlParser.KW_INSTEAD: + case PostgreSqlParser.KW_INVOKER: + case PostgreSqlParser.KW_ISOLATION: + case PostgreSqlParser.KW_KEY: + case PostgreSqlParser.KW_LABEL: + case PostgreSqlParser.KW_LANGUAGE: + case PostgreSqlParser.KW_LARGE: + case PostgreSqlParser.KW_LAST: + case PostgreSqlParser.KW_LEAKPROOF: + case PostgreSqlParser.KW_LEVEL: + case PostgreSqlParser.KW_LISTEN: + case PostgreSqlParser.KW_LOAD: + case PostgreSqlParser.KW_LOCAL: + case PostgreSqlParser.KW_LOCATION: + case PostgreSqlParser.KW_LOCK: + case PostgreSqlParser.KW_MAPPING: + case PostgreSqlParser.KW_MATCH: + case PostgreSqlParser.KW_MATERIALIZED: + case PostgreSqlParser.KW_MAXVALUE: + case PostgreSqlParser.KW_MINUTE: + case PostgreSqlParser.KW_MINVALUE: + case PostgreSqlParser.KW_MODE: + case PostgreSqlParser.KW_MONTH: + case PostgreSqlParser.KW_MOVE: + case PostgreSqlParser.KW_NAME: + case PostgreSqlParser.KW_NAMES: + case PostgreSqlParser.KW_NEXT: + case PostgreSqlParser.KW_NO: + case PostgreSqlParser.KW_NOTHING: + case PostgreSqlParser.KW_NOTIFY: + case PostgreSqlParser.KW_NOWAIT: + case PostgreSqlParser.KW_NULLS: + case PostgreSqlParser.KW_OBJECT: + case PostgreSqlParser.KW_OF: + case PostgreSqlParser.KW_OFF: + case PostgreSqlParser.KW_OIDS: + case PostgreSqlParser.KW_OPERATOR: + case PostgreSqlParser.KW_OPTION: + case PostgreSqlParser.KW_OPTIONS: + case PostgreSqlParser.KW_OWNED: + case PostgreSqlParser.KW_OWNER: + case PostgreSqlParser.KW_PARSER: + case PostgreSqlParser.KW_PARTIAL: + case PostgreSqlParser.KW_PARTITION: + case PostgreSqlParser.KW_PASSING: + case PostgreSqlParser.KW_PASSWORD: + case PostgreSqlParser.KW_PLANS: + case PostgreSqlParser.KW_PRECEDING: + case PostgreSqlParser.KW_PREPARE: + case PostgreSqlParser.KW_PREPARED: + case PostgreSqlParser.KW_PRESERVE: + case PostgreSqlParser.KW_PRIOR: + case PostgreSqlParser.KW_PRIVILEGES: + case PostgreSqlParser.KW_PROCEDURAL: + case PostgreSqlParser.KW_PROCEDURE: + case PostgreSqlParser.KW_PROGRAM: + case PostgreSqlParser.KW_QUOTE: + case PostgreSqlParser.KW_RANGE: + case PostgreSqlParser.KW_READ: + case PostgreSqlParser.KW_REASSIGN: + case PostgreSqlParser.KW_RECHECK: + case PostgreSqlParser.KW_RECURSIVE: + case PostgreSqlParser.KW_REF: + case PostgreSqlParser.KW_REFRESH: + case PostgreSqlParser.KW_REINDEX: + case PostgreSqlParser.KW_RELATIVE: + case PostgreSqlParser.KW_RELEASE: + case PostgreSqlParser.KW_RENAME: + case PostgreSqlParser.KW_REPEATABLE: + case PostgreSqlParser.KW_REPLACE: + case PostgreSqlParser.KW_REPLICA: + case PostgreSqlParser.KW_RESET: + case PostgreSqlParser.KW_RESTART: + case PostgreSqlParser.KW_RESTRICT: + case PostgreSqlParser.KW_RETURNS: + case PostgreSqlParser.KW_REVOKE: + case PostgreSqlParser.KW_ROLE: + case PostgreSqlParser.KW_ROLLBACK: + case PostgreSqlParser.KW_ROWS: + case PostgreSqlParser.KW_RULE: + case PostgreSqlParser.KW_SAVEPOINT: + case PostgreSqlParser.KW_SCHEMA: + case PostgreSqlParser.KW_SCROLL: + case PostgreSqlParser.KW_SEARCH: + case PostgreSqlParser.KW_SECOND: + case PostgreSqlParser.KW_SECURITY: + case PostgreSqlParser.KW_SEQUENCE: + case PostgreSqlParser.KW_SEQUENCES: + case PostgreSqlParser.KW_SERIALIZABLE: + case PostgreSqlParser.KW_SERVER: + case PostgreSqlParser.KW_SESSION: + case PostgreSqlParser.KW_SET: + case PostgreSqlParser.KW_SHARE: + case PostgreSqlParser.KW_SHOW: + case PostgreSqlParser.KW_SIMPLE: + case PostgreSqlParser.KW_SNAPSHOT: + case PostgreSqlParser.KW_STABLE: + case PostgreSqlParser.KW_STANDALONE: + case PostgreSqlParser.KW_START: + case PostgreSqlParser.KW_STATEMENT: + case PostgreSqlParser.KW_STATISTICS: + case PostgreSqlParser.KW_STDIN: + case PostgreSqlParser.KW_STDOUT: + case PostgreSqlParser.KW_STORAGE: + case PostgreSqlParser.KW_STRICT: + case PostgreSqlParser.KW_STRIP: + case PostgreSqlParser.KW_SYSID: + case PostgreSqlParser.KW_SYSTEM: + case PostgreSqlParser.KW_TABLES: + case PostgreSqlParser.KW_TABLESPACE: + case PostgreSqlParser.KW_TEMP: + case PostgreSqlParser.KW_TEMPLATE: + case PostgreSqlParser.KW_TEMPORARY: + case PostgreSqlParser.KW_TEXT: + case PostgreSqlParser.KW_TRANSACTION: + case PostgreSqlParser.KW_TRIGGER: + case PostgreSqlParser.KW_TRUNCATE: + case PostgreSqlParser.KW_TRUSTED: + case PostgreSqlParser.KW_TYPE: + case PostgreSqlParser.KW_TYPES: + case PostgreSqlParser.KW_UNBOUNDED: + case PostgreSqlParser.KW_UNCOMMITTED: + case PostgreSqlParser.KW_UNENCRYPTED: + case PostgreSqlParser.KW_UNKNOWN: + case PostgreSqlParser.KW_UNLISTEN: + case PostgreSqlParser.KW_UNLOGGED: + case PostgreSqlParser.KW_UNTIL: + case PostgreSqlParser.KW_UPDATE: + case PostgreSqlParser.KW_VACUUM: + case PostgreSqlParser.KW_VALID: + case PostgreSqlParser.KW_VALIDATE: + case PostgreSqlParser.KW_VALIDATOR: + case PostgreSqlParser.KW_VARYING: + case PostgreSqlParser.KW_VERSION: + case PostgreSqlParser.KW_VIEW: + case PostgreSqlParser.KW_VOLATILE: + case PostgreSqlParser.KW_WHITESPACE: + case PostgreSqlParser.KW_WITHOUT: + case PostgreSqlParser.KW_WORK: + case PostgreSqlParser.KW_WRAPPER: + case PostgreSqlParser.KW_WRITE: + case PostgreSqlParser.KW_XML: + case PostgreSqlParser.KW_YEAR: + case PostgreSqlParser.KW_YES: + case PostgreSqlParser.KW_ZONE: + case PostgreSqlParser.KW_BETWEEN: + case PostgreSqlParser.KW_BIGINT: + case PostgreSqlParser.KW_BIT: + case PostgreSqlParser.KW_BOOLEAN: + case PostgreSqlParser.KW_CHAR: + case PostgreSqlParser.KW_CHARACTER: + case PostgreSqlParser.KW_COALESCE: + case PostgreSqlParser.KW_DEC: + case PostgreSqlParser.KW_DECIMAL: + case PostgreSqlParser.KW_EXISTS: + case PostgreSqlParser.KW_EXTRACT: + case PostgreSqlParser.KW_FLOAT: + case PostgreSqlParser.KW_GREATEST: + case PostgreSqlParser.KW_INOUT: + case PostgreSqlParser.KW_INT: + case PostgreSqlParser.KW_INTEGER: + case PostgreSqlParser.KW_INTERVAL: + case PostgreSqlParser.KW_LEAST: + case PostgreSqlParser.KW_NATIONAL: + case PostgreSqlParser.KW_NCHAR: + case PostgreSqlParser.KW_NONE: + case PostgreSqlParser.KW_NULLIF: + case PostgreSqlParser.KW_NUMERIC: + case PostgreSqlParser.KW_OVERLAY: + case PostgreSqlParser.KW_POSITION: + case PostgreSqlParser.KW_PRECISION: + case PostgreSqlParser.KW_REAL: + case PostgreSqlParser.KW_ROW: + case PostgreSqlParser.KW_SETOF: + case PostgreSqlParser.KW_SMALLINT: + case PostgreSqlParser.KW_SUBSTRING: + case PostgreSqlParser.KW_TIME: + case PostgreSqlParser.KW_TIMESTAMP: + case PostgreSqlParser.KW_TREAT: + case PostgreSqlParser.KW_TRIM: + case PostgreSqlParser.KW_VALUES: + case PostgreSqlParser.KW_VARCHAR: + case PostgreSqlParser.KW_XMLATTRIBUTES: + case PostgreSqlParser.KW_XMLCONCAT: + case PostgreSqlParser.KW_XMLELEMENT: + case PostgreSqlParser.KW_XMLEXISTS: + case PostgreSqlParser.KW_XMLFOREST: + case PostgreSqlParser.KW_XMLPARSE: + case PostgreSqlParser.KW_XMLPI: + case PostgreSqlParser.KW_XMLROOT: + case PostgreSqlParser.KW_XMLSERIALIZE: + case PostgreSqlParser.KW_CALL: + case PostgreSqlParser.KW_CURRENT: + case PostgreSqlParser.KW_ATTACH: + case PostgreSqlParser.KW_DETACH: + case PostgreSqlParser.KW_EXPRESSION: + case PostgreSqlParser.KW_GENERATED: + case PostgreSqlParser.KW_LOGGED: + case PostgreSqlParser.KW_STORED: + case PostgreSqlParser.KW_INCLUDE: + case PostgreSqlParser.KW_ROUTINE: + case PostgreSqlParser.KW_TRANSFORM: + case PostgreSqlParser.KW_IMPORT: + case PostgreSqlParser.KW_POLICY: + case PostgreSqlParser.KW_METHOD: + case PostgreSqlParser.KW_REFERENCING: + case PostgreSqlParser.KW_NEW: + case PostgreSqlParser.KW_OLD: + case PostgreSqlParser.KW_VALUE: + case PostgreSqlParser.KW_SUBSCRIPTION: + case PostgreSqlParser.KW_PUBLICATION: + case PostgreSqlParser.KW_OUT: + case PostgreSqlParser.KW_ROUTINES: + case PostgreSqlParser.KW_SCHEMAS: + case PostgreSqlParser.KW_PROCEDURES: + case PostgreSqlParser.KW_INPUT: + case PostgreSqlParser.KW_SUPPORT: + case PostgreSqlParser.KW_PARALLEL: + case PostgreSqlParser.KW_SQL: + case PostgreSqlParser.KW_DEPENDS: + case PostgreSqlParser.KW_OVERRIDING: + case PostgreSqlParser.KW_CONFLICT: + case PostgreSqlParser.KW_SKIP: + case PostgreSqlParser.KW_LOCKED: + case PostgreSqlParser.KW_TIES: + case PostgreSqlParser.KW_ROLLUP: + case PostgreSqlParser.KW_CUBE: + case PostgreSqlParser.KW_GROUPING: + case PostgreSqlParser.KW_SETS: + case PostgreSqlParser.KW_ORDINALITY: + case PostgreSqlParser.KW_XMLTABLE: + case PostgreSqlParser.KW_COLUMNS: + case PostgreSqlParser.KW_XMLNAMESPACES: + case PostgreSqlParser.KW_ROWTYPE: + case PostgreSqlParser.KW_NORMALIZED: + case PostgreSqlParser.KW_WITHIN: + case PostgreSqlParser.KW_FILTER: + case PostgreSqlParser.KW_GROUPS: + case PostgreSqlParser.KW_OTHERS: + case PostgreSqlParser.KW_NFC: + case PostgreSqlParser.KW_NFD: + case PostgreSqlParser.KW_NFKC: + case PostgreSqlParser.KW_NFKD: + case PostgreSqlParser.KW_UESCAPE: + case PostgreSqlParser.KW_VIEWS: + case PostgreSqlParser.KW_NORMALIZE: + case PostgreSqlParser.KW_DUMP: + case PostgreSqlParser.KW_PRINT_STRICT_PARAMS: + case PostgreSqlParser.KW_VARIABLE_CONFLICT: + case PostgreSqlParser.KW_ERROR: + case PostgreSqlParser.KW_USE_VARIABLE: + case PostgreSqlParser.KW_USE_COLUMN: + case PostgreSqlParser.KW_ALIAS: + case PostgreSqlParser.KW_CONSTANT: + case PostgreSqlParser.KW_PERFORM: + case PostgreSqlParser.KW_GET: + case PostgreSqlParser.KW_DIAGNOSTICS: + case PostgreSqlParser.KW_STACKED: + case PostgreSqlParser.KW_ELSIF: + case PostgreSqlParser.KW_REVERSE: + case PostgreSqlParser.KW_SLICE: + case PostgreSqlParser.KW_EXIT: + case PostgreSqlParser.KW_RETURN: + case PostgreSqlParser.KW_QUERY: + case PostgreSqlParser.KW_RAISE: + case PostgreSqlParser.KW_SQLSTATE: + case PostgreSqlParser.KW_DEBUG: + case PostgreSqlParser.KW_LOG: + case PostgreSqlParser.KW_INFO: + case PostgreSqlParser.KW_NOTICE: + case PostgreSqlParser.KW_WARNING: + case PostgreSqlParser.KW_EXCEPTION: + case PostgreSqlParser.KW_ASSERT: + case PostgreSqlParser.KW_OPEN: + case PostgreSqlParser.KW_SKIP_LOCKED: + case PostgreSqlParser.KW_BUFFER_USAGE_LIMIT: + case PostgreSqlParser.Identifier: + case PostgreSqlParser.QuotedIdentifier: + case PostgreSqlParser.UnicodeQuotedIdentifier: + case PostgreSqlParser.StringConstant: + case PostgreSqlParser.UnicodeEscapeStringConstant: + case PostgreSqlParser.BeginDollarStringConstant: + case PostgreSqlParser.PLSQLVARIABLENAME: + case PostgreSqlParser.PLSQLIDENTIFIER: + case PostgreSqlParser.EscapeStringConstant: + this.enterOuterAlt(localContext, 1); + { + this.state = 8445; + this.colid(); + } + break; + case PostgreSqlParser.PARAM: + this.enterOuterAlt(localContext, 2); + { + this.state = 8446; + this.match(PostgreSqlParser.PARAM); + } + break; + default: + throw new antlr.NoViableAltException(this); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAuth_ident) { - listener.exitAuth_ident(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAuth_ident) { - return visitor.visitAuth_ident(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class AlterusermappingstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_USER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USER, 0)!; - } - public KW_MAPPING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_MAPPING, 0)!; - } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; - } - public auth_ident(): Auth_identContext { - return this.getRuleContext(0, Auth_identContext)!; - } - public KW_SERVER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public alter_generic_options(): Alter_generic_optionsContext { - return this.getRuleContext(0, Alter_generic_optionsContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterusermappingstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterusermappingstmt) { - listener.enterAlterusermappingstmt(this); + public exception_sect(): Exception_sectContext { + let localContext = new Exception_sectContext(this.context, this.state); + this.enterRule(localContext, 924, PostgreSqlParser.RULE_exception_sect); + let _la: number; + try { + let alternative: number; + this.enterOuterAlt(localContext, 1); + { + this.state = 8449; + this.match(PostgreSqlParser.KW_EXCEPTION); + this.state = 8466; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + do { + { + { + this.state = 8450; + this.match(PostgreSqlParser.KW_WHEN); + { + this.state = 8451; + this.proc_condition(); + this.state = 8456; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + while (_la === 82) { + { + { + this.state = 8452; + this.match(PostgreSqlParser.KW_OR); + this.state = 8453; + this.proc_condition(); + } + } + this.state = 8458; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } + } + this.state = 8459; + this.match(PostgreSqlParser.KW_THEN); + this.state = 8463; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1177, this.context); + while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) { + if (alternative === 1) { + { + { + this.state = 8460; + this.proc_stmt(); + } + } + } + this.state = 8465; + this.errorHandler.sync(this); + alternative = this.interpreter.adaptivePredict(this.tokenStream, 1177, this.context); + } + } + } + this.state = 8468; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + } while (_la === 102); + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterusermappingstmt) { - listener.exitAlterusermappingstmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterusermappingstmt) { - return visitor.visitAlterusermappingstmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class CreatepolicystmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_POLICY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_POLICY, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; - } - public qualified_name(): Qualified_nameContext { - return this.getRuleContext(0, Qualified_nameContext)!; - } - public rowsecuritydefaultpermissive(): RowsecuritydefaultpermissiveContext | null { - return this.getRuleContext(0, RowsecuritydefaultpermissiveContext); - } - public rowsecuritydefaultforcmd(): RowsecuritydefaultforcmdContext | null { - return this.getRuleContext(0, RowsecuritydefaultforcmdContext); - } - public rowsecuritydefaulttorole(): RowsecuritydefaulttoroleContext | null { - return this.getRuleContext(0, RowsecuritydefaulttoroleContext); - } - public rowsecurityoptionalexpr(): RowsecurityoptionalexprContext | null { - return this.getRuleContext(0, RowsecurityoptionalexprContext); - } - public rowsecurityoptionalwithcheck(): RowsecurityoptionalwithcheckContext | null { - return this.getRuleContext(0, RowsecurityoptionalwithcheckContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createpolicystmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatepolicystmt) { - listener.enterCreatepolicystmt(this); + public proc_condition(): Proc_conditionContext { + let localContext = new Proc_conditionContext(this.context, this.state); + this.enterRule(localContext, 926, PostgreSqlParser.RULE_proc_condition); + try { + this.state = 8473; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1179, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 8470; + this.any_identifier(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 8471; + this.match(PostgreSqlParser.KW_SQLSTATE); + this.state = 8472; + this.sconst(); + } + break; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatepolicystmt) { - listener.exitCreatepolicystmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatepolicystmt) { - return visitor.visitCreatepolicystmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class AlterpolicystmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_POLICY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_POLICY, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; - } - public qualified_name(): Qualified_nameContext { - return this.getRuleContext(0, Qualified_nameContext)!; - } - public rowsecurityoptionaltorole(): RowsecurityoptionaltoroleContext | null { - return this.getRuleContext(0, RowsecurityoptionaltoroleContext); - } - public rowsecurityoptionalexpr(): RowsecurityoptionalexprContext | null { - return this.getRuleContext(0, RowsecurityoptionalexprContext); - } - public rowsecurityoptionalwithcheck(): RowsecurityoptionalwithcheckContext | null { - return this.getRuleContext(0, RowsecurityoptionalwithcheckContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterpolicystmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterpolicystmt) { - listener.enterAlterpolicystmt(this); + public any_identifier(): Any_identifierContext { + let localContext = new Any_identifierContext(this.context, this.state); + this.enterRule(localContext, 928, PostgreSqlParser.RULE_any_identifier); + try { + this.state = 8477; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1180, this.context) ) { + case 1: + this.enterOuterAlt(localContext, 1); + { + this.state = 8475; + this.colid(); + } + break; + case 2: + this.enterOuterAlt(localContext, 2); + { + this.state = 8476; + this.plsql_unreserved_keyword(); + } + break; + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterpolicystmt) { - listener.exitAlterpolicystmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterpolicystmt) { - return visitor.visitAlterpolicystmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class AlterprocedurestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_PROCEDURE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0)!; - } - public procedure_name(): Procedure_nameContext { - return this.getRuleContext(0, Procedure_nameContext)!; - } - public procedure_cluase(): Procedure_cluaseContext { - return this.getRuleContext(0, Procedure_cluaseContext)!; - } - public func_args(): Func_argsContext | null { - return this.getRuleContext(0, Func_argsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterprocedurestmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterprocedurestmt) { - listener.enterAlterprocedurestmt(this); + public plsql_unreserved_keyword(): Plsql_unreserved_keywordContext { + let localContext = new Plsql_unreserved_keywordContext(this.context, this.state); + this.enterRule(localContext, 930, PostgreSqlParser.RULE_plsql_unreserved_keyword); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8479; + _la = this.tokenStream.LA(1); + if(!(((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 286266373) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & 268451969) !== 0) || ((((_la - 153)) & ~0x1F) === 0 && ((1 << (_la - 153)) & 540945) !== 0) || _la === 207 || _la === 210 || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & 419430657) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & 268451841) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & 1051713) !== 0) || _la === 360 || _la === 433 || _la === 434 || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & 3959414785) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & 3071) !== 0))) { + this.errorHandler.recoverInline(this); + } + else { + this.errorHandler.reportMatch(this); + this.consume(); + } + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterprocedurestmt) { - listener.exitAlterprocedurestmt(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterprocedurestmt) { - return visitor.visitAlterprocedurestmt(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} + public sql_expression(): Sql_expressionContext { + let localContext = new Sql_expressionContext(this.context, this.state); + this.enterRule(localContext, 932, PostgreSqlParser.RULE_sql_expression); + let _la: number; + try { + this.enterOuterAlt(localContext, 1); + { + this.state = 8482; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1181, this.context) ) { + case 1: + { + this.state = 8481; + this.target_list(); + } + break; + } + this.state = 8485; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1182, this.context) ) { + case 1: + { + this.state = 8484; + this.into_clause(); + } + break; + } + this.state = 8488; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 64) { + { + this.state = 8487; + this.from_clause(); + } + } + + this.state = 8491; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 103) { + { + this.state = 8490; + this.where_clause(); + } + } + this.state = 8494; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 66) { + { + this.state = 8493; + this.group_clause(); + } + } -export class Procedure_cluaseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public procedure_action(): Procedure_actionContext[]; - public procedure_action(i: number): Procedure_actionContext | null; - public procedure_action(i?: number): Procedure_actionContext[] | Procedure_actionContext | null { - if (i === undefined) { - return this.getRuleContexts(Procedure_actionContext); - } + this.state = 8498; + this.errorHandler.sync(this); + _la = this.tokenStream.LA(1); + if (_la === 67) { + { + this.state = 8496; + this.match(PostgreSqlParser.KW_HAVING); + this.state = 8497; + this.expression(); + } + } - return this.getRuleContext(i, Procedure_actionContext); - } - public KW_RESTRICT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESTRICT, 0); - } - public KW_RENAME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RENAME, 0); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public procedure_name_create(): Procedure_name_createContext | null { - return this.getRuleContext(0, Procedure_name_createContext); - } - public KW_OWNER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OWNER, 0); - } - public rolespec(): RolespecContext | null { - return this.getRuleContext(0, RolespecContext); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); - } - public schema_name_create(): Schema_name_createContext | null { - return this.getRuleContext(0, Schema_name_createContext); - } - public KW_DEPENDS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEPENDS, 0); - } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); - } - public KW_EXTENSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXTENSION, 0); - } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); - } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_procedure_cluase; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterProcedure_cluase) { - listener.enterProcedure_cluase(this); + this.state = 8501; + this.errorHandler.sync(this); + switch (this.interpreter.adaptivePredict(this.tokenStream, 1187, this.context) ) { + case 1: + { + this.state = 8500; + this.window_clause(); + } + break; + } + } } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitProcedure_cluase) { - listener.exitProcedure_cluase(this); + catch (re) { + if (re instanceof antlr.RecognitionException) { + localContext.exception = re; + this.errorHandler.reportError(this, re); + this.errorHandler.recover(this, re); + } else { + throw re; + } } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitProcedure_cluase) { - return visitor.visitProcedure_cluase(this); - } else { - return visitor.visitChildren(this); + finally { + this.exitRule(); } + return localContext; } -} - - -export class Procedure_actionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_SECURITY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SECURITY, 0); - } - public KW_INVOKER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INVOKER, 0); - } - public KW_DEFINER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFINER, 0); - } - public KW_EXTERNAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXTERNAL, 0); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public name(): NameContext[]; - public name(i: number): NameContext | null; - public name(i?: number): NameContext[] | NameContext | null { - if (i === undefined) { - return this.getRuleContexts(NameContext); - } - return this.getRuleContext(i, NameContext); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public STAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.STAR, 0); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public KW_CURRENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT, 0); - } - public KW_RESET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESET, 0); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_procedure_action; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterProcedure_action) { - listener.enterProcedure_action(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitProcedure_action) { - listener.exitProcedure_action(this); + public override sempred(localContext: antlr.RuleContext | null, ruleIndex: number, predIndex: number): boolean { + switch (ruleIndex) { + case 338: + return this.booleanExpression_sempred(localContext as BooleanExpressionContext, predIndex); + case 340: + return this.valueExpression_sempred(localContext as ValueExpressionContext, predIndex); + case 341: + return this.primaryExpression_sempred(localContext as PrimaryExpressionContext, predIndex); + case 400: + return this.column_name_sempred(localContext as Column_nameContext, predIndex); } + return true; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitProcedure_action) { - return visitor.visitProcedure_action(this); - } else { - return visitor.visitChildren(this); + private booleanExpression_sempred(localContext: BooleanExpressionContext | null, predIndex: number): boolean { + switch (predIndex) { + case 0: + return this.precpred(this.context, 2); + case 1: + return this.precpred(this.context, 1); } + return true; } -} - - -export class RowsecurityoptionalexprContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_rowsecurityoptionalexpr; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRowsecurityoptionalexpr) { - listener.enterRowsecurityoptionalexpr(this); + private valueExpression_sempred(localContext: ValueExpressionContext | null, predIndex: number): boolean { + switch (predIndex) { + case 2: + return this.precpred(this.context, 3); + case 3: + return this.precpred(this.context, 2); + case 4: + return this.precpred(this.context, 1); + case 5: + return this.precpred(this.context, 5); } + return true; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRowsecurityoptionalexpr) { - listener.exitRowsecurityoptionalexpr(this); + private primaryExpression_sempred(localContext: PrimaryExpressionContext | null, predIndex: number): boolean { + switch (predIndex) { + case 6: + return this.precpred(this.context, 3); + case 7: + return this.precpred(this.context, 6); + case 8: + return this.precpred(this.context, 4); + case 9: + return this.precpred(this.context, 1); } + return true; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRowsecurityoptionalexpr) { - return visitor.visitRowsecurityoptionalexpr(this); - } else { - return visitor.visitChildren(this); + private column_name_sempred(localContext: Column_nameContext | null, predIndex: number): boolean { + switch (predIndex) { + case 10: + return this.shouldMatchEmpty(); } + return true; } -} + public static readonly _serializedATN: number[] = [ + 4,1,590,8504,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6, + 7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7, + 13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2, + 20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7, + 26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2, + 33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7, + 39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2, + 46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7, + 52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2, + 59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7, + 65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2, + 72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7, + 78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2, + 85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7, + 91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2, + 98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103, + 2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109, + 7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114, + 2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120, + 7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125,7,125, + 2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130,2,131, + 7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136,7,136, + 2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141,2,142, + 7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147,7,147, + 2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152,2,153, + 7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,7,158, + 2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164, + 7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169, + 2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175, + 7,175,2,176,7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180, + 2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186, + 7,186,2,187,7,187,2,188,7,188,2,189,7,189,2,190,7,190,2,191,7,191, + 2,192,7,192,2,193,7,193,2,194,7,194,2,195,7,195,2,196,7,196,2,197, + 7,197,2,198,7,198,2,199,7,199,2,200,7,200,2,201,7,201,2,202,7,202, + 2,203,7,203,2,204,7,204,2,205,7,205,2,206,7,206,2,207,7,207,2,208, + 7,208,2,209,7,209,2,210,7,210,2,211,7,211,2,212,7,212,2,213,7,213, + 2,214,7,214,2,215,7,215,2,216,7,216,2,217,7,217,2,218,7,218,2,219, + 7,219,2,220,7,220,2,221,7,221,2,222,7,222,2,223,7,223,2,224,7,224, + 2,225,7,225,2,226,7,226,2,227,7,227,2,228,7,228,2,229,7,229,2,230, + 7,230,2,231,7,231,2,232,7,232,2,233,7,233,2,234,7,234,2,235,7,235, + 2,236,7,236,2,237,7,237,2,238,7,238,2,239,7,239,2,240,7,240,2,241, + 7,241,2,242,7,242,2,243,7,243,2,244,7,244,2,245,7,245,2,246,7,246, + 2,247,7,247,2,248,7,248,2,249,7,249,2,250,7,250,2,251,7,251,2,252, + 7,252,2,253,7,253,2,254,7,254,2,255,7,255,2,256,7,256,2,257,7,257, + 2,258,7,258,2,259,7,259,2,260,7,260,2,261,7,261,2,262,7,262,2,263, + 7,263,2,264,7,264,2,265,7,265,2,266,7,266,2,267,7,267,2,268,7,268, + 2,269,7,269,2,270,7,270,2,271,7,271,2,272,7,272,2,273,7,273,2,274, + 7,274,2,275,7,275,2,276,7,276,2,277,7,277,2,278,7,278,2,279,7,279, + 2,280,7,280,2,281,7,281,2,282,7,282,2,283,7,283,2,284,7,284,2,285, + 7,285,2,286,7,286,2,287,7,287,2,288,7,288,2,289,7,289,2,290,7,290, + 2,291,7,291,2,292,7,292,2,293,7,293,2,294,7,294,2,295,7,295,2,296, + 7,296,2,297,7,297,2,298,7,298,2,299,7,299,2,300,7,300,2,301,7,301, + 2,302,7,302,2,303,7,303,2,304,7,304,2,305,7,305,2,306,7,306,2,307, + 7,307,2,308,7,308,2,309,7,309,2,310,7,310,2,311,7,311,2,312,7,312, + 2,313,7,313,2,314,7,314,2,315,7,315,2,316,7,316,2,317,7,317,2,318, + 7,318,2,319,7,319,2,320,7,320,2,321,7,321,2,322,7,322,2,323,7,323, + 2,324,7,324,2,325,7,325,2,326,7,326,2,327,7,327,2,328,7,328,2,329, + 7,329,2,330,7,330,2,331,7,331,2,332,7,332,2,333,7,333,2,334,7,334, + 2,335,7,335,2,336,7,336,2,337,7,337,2,338,7,338,2,339,7,339,2,340, + 7,340,2,341,7,341,2,342,7,342,2,343,7,343,2,344,7,344,2,345,7,345, + 2,346,7,346,2,347,7,347,2,348,7,348,2,349,7,349,2,350,7,350,2,351, + 7,351,2,352,7,352,2,353,7,353,2,354,7,354,2,355,7,355,2,356,7,356, + 2,357,7,357,2,358,7,358,2,359,7,359,2,360,7,360,2,361,7,361,2,362, + 7,362,2,363,7,363,2,364,7,364,2,365,7,365,2,366,7,366,2,367,7,367, + 2,368,7,368,2,369,7,369,2,370,7,370,2,371,7,371,2,372,7,372,2,373, + 7,373,2,374,7,374,2,375,7,375,2,376,7,376,2,377,7,377,2,378,7,378, + 2,379,7,379,2,380,7,380,2,381,7,381,2,382,7,382,2,383,7,383,2,384, + 7,384,2,385,7,385,2,386,7,386,2,387,7,387,2,388,7,388,2,389,7,389, + 2,390,7,390,2,391,7,391,2,392,7,392,2,393,7,393,2,394,7,394,2,395, + 7,395,2,396,7,396,2,397,7,397,2,398,7,398,2,399,7,399,2,400,7,400, + 2,401,7,401,2,402,7,402,2,403,7,403,2,404,7,404,2,405,7,405,2,406, + 7,406,2,407,7,407,2,408,7,408,2,409,7,409,2,410,7,410,2,411,7,411, + 2,412,7,412,2,413,7,413,2,414,7,414,2,415,7,415,2,416,7,416,2,417, + 7,417,2,418,7,418,2,419,7,419,2,420,7,420,2,421,7,421,2,422,7,422, + 2,423,7,423,2,424,7,424,2,425,7,425,2,426,7,426,2,427,7,427,2,428, + 7,428,2,429,7,429,2,430,7,430,2,431,7,431,2,432,7,432,2,433,7,433, + 2,434,7,434,2,435,7,435,2,436,7,436,2,437,7,437,2,438,7,438,2,439, + 7,439,2,440,7,440,2,441,7,441,2,442,7,442,2,443,7,443,2,444,7,444, + 2,445,7,445,2,446,7,446,2,447,7,447,2,448,7,448,2,449,7,449,2,450, + 7,450,2,451,7,451,2,452,7,452,2,453,7,453,2,454,7,454,2,455,7,455, + 2,456,7,456,2,457,7,457,2,458,7,458,2,459,7,459,2,460,7,460,2,461, + 7,461,2,462,7,462,2,463,7,463,2,464,7,464,2,465,7,465,2,466,7,466, + 1,0,5,0,936,8,0,10,0,12,0,939,9,0,1,0,1,0,1,1,1,1,3,1,945,8,1,1, + 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, + 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, + 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, + 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, + 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, + 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, + 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, + 2,1,2,1,2,1,2,1,2,1,2,3,2,1065,8,2,3,2,1067,8,2,1,3,1,3,1,3,1,4, + 1,4,1,4,1,4,3,4,1076,8,4,1,4,5,4,1079,8,4,10,4,12,4,1082,9,4,1,5, + 1,5,1,5,3,5,1087,8,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, + 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, + 1,5,1,5,1,5,1,5,1,5,1,5,3,5,1122,8,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6, + 1,6,3,6,1132,8,6,1,7,1,7,1,7,1,7,3,7,1138,8,7,1,7,5,7,1141,8,7,10, + 7,12,7,1144,9,7,1,8,1,8,1,8,1,8,3,8,1150,8,8,1,8,5,8,1153,8,8,10, + 8,12,8,1156,9,8,1,9,1,9,1,9,1,9,3,9,1162,8,9,1,9,1,9,1,9,1,9,1,9, + 1,10,1,10,1,10,1,10,3,10,1173,8,10,1,10,1,10,1,11,1,11,5,11,1179, + 8,11,10,11,12,11,1182,9,11,1,11,3,11,1185,8,11,1,11,1,11,1,11,1, + 11,1,11,1,11,1,11,1,11,1,11,1,11,3,11,1197,8,11,1,11,1,11,1,11,1, + 11,3,11,1203,8,11,1,12,1,12,1,12,1,12,3,12,1209,8,12,1,12,1,12,3, + 12,1213,8,12,1,12,1,12,1,12,3,12,1218,8,12,1,12,1,12,3,12,1222,8, + 12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,3,12,1235, + 8,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,3,12,1245,8,12,3,12, + 1247,8,12,1,13,1,13,1,13,1,13,3,13,1253,8,13,1,13,5,13,1256,8,13, + 10,13,12,13,1259,9,13,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,15,1, + 15,1,15,3,15,1271,8,15,1,15,3,15,1274,8,15,1,15,1,15,1,15,3,15,1279, + 8,15,1,15,5,15,1282,8,15,10,15,12,15,1285,9,15,1,16,1,16,1,17,1, + 17,1,17,1,17,1,17,1,17,3,17,1295,8,17,1,18,1,18,3,18,1299,8,18,1, + 18,1,18,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,1311,8,19,1, + 20,1,20,3,20,1315,8,20,1,20,3,20,1318,8,20,1,20,1,20,3,20,1322,8, + 20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,3,21,1334,8, + 21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1, + 21,1,21,1,21,1,21,3,21,1352,8,21,1,22,1,22,1,22,5,22,1357,8,22,10, + 22,12,22,1360,9,22,1,23,1,23,1,23,5,23,1365,8,23,10,23,12,23,1368, + 9,23,1,24,1,24,3,24,1372,8,24,1,25,1,25,1,25,1,25,1,25,3,25,1379, + 8,25,1,26,1,26,1,26,1,26,1,26,1,26,3,26,1387,8,26,1,27,1,27,1,27, + 1,27,3,27,1393,8,27,1,28,1,28,1,28,1,28,1,28,1,28,3,28,1401,8,28, + 1,28,1,28,1,28,1,28,1,28,1,28,3,28,1409,8,28,1,29,1,29,3,29,1413, + 8,29,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31, + 3,31,1427,8,31,1,32,1,32,1,32,3,32,1432,8,32,1,33,1,33,1,33,3,33, + 1437,8,33,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,3,34, + 1449,8,34,1,35,1,35,1,35,1,35,3,35,1455,8,35,1,35,1,35,1,36,1,36, + 1,37,1,37,1,37,1,38,1,38,1,38,3,38,1467,8,38,1,38,1,38,1,38,3,38, + 1472,8,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,3,38,1482,8,38, + 1,38,1,38,1,38,1,38,3,38,1488,8,38,1,38,1,38,1,38,3,38,1493,8,38, + 1,38,1,38,1,38,1,38,1,38,1,38,3,38,1501,8,38,1,38,1,38,1,38,3,38, + 1506,8,38,1,38,1,38,1,38,1,38,1,38,3,38,1513,8,38,1,38,1,38,1,38, + 3,38,1518,8,38,1,38,1,38,1,38,3,38,1523,8,38,1,38,1,38,1,38,1,38, + 1,38,1,38,1,38,1,38,3,38,1533,8,38,1,38,1,38,1,38,3,38,1538,8,38, + 1,38,1,38,1,38,3,38,1543,8,38,1,38,1,38,1,38,1,38,1,38,3,38,1550, + 8,38,1,38,1,38,3,38,1554,8,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38, + 1,38,1,38,1,38,1,38,1,38,3,38,1568,8,38,1,38,1,38,1,38,1,38,3,38, + 1574,8,38,1,38,1,38,1,38,1,38,3,38,1580,8,38,1,38,1,38,1,38,3,38, + 1585,8,38,1,39,1,39,1,39,5,39,1590,8,39,10,39,12,39,1593,9,39,1, + 40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,3,40,1604,8,40,1,41,1, + 41,1,41,1,41,5,41,1610,8,41,10,41,12,41,1613,9,41,1,41,1,41,1,42, + 1,42,1,42,3,42,1620,8,42,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43, + 1,44,1,44,1,44,1,44,1,44,1,44,3,44,1636,8,44,1,45,1,45,1,45,1,45, + 1,46,1,46,1,46,3,46,1645,8,46,1,46,1,46,1,46,1,46,1,46,5,46,1652, + 8,46,10,46,12,46,1655,9,46,1,46,1,46,1,46,1,46,1,46,1,46,3,46,1663, + 8,46,1,46,1,46,3,46,1667,8,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46, + 1,46,1,46,1,46,3,46,1679,8,46,1,46,1,46,1,46,1,46,1,46,1,46,3,46, + 1687,8,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,3,46,1697,8,46, + 1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46, + 1,46,1,46,1,46,1,46,1,46,3,46,1717,8,46,1,46,1,46,1,46,3,46,1722, + 8,46,1,46,3,46,1725,8,46,1,46,1,46,1,46,1,46,1,46,3,46,1732,8,46, + 1,46,3,46,1735,8,46,1,46,1,46,3,46,1739,8,46,1,46,1,46,3,46,1743, + 8,46,1,46,3,46,1746,8,46,1,46,1,46,1,46,3,46,1751,8,46,1,46,1,46, + 1,46,3,46,1756,8,46,1,46,1,46,3,46,1760,8,46,1,46,1,46,1,46,1,46, + 1,46,1,46,1,46,3,46,1769,8,46,1,46,1,46,1,46,1,46,3,46,1775,8,46, + 1,46,1,46,3,46,1779,8,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,3,46, + 1788,8,46,1,46,3,46,1791,8,46,1,46,1,46,1,46,1,46,3,46,1797,8,46, + 1,46,1,46,1,46,1,46,1,46,1,46,1,46,3,46,1806,8,46,1,46,1,46,1,46, + 1,46,1,46,1,46,1,46,1,46,4,46,1816,8,46,11,46,12,46,1817,1,46,1, + 46,3,46,1822,8,46,1,46,1,46,3,46,1826,8,46,1,46,1,46,1,46,3,46,1831, + 8,46,1,46,3,46,1834,8,46,1,46,1,46,1,46,1,46,3,46,1840,8,46,4,46, + 1842,8,46,11,46,12,46,1843,1,46,1,46,3,46,1848,8,46,1,46,1,46,1, + 46,1,46,3,46,1854,8,46,1,46,1,46,3,46,1858,8,46,1,46,1,46,1,46,3, + 46,1863,8,46,1,46,1,46,1,46,3,46,1868,8,46,1,46,1,46,3,46,1872,8, + 46,1,46,3,46,1875,8,46,1,47,1,47,1,47,1,47,1,47,3,47,1882,8,47,1, + 48,1,48,1,49,1,49,1,49,1,50,1,50,1,50,1,50,5,50,1893,8,50,10,50, + 12,50,1896,9,50,1,50,1,50,1,51,1,51,1,51,1,52,1,52,1,52,1,52,1,52, + 3,52,1908,8,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53, + 5,53,1920,8,53,10,53,12,53,1923,9,53,1,53,1,53,1,53,1,53,1,53,1, + 53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1939,8,53,1,54,1, + 54,1,54,1,54,1,54,1,54,5,54,1947,8,54,10,54,12,54,1950,9,54,1,55, + 1,55,1,55,1,55,3,55,1956,8,55,1,55,1,55,1,55,3,55,1961,8,55,1,55, + 1,55,3,55,1965,8,55,1,55,1,55,1,55,1,55,1,55,3,55,1972,8,55,1,55, + 1,55,1,55,3,55,1977,8,55,1,55,3,55,1980,8,55,3,55,1982,8,55,1,56, + 1,56,1,56,3,56,1987,8,56,1,57,1,57,3,57,1991,8,57,1,57,1,57,3,57, + 1995,8,57,1,57,1,57,3,57,1999,8,57,1,57,1,57,1,57,3,57,2004,8,57, + 1,57,3,57,2007,8,57,1,57,1,57,3,57,2011,8,57,1,57,3,57,2014,8,57, + 1,57,1,57,3,57,2018,8,57,1,57,1,57,1,57,1,57,1,57,1,57,3,57,2026, + 8,57,1,57,1,57,1,57,3,57,2031,8,57,1,57,3,57,2034,8,57,1,57,1,57, + 3,57,2038,8,57,1,58,1,58,1,58,1,58,3,58,2044,8,58,1,58,1,58,1,58, + 1,58,1,58,1,58,1,58,3,58,2053,8,58,1,58,1,58,3,58,2057,8,58,1,58, + 1,58,1,58,1,58,5,58,2063,8,58,10,58,12,58,2066,9,58,1,58,1,58,1, + 58,1,58,5,58,2072,8,58,10,58,12,58,2075,9,58,1,58,1,58,3,58,2079, + 8,58,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,5,59,2089,8,59,10,59, + 12,59,2092,9,59,1,59,1,59,3,59,2096,8,59,1,60,1,60,3,60,2100,8,60, + 1,60,1,60,3,60,2104,8,60,1,60,1,60,1,60,3,60,2109,8,60,1,60,1,60, + 3,60,2113,8,60,1,60,3,60,2116,8,60,1,60,3,60,2119,8,60,1,60,3,60, + 2122,8,60,1,60,3,60,2125,8,60,1,60,3,60,2128,8,60,1,60,1,60,1,60, + 3,60,2133,8,60,1,60,3,60,2136,8,60,1,60,3,60,2139,8,60,1,60,3,60, + 2142,8,60,1,60,3,60,2145,8,60,1,60,3,60,2148,8,60,1,60,1,60,1,60, + 1,60,3,60,2154,8,60,1,60,1,60,3,60,2158,8,60,1,60,3,60,2161,8,60, + 1,60,3,60,2164,8,60,1,60,3,60,2167,8,60,1,60,3,60,2170,8,60,3,60, + 2172,8,60,1,61,1,61,1,61,1,61,1,61,3,61,2179,8,61,1,62,1,62,1,62, + 1,62,5,62,2185,8,62,10,62,12,62,2188,9,62,1,62,1,62,1,63,1,63,1, + 63,5,63,2195,8,63,10,63,12,63,2198,9,63,1,64,1,64,1,64,1,64,1,64, + 5,64,2205,8,64,10,64,12,64,2208,9,64,1,64,1,64,3,64,2212,8,64,1, + 64,3,64,2215,8,64,1,65,1,65,1,65,3,65,2220,8,65,1,65,5,65,2223,8, + 65,10,65,12,65,2226,9,65,1,65,1,65,3,65,2230,8,65,1,65,3,65,2233, + 8,65,1,66,1,66,1,66,3,66,2238,8,66,1,66,1,66,1,66,1,66,1,66,1,66, + 1,66,3,66,2247,8,66,3,66,2249,8,66,1,66,1,66,3,66,2253,8,66,1,66, + 3,66,2256,8,66,1,66,1,66,3,66,2260,8,66,1,66,5,66,2263,8,66,10,66, + 12,66,2266,9,66,1,67,1,67,3,67,2270,8,67,1,67,1,67,3,67,2274,8,67, + 1,67,3,67,2277,8,67,1,67,1,67,3,67,2281,8,67,1,68,3,68,2284,8,68, + 1,68,1,68,1,68,3,68,2289,8,68,1,68,3,68,2292,8,68,1,68,1,68,1,68, + 3,68,2297,8,68,1,68,3,68,2300,8,68,1,68,1,68,3,68,2304,8,68,1,68, + 3,68,2307,8,68,1,68,3,68,2310,8,68,1,68,1,68,1,68,3,68,2315,8,68, + 1,68,3,68,2318,8,68,1,68,1,68,1,68,1,68,1,68,1,68,3,68,2326,8,68, + 1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,68,4,68,2336,8,68,11,68,12, + 68,2337,1,68,1,68,3,68,2342,8,68,1,68,1,68,1,68,1,68,1,68,3,68,2349, + 8,68,1,68,1,68,1,68,3,68,2354,8,68,1,68,3,68,2357,8,68,1,68,3,68, + 2360,8,68,1,68,3,68,2363,8,68,1,69,1,69,1,69,3,69,2368,8,69,1,70, + 1,70,1,71,1,71,1,71,1,71,1,71,5,71,2377,8,71,10,71,12,71,2380,9, + 71,1,71,1,71,1,71,3,71,2385,8,71,1,71,1,71,3,71,2389,8,71,1,71,3, + 71,2392,8,71,1,71,3,71,2395,8,71,1,71,5,71,2398,8,71,10,71,12,71, + 2401,9,71,1,71,1,71,5,71,2405,8,71,10,71,12,71,2408,9,71,3,71,2410, + 8,71,1,71,1,71,3,71,2414,8,71,1,71,1,71,1,71,1,71,5,71,2420,8,71, + 10,71,12,71,2423,9,71,1,71,1,71,3,71,2427,8,71,1,71,3,71,2430,8, + 71,1,71,3,71,2433,8,71,1,71,1,71,1,71,1,71,1,71,3,71,2440,8,71,1, + 71,5,71,2443,8,71,10,71,12,71,2446,9,71,1,71,1,71,1,71,1,71,1,71, + 1,71,3,71,2454,8,71,1,71,3,71,2457,8,71,1,71,3,71,2460,8,71,1,71, + 5,71,2463,8,71,10,71,12,71,2466,9,71,3,71,2468,8,71,1,72,1,72,1, + 72,1,72,1,73,1,73,1,73,1,73,5,73,2478,8,73,10,73,12,73,2481,9,73, + 1,73,1,73,1,74,1,74,1,74,5,74,2488,8,74,10,74,12,74,2491,9,74,1, + 75,1,75,1,75,1,76,1,76,1,76,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1, + 77,3,77,2507,8,77,1,78,1,78,3,78,2511,8,78,1,78,1,78,3,78,2515,8, + 78,3,78,2517,8,78,1,79,1,79,1,79,1,79,1,80,1,80,1,80,1,80,1,81,1, + 81,1,81,1,81,1,81,1,81,1,81,3,81,2534,8,81,3,81,2536,8,81,1,82,1, + 82,1,82,1,82,1,82,1,83,1,83,1,83,1,83,1,83,1,83,1,83,5,83,2550,8, + 83,10,83,12,83,2553,9,83,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84, + 3,84,2563,8,84,1,84,3,84,2566,8,84,1,84,3,84,2569,8,84,1,85,1,85, + 1,85,1,86,1,86,1,86,1,86,3,86,2578,8,86,1,87,1,87,1,87,1,87,1,87, + 1,87,1,87,3,87,2587,8,87,1,88,1,88,1,88,1,89,1,89,1,89,1,89,1,90, + 1,90,1,90,1,90,1,91,1,91,1,91,3,91,2603,8,91,1,91,3,91,2606,8,91, + 1,91,3,91,2609,8,91,1,91,1,91,1,91,1,91,5,91,2615,8,91,10,91,12, + 91,2618,9,91,1,91,3,91,2621,8,91,1,91,1,91,1,92,1,92,1,92,3,92,2628, + 8,92,1,92,1,92,1,92,1,92,1,92,1,93,1,93,3,93,2637,8,93,1,93,1,93, + 3,93,2641,8,93,1,93,1,93,1,93,1,93,3,93,2647,8,93,1,94,1,94,3,94, + 2651,8,94,1,94,3,94,2654,8,94,1,94,3,94,2657,8,94,1,94,3,94,2660, + 8,94,1,94,3,94,2663,8,94,1,95,1,95,1,95,1,95,3,95,2669,8,95,1,96, + 1,96,3,96,2673,8,96,1,96,1,96,1,96,3,96,2678,8,96,1,96,1,96,3,96, + 2682,8,96,1,96,3,96,2685,8,96,1,96,3,96,2688,8,96,1,96,3,96,2691, + 8,96,1,96,1,96,1,96,3,96,2696,8,96,1,97,1,97,1,97,1,97,3,97,2702, + 8,97,1,97,1,97,3,97,2706,8,97,1,98,1,98,3,98,2710,8,98,1,98,1,98, + 3,98,2714,8,98,1,98,1,98,4,98,2718,8,98,11,98,12,98,2719,3,98,2722, + 8,98,1,99,1,99,1,99,3,99,2727,8,99,1,99,1,99,4,99,2731,8,99,11,99, + 12,99,2732,1,100,1,100,1,100,1,100,3,100,2739,8,100,1,100,1,100, + 3,100,2743,8,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,1,100,1,100,3,100,2758,8,100,1,100,1,100,1,100, + 3,100,2763,8,100,1,100,3,100,2766,8,100,3,100,2768,8,100,1,101,3, + 101,2771,8,101,1,101,1,101,3,101,2775,8,101,1,102,1,102,3,102,2779, + 8,102,1,102,3,102,2782,8,102,1,102,3,102,2785,8,102,1,102,1,102, + 1,102,1,102,1,102,1,102,3,102,2793,8,102,1,102,1,102,1,102,1,102, + 3,102,2799,8,102,3,102,2801,8,102,1,103,1,103,1,103,1,103,3,103, + 2807,8,103,1,103,1,103,1,103,3,103,2812,8,103,1,104,1,104,1,104, + 3,104,2817,8,104,1,104,1,104,3,104,2821,8,104,1,104,1,104,1,104, + 1,104,1,104,5,104,2828,8,104,10,104,12,104,2831,9,104,1,105,1,105, + 1,105,1,105,1,105,1,105,5,105,2839,8,105,10,105,12,105,2842,9,105, + 1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106, + 1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106, + 1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106, + 1,106,1,106,1,106,3,106,2880,8,106,1,107,1,107,1,107,1,107,1,107, + 1,107,4,107,2888,8,107,11,107,12,107,2889,3,107,2892,8,107,1,107, + 3,107,2895,8,107,1,108,1,108,3,108,2899,8,108,1,108,1,108,3,108, + 2903,8,108,1,109,1,109,1,109,1,109,1,109,1,109,4,109,2911,8,109, + 11,109,12,109,2912,3,109,2915,8,109,1,109,1,109,4,109,2919,8,109, + 11,109,12,109,2920,3,109,2923,8,109,1,110,1,110,1,110,1,110,1,110, + 5,110,2930,8,110,10,110,12,110,2933,9,110,1,110,1,110,1,111,1,111, + 1,111,1,111,1,111,5,111,2942,8,111,10,111,12,111,2945,9,111,1,111, + 1,111,1,112,1,112,1,112,1,113,1,113,1,113,1,114,1,114,1,114,3,114, + 2958,8,114,1,114,1,114,1,114,3,114,2963,8,114,1,114,3,114,2966,8, + 114,1,114,1,114,1,114,1,114,1,114,3,114,2973,8,114,1,115,1,115,1, + 115,3,115,2978,8,115,1,116,1,116,1,116,1,116,1,116,1,116,3,116,2986, + 8,116,3,116,2988,8,116,1,117,1,117,1,117,1,117,3,117,2994,8,117, + 1,117,1,117,1,117,3,117,2999,8,117,1,117,1,117,3,117,3003,8,117, + 1,117,1,117,1,117,3,117,3008,8,117,1,117,1,117,1,117,1,117,3,117, + 3014,8,117,1,117,1,117,1,117,1,117,1,117,3,117,3021,8,117,1,117, + 1,117,1,117,1,117,3,117,3027,8,117,3,117,3029,8,117,1,118,1,118, + 1,118,1,118,1,118,1,118,1,118,3,118,3038,8,118,1,118,1,118,1,118, + 1,118,3,118,3044,8,118,1,118,1,118,1,118,1,118,1,118,1,118,3,118, + 3052,8,118,1,119,1,119,1,119,1,119,3,119,3058,8,119,1,119,1,119, + 1,119,3,119,3063,8,119,1,119,1,119,1,119,3,119,3068,8,119,1,120, + 1,120,1,120,1,120,1,120,1,120,3,120,3076,8,120,1,120,1,120,1,120, + 1,120,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,3,121, + 3091,8,121,3,121,3093,8,121,1,121,1,121,3,121,3097,8,121,1,121,1, + 121,3,121,3101,8,121,1,121,3,121,3104,8,121,1,121,3,121,3107,8,121, + 1,122,1,122,1,122,1,122,1,122,1,122,1,122,3,122,3116,8,122,1,122, + 3,122,3119,8,122,1,122,3,122,3122,8,122,1,123,1,123,1,123,1,123, + 3,123,3128,8,123,1,123,1,123,5,123,3132,8,123,10,123,12,123,3135, + 9,123,1,123,3,123,3138,8,123,1,123,1,123,1,123,1,123,1,123,1,123, + 1,123,1,123,1,123,1,123,3,123,3150,8,123,1,123,1,123,1,123,1,123, + 3,123,3156,8,123,1,124,3,124,3159,8,124,1,124,1,124,1,124,3,124, + 3164,8,124,1,124,1,124,3,124,3168,8,124,1,124,1,124,1,124,1,124, + 1,124,3,124,3175,8,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, + 1,124,3,124,3185,8,124,3,124,3187,8,124,1,125,1,125,1,125,1,125, + 1,125,1,126,1,126,1,126,1,126,1,126,1,126,1,127,1,127,1,127,1,127, + 1,127,1,127,1,127,1,127,1,127,1,128,1,128,3,128,3211,8,128,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,3,128,3223, + 8,128,1,128,4,128,3226,8,128,11,128,12,128,3227,3,128,3230,8,128, + 1,128,1,128,3,128,3234,8,128,1,128,3,128,3237,8,128,1,128,3,128, + 3240,8,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,3,128, + 3250,8,128,1,128,3,128,3253,8,128,1,128,1,128,1,128,1,128,1,128, + 1,128,1,128,1,128,3,128,3263,8,128,1,128,5,128,3266,8,128,10,128, + 12,128,3269,9,128,1,128,1,128,3,128,3273,8,128,1,128,3,128,3276, + 8,128,1,128,3,128,3279,8,128,1,128,1,128,1,128,1,128,1,128,1,128, + 3,128,3287,8,128,1,129,1,129,1,129,1,129,3,129,3293,8,129,1,130, + 1,130,1,130,5,130,3298,8,130,10,130,12,130,3301,9,130,1,131,1,131, + 1,131,1,131,1,131,3,131,3308,8,131,1,131,3,131,3311,8,131,1,132, + 1,132,1,132,1,132,1,132,1,133,1,133,1,133,1,133,3,133,3322,8,133, + 1,134,1,134,3,134,3326,8,134,1,134,1,134,5,134,3330,8,134,10,134, + 12,134,3333,9,134,1,135,1,135,1,135,1,135,3,135,3339,8,135,1,136, + 3,136,3342,8,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,3,136, + 3351,8,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137, + 1,137,5,137,3363,8,137,10,137,12,137,3366,9,137,3,137,3368,8,137, + 1,137,1,137,1,137,1,137,1,137,1,138,1,138,1,138,1,138,1,138,5,138, + 3380,8,138,10,138,12,138,3383,9,138,1,138,1,138,1,139,1,139,1,139, + 1,139,1,139,1,139,3,139,3393,8,139,1,139,3,139,3396,8,139,1,140, + 1,140,1,140,1,140,1,140,1,140,1,140,1,140,5,140,3406,8,140,10,140, + 12,140,3409,9,140,1,141,1,141,3,141,3413,8,141,1,141,1,141,1,141, + 1,141,1,141,1,141,1,141,1,141,1,141,5,141,3424,8,141,10,141,12,141, + 3427,9,141,1,141,1,141,3,141,3431,8,141,1,141,1,141,1,141,1,141, + 1,141,1,141,1,141,1,141,1,141,1,141,1,141,3,141,3444,8,141,1,141, + 1,141,1,141,1,141,1,141,5,141,3451,8,141,10,141,12,141,3454,9,141, + 3,141,3456,8,141,1,141,3,141,3459,8,141,1,141,1,141,1,141,1,141, + 1,141,3,141,3466,8,141,1,141,3,141,3469,8,141,1,141,1,141,1,141, + 1,141,1,141,1,141,1,141,1,141,1,141,1,141,3,141,3481,8,141,1,141, + 1,141,1,141,1,141,3,141,3487,8,141,3,141,3489,8,141,1,142,1,142, + 1,142,1,142,5,142,3495,8,142,10,142,12,142,3498,9,142,1,142,1,142, + 1,143,1,143,1,143,3,143,3505,8,143,1,144,1,144,1,144,1,144,1,144, + 1,144,3,144,3513,8,144,1,145,1,145,1,145,1,145,1,146,1,146,1,146, + 1,146,1,146,1,146,3,146,3525,8,146,1,146,1,146,1,146,3,146,3530, + 8,146,1,146,1,146,1,146,1,146,1,146,1,146,1,146,1,146,1,146,3,146, + 3541,8,146,1,147,1,147,1,147,1,147,1,148,1,148,1,148,1,148,1,148, + 3,148,3552,8,148,1,148,1,148,1,148,1,148,1,148,1,148,3,148,3560, + 8,148,1,148,1,148,1,148,1,148,5,148,3566,8,148,10,148,12,148,3569, + 9,148,1,149,1,149,1,149,1,149,3,149,3575,8,149,1,149,1,149,1,149, + 1,149,1,149,3,149,3582,8,149,3,149,3584,8,149,1,149,3,149,3587,8, + 149,1,149,1,149,1,149,3,149,3592,8,149,1,149,1,149,1,149,3,149,3597, + 8,149,1,150,1,150,1,150,1,150,1,150,1,150,1,151,1,151,1,151,1,151, + 1,151,1,151,1,151,1,151,1,151,5,151,3614,8,151,10,151,12,151,3617, + 9,151,1,151,1,151,1,151,1,151,5,151,3623,8,151,10,151,12,151,3626, + 9,151,3,151,3628,8,151,1,152,1,152,1,152,1,152,1,153,1,153,1,153, + 1,153,1,153,1,153,1,153,1,154,1,154,1,154,1,154,1,154,1,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,1,154,3,154,3655,8,154,1,154, + 1,154,1,154,1,154,1,154,1,154,1,154,3,154,3664,8,154,1,154,3,154, + 3667,8,154,1,154,1,154,3,154,3671,8,154,1,154,1,154,3,154,3675,8, + 154,1,154,1,154,3,154,3679,8,154,1,154,1,154,1,154,5,154,3684,8, + 154,10,154,12,154,3687,9,154,1,154,3,154,3690,8,154,1,154,1,154, + 3,154,3694,8,154,1,154,1,154,3,154,3698,8,154,1,154,1,154,3,154, + 3702,8,154,1,154,1,154,1,154,3,154,3707,8,154,1,154,1,154,3,154, + 3711,8,154,1,154,1,154,1,154,3,154,3716,8,154,1,154,1,154,1,154, + 1,154,3,154,3722,8,154,1,154,1,154,1,154,3,154,3727,8,154,1,154, + 1,154,1,154,5,154,3732,8,154,10,154,12,154,3735,9,154,1,154,3,154, + 3738,8,154,1,154,1,154,1,154,1,154,3,154,3744,8,154,1,154,1,154, + 3,154,3748,8,154,1,154,1,154,1,154,3,154,3753,8,154,1,154,1,154, + 1,154,1,154,1,154,1,154,3,154,3761,8,154,1,154,1,154,1,154,1,154, + 3,154,3767,8,154,1,154,1,154,1,154,3,154,3772,8,154,1,154,1,154, + 1,154,1,154,1,154,3,154,3779,8,154,1,154,1,154,1,154,3,154,3784, + 8,154,1,154,1,154,3,154,3788,8,154,1,154,1,154,1,154,3,154,3793, + 8,154,1,154,1,154,1,154,1,154,3,154,3799,8,154,1,154,1,154,1,154, + 1,154,1,154,3,154,3806,8,154,1,154,1,154,1,154,3,154,3811,8,154, + 1,154,1,154,1,154,1,154,1,154,3,154,3818,8,154,1,154,1,154,1,154, + 3,154,3823,8,154,1,154,1,154,1,154,1,154,1,154,3,154,3830,8,154, + 1,154,1,154,3,154,3834,8,154,1,154,1,154,1,154,1,154,5,154,3840, + 8,154,10,154,12,154,3843,9,154,1,154,3,154,3846,8,154,3,154,3848, + 8,154,1,155,3,155,3851,8,155,1,155,1,155,1,155,3,155,3856,8,155, + 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,3,155,3866,8,155, + 1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156, + 1,156,1,156,3,156,3881,8,156,1,156,3,156,3884,8,156,1,156,1,156, + 1,156,1,156,1,156,1,156,3,156,3892,8,156,1,157,1,157,1,157,5,157, + 3897,8,157,10,157,12,157,3900,9,157,1,158,1,158,3,158,3904,8,158, + 1,159,1,159,4,159,3908,8,159,11,159,12,159,3909,1,160,1,160,3,160, + 3914,8,160,1,160,1,160,1,160,5,160,3919,8,160,10,160,12,160,3922, + 9,160,1,160,1,160,3,160,3926,8,160,1,160,3,160,3929,8,160,1,161, + 3,161,3932,8,161,1,161,1,161,3,161,3936,8,161,1,162,1,162,1,162, + 1,162,1,162,1,162,1,162,3,162,3945,8,162,1,162,1,162,1,162,1,162, + 1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162, + 1,162,3,162,3963,8,162,1,162,3,162,3966,8,162,1,162,1,162,1,162, + 1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162, + 1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162,1,162, + 1,162,1,162,1,162,1,162,1,162,3,162,3998,8,162,1,162,1,162,1,162, + 3,162,4003,8,162,1,163,1,163,1,163,1,163,3,163,4009,8,163,1,163, + 1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163,1,163, + 1,163,1,163,1,163,1,163,1,163,1,163,3,163,4029,8,163,1,163,1,163, + 1,163,3,163,4034,8,163,1,164,1,164,1,164,1,165,3,165,4040,8,165, + 1,165,3,165,4043,8,165,1,165,1,165,3,165,4047,8,165,1,165,1,165, + 3,165,4051,8,165,1,165,1,165,1,165,1,165,3,165,4057,8,165,1,165, + 3,165,4060,8,165,1,165,1,165,3,165,4064,8,165,1,165,1,165,3,165, + 4068,8,165,1,165,1,165,1,165,3,165,4073,8,165,1,165,3,165,4076,8, + 165,1,165,3,165,4079,8,165,1,165,3,165,4082,8,165,1,166,1,166,1, + 167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,1,167,3,167,4095,8, + 167,1,168,1,168,1,168,1,168,3,168,4101,8,168,1,168,1,168,1,168,1, + 168,1,168,1,168,3,168,4109,8,168,1,169,1,169,1,169,5,169,4114,8, + 169,10,169,12,169,4117,9,169,1,169,1,169,3,169,4121,8,169,1,169, + 3,169,4124,8,169,1,169,1,169,1,169,5,169,4129,8,169,10,169,12,169, + 4132,9,169,3,169,4134,8,169,1,170,1,170,1,171,1,171,1,171,1,171, + 3,171,4142,8,171,1,171,3,171,4145,8,171,1,172,1,172,1,172,3,172, + 4150,8,172,1,172,1,172,1,172,1,172,1,172,3,172,4157,8,172,1,172, + 3,172,4160,8,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172, + 1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,5,172,4178,8,172, + 10,172,12,172,4181,9,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172, + 1,172,1,172,3,172,4192,8,172,1,173,3,173,4195,8,173,1,173,1,173, + 1,173,1,173,3,173,4201,8,173,1,173,5,173,4204,8,173,10,173,12,173, + 4207,9,173,1,174,1,174,1,174,1,174,5,174,4213,8,174,10,174,12,174, + 4216,9,174,1,174,1,174,1,174,1,174,1,174,3,174,4223,8,174,1,174, + 1,174,1,174,3,174,4228,8,174,1,175,1,175,1,175,1,175,3,175,4234, + 8,175,1,175,1,175,1,175,5,175,4239,8,175,10,175,12,175,4242,9,175, + 1,175,1,175,1,175,1,175,1,175,3,175,4249,8,175,1,175,3,175,4252, + 8,175,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,5,176, + 4263,8,176,10,176,12,176,4266,9,176,1,176,1,176,1,177,1,177,1,177, + 1,177,1,177,1,177,1,177,1,177,1,177,3,177,4279,8,177,1,177,1,177, + 1,177,1,177,3,177,4285,8,177,1,177,1,177,1,177,1,177,1,177,1,177, + 3,177,4293,8,177,3,177,4295,8,177,1,178,1,178,1,179,1,179,3,179, + 4301,8,179,1,179,1,179,3,179,4305,8,179,1,179,3,179,4308,8,179,1, + 179,3,179,4311,8,179,1,179,1,179,1,179,3,179,4316,8,179,1,179,1, + 179,1,179,3,179,4321,8,179,1,179,1,179,3,179,4325,8,179,1,179,3, + 179,4328,8,179,1,179,3,179,4331,8,179,1,179,3,179,4334,8,179,1,179, + 3,179,4337,8,179,1,180,1,180,1,180,1,180,5,180,4343,8,180,10,180, + 12,180,4346,9,180,1,180,1,180,1,181,1,181,1,181,1,181,1,181,1,181, + 3,181,4356,8,181,1,181,3,181,4359,8,181,1,181,3,181,4362,8,181,1, + 181,1,181,1,181,3,181,4367,8,181,1,181,3,181,4370,8,181,1,181,1, + 181,3,181,4374,8,181,1,182,1,182,3,182,4378,8,182,1,182,1,182,1, + 182,1,182,3,182,4384,8,182,1,182,1,182,1,182,1,182,5,182,4390,8, + 182,10,182,12,182,4393,9,182,3,182,4395,8,182,1,182,1,182,1,182, + 1,182,1,182,1,182,1,182,1,182,1,182,5,182,4406,8,182,10,182,12,182, + 4409,9,182,1,182,1,182,3,182,4413,8,182,3,182,4415,8,182,1,182,4, + 182,4418,8,182,11,182,12,182,4419,1,182,1,182,1,182,1,182,1,182, + 3,182,4427,8,182,1,183,1,183,1,183,1,184,1,184,3,184,4434,8,184, + 1,184,1,184,1,185,1,185,1,185,5,185,4441,8,185,10,185,12,185,4444, + 9,185,1,186,1,186,1,186,5,186,4449,8,186,10,186,12,186,4452,9,186, + 1,187,1,187,1,187,1,187,1,187,3,187,4459,8,187,1,188,1,188,1,188, + 5,188,4464,8,188,10,188,12,188,4467,9,188,1,189,1,189,1,189,1,189, + 1,189,3,189,4474,8,189,1,190,1,190,1,190,5,190,4479,8,190,10,190, + 12,190,4482,9,190,1,191,1,191,1,191,1,191,1,191,3,191,4489,8,191, + 1,192,1,192,3,192,4493,8,192,1,192,1,192,3,192,4497,8,192,3,192, + 4499,8,192,1,192,1,192,1,193,1,193,3,193,4505,8,193,1,193,1,193, + 1,193,3,193,4510,8,193,1,194,1,194,3,194,4514,8,194,1,194,1,194, + 1,194,1,194,1,194,3,194,4521,8,194,1,195,1,195,1,195,3,195,4526, + 8,195,1,196,1,196,1,196,3,196,4531,8,196,1,196,1,196,1,196,3,196, + 4536,8,196,3,196,4538,8,196,1,196,1,196,1,197,1,197,1,197,1,198, + 1,198,1,198,3,198,4548,8,198,1,198,1,198,1,198,1,198,1,198,1,198, + 1,198,1,198,3,198,4558,8,198,1,198,1,198,1,198,1,198,1,198,1,198, + 1,198,1,198,1,198,1,198,1,198,1,198,1,198,1,198,3,198,4574,8,198, + 1,199,1,199,1,199,1,199,1,199,1,199,1,199,1,199,1,199,1,199,1,199, + 1,199,1,199,1,199,5,199,4590,8,199,10,199,12,199,4593,9,199,1,199, + 1,199,1,199,1,199,1,199,1,199,1,199,1,199,1,199,3,199,4604,8,199, + 1,199,1,199,1,199,1,199,1,199,3,199,4611,8,199,1,200,1,200,1,200, + 1,201,1,201,1,201,1,202,1,202,1,202,1,202,1,202,1,202,1,202,3,202, + 4626,8,202,1,202,4,202,4629,8,202,11,202,12,202,4630,1,202,3,202, + 4634,8,202,1,203,1,203,1,203,3,203,4639,8,203,1,203,1,203,1,203, + 3,203,4644,8,203,1,203,1,203,1,203,3,203,4649,8,203,1,203,3,203, + 4652,8,203,1,203,3,203,4655,8,203,1,204,1,204,1,204,3,204,4660,8, + 204,1,204,1,204,1,204,5,204,4665,8,204,10,204,12,204,4668,9,204, + 1,204,3,204,4671,8,204,1,205,1,205,1,205,3,205,4676,8,205,1,205, + 1,205,1,205,5,205,4681,8,205,10,205,12,205,4684,9,205,1,205,3,205, + 4687,8,205,1,206,1,206,1,206,1,206,3,206,4693,8,206,1,206,1,206, + 1,206,1,206,1,206,1,206,1,206,3,206,4702,8,206,1,206,1,206,1,207, + 1,207,1,207,5,207,4709,8,207,10,207,12,207,4712,9,207,1,207,1,207, + 1,208,1,208,1,208,1,209,1,209,1,209,1,209,4,209,4723,8,209,11,209, + 12,209,4724,1,210,1,210,1,210,1,210,1,210,1,210,1,210,1,210,1,210, + 1,210,1,210,3,210,4738,8,210,1,210,1,210,1,210,1,210,3,210,4744, + 8,210,1,210,1,210,3,210,4748,8,210,3,210,4750,8,210,1,211,1,211, + 1,211,1,212,1,212,3,212,4757,8,212,1,212,1,212,1,212,1,212,1,212, + 1,212,1,212,1,212,1,212,1,212,1,212,3,212,4770,8,212,1,212,1,212, + 1,212,1,212,1,212,3,212,4777,8,212,3,212,4779,8,212,1,212,1,212, + 1,213,1,213,1,213,1,213,1,213,1,214,1,214,1,214,1,214,1,214,5,214, + 4793,8,214,10,214,12,214,4796,9,214,1,214,3,214,4799,8,214,1,214, + 1,214,3,214,4803,8,214,1,214,1,214,1,214,3,214,4808,8,214,1,214, + 1,214,1,214,3,214,4813,8,214,1,214,1,214,1,214,3,214,4818,8,214, + 1,214,1,214,1,214,3,214,4823,8,214,1,214,3,214,4826,8,214,1,215, + 1,215,1,215,1,215,1,215,1,216,1,216,1,216,1,216,1,216,3,216,4838, + 8,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216, + 1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216, + 1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216, + 1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216, + 1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,3,216,4891,8,216, + 1,216,1,216,1,216,1,216,1,216,1,216,1,216,3,216,4900,8,216,1,216, + 1,216,3,216,4904,8,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216, + 3,216,4913,8,216,1,216,1,216,3,216,4917,8,216,1,216,1,216,1,216, + 1,216,1,216,1,216,1,216,3,216,4926,8,216,1,216,1,216,3,216,4930, + 8,216,1,216,1,216,1,216,3,216,4935,8,216,1,216,3,216,4938,8,216, + 1,216,1,216,3,216,4942,8,216,1,216,1,216,1,216,3,216,4947,8,216, + 3,216,4949,8,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,3,216, + 4958,8,216,1,216,1,216,1,216,3,216,4963,8,216,1,216,1,216,1,216, + 1,216,1,216,1,216,1,216,1,216,1,216,3,216,4974,8,216,1,216,1,216, + 3,216,4978,8,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216, + 1,216,1,216,1,216,1,216,3,216,4992,8,216,1,216,1,216,1,216,1,216, + 1,216,1,216,3,216,5000,8,216,1,216,1,216,1,216,1,216,1,216,1,216, + 1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216, + 1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216, + 1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,3,216,5038,8,216, + 3,216,5040,8,216,1,217,1,217,1,217,1,217,1,217,1,217,1,217,1,217, + 1,217,1,217,1,217,1,217,1,217,1,217,1,217,1,217,1,217,3,217,5059, + 8,217,1,217,3,217,5062,8,217,1,217,1,217,1,217,1,217,1,217,1,218, + 1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218, + 1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,3,218,5089,8,218, + 1,218,1,218,3,218,5093,8,218,1,218,1,218,3,218,5097,8,218,1,218, + 1,218,3,218,5101,8,218,1,218,1,218,3,218,5105,8,218,1,218,3,218, + 5108,8,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218, + 1,218,1,218,1,218,1,218,3,218,5123,8,218,1,218,1,218,1,218,1,218, + 1,218,3,218,5130,8,218,1,219,1,219,1,219,1,219,1,219,1,219,1,220, + 1,220,1,220,1,220,5,220,5142,8,220,10,220,12,220,5145,9,220,1,220, + 1,220,1,221,1,221,1,221,1,221,1,221,1,221,1,221,1,221,3,221,5157, + 8,221,1,222,1,222,1,222,1,222,1,222,1,222,1,223,1,223,1,223,1,223, + 1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223, + 1,223,1,223,3,223,5182,8,223,1,223,1,223,1,223,1,223,1,223,1,223, + 1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223, + 3,223,5201,8,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223, + 1,223,1,223,1,223,1,223,1,223,3,223,5216,8,223,1,223,1,223,1,223, + 1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223,1,223, + 3,223,5232,8,223,1,223,1,223,1,223,1,223,1,223,3,223,5239,8,223, + 1,224,1,224,1,224,1,224,1,224,1,224,1,224,1,224,1,224,3,224,5250, + 8,224,1,224,3,224,5253,8,224,1,225,1,225,1,225,1,225,1,225,1,225, + 1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,225,1,225,5,225,5270, + 8,225,10,225,12,225,5273,9,225,3,225,5275,8,225,1,226,1,226,1,226, + 1,226,1,226,1,226,1,226,1,226,1,226,5,226,5286,8,226,10,226,12,226, + 5289,9,226,1,226,3,226,5292,8,226,1,227,1,227,1,227,1,227,1,227, + 1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227, + 1,227,1,227,3,227,5312,8,227,1,227,1,227,1,227,1,227,1,227,1,227, + 1,227,1,227,5,227,5322,8,227,10,227,12,227,5325,9,227,1,227,3,227, + 5328,8,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227, + 1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227, + 3,227,5350,8,227,1,228,1,228,3,228,5354,8,228,1,228,1,228,1,228, + 1,228,1,228,1,228,1,228,1,228,3,228,5364,8,228,1,228,1,228,3,228, + 5368,8,228,1,228,1,228,1,228,1,228,3,228,5374,8,228,1,228,1,228, + 3,228,5378,8,228,5,228,5380,8,228,10,228,12,228,5383,9,228,1,228, + 3,228,5386,8,228,1,229,1,229,1,229,1,229,1,229,3,229,5393,8,229, + 1,230,1,230,1,230,3,230,5398,8,230,1,231,1,231,1,231,1,232,1,232, + 1,232,1,233,1,233,1,233,3,233,5409,8,233,1,234,1,234,3,234,5413, + 8,234,1,234,3,234,5416,8,234,1,234,1,234,1,234,3,234,5421,8,234, + 1,234,1,234,1,234,1,234,3,234,5427,8,234,1,234,1,234,1,234,1,234, + 1,234,1,234,1,234,1,234,1,234,3,234,5438,8,234,1,234,1,234,3,234, + 5442,8,234,1,234,3,234,5445,8,234,1,234,1,234,3,234,5449,8,234,1, + 234,1,234,3,234,5453,8,234,1,234,3,234,5456,8,234,1,235,1,235,1, + 236,1,236,1,236,1,236,1,236,1,236,3,236,5466,8,236,1,236,3,236,5469, + 8,236,1,237,1,237,3,237,5473,8,237,1,237,5,237,5476,8,237,10,237, + 12,237,5479,9,237,1,238,1,238,1,238,3,238,5484,8,238,1,238,3,238, + 5487,8,238,1,238,1,238,1,238,3,238,5492,8,238,1,238,3,238,5495,8, + 238,1,238,1,238,1,238,1,238,1,238,3,238,5502,8,238,3,238,5504,8, + 238,1,238,1,238,1,238,1,238,3,238,5510,8,238,1,238,1,238,3,238,5514, + 8,238,1,239,1,239,1,239,1,240,1,240,1,240,1,240,3,240,5523,8,240, + 1,240,4,240,5526,8,240,11,240,12,240,5527,3,240,5530,8,240,1,241, + 1,241,1,241,1,241,1,241,1,241,1,241,1,241,3,241,5540,8,241,1,241, + 3,241,5543,8,241,1,241,1,241,1,241,3,241,5548,8,241,1,242,1,242, + 1,242,1,242,1,242,1,242,3,242,5556,8,242,1,242,3,242,5559,8,242, + 1,242,4,242,5562,8,242,11,242,12,242,5563,3,242,5566,8,242,3,242, + 5568,8,242,1,243,1,243,1,243,1,243,3,243,5574,8,243,1,244,1,244, + 1,244,1,244,1,244,1,244,1,245,1,245,1,245,1,245,1,245,1,246,1,246, + 1,246,1,246,3,246,5591,8,246,1,246,1,246,5,246,5595,8,246,10,246, + 12,246,5598,9,246,1,247,1,247,1,247,1,247,1,247,1,247,1,247,1,247, + 1,247,1,247,3,247,5610,8,247,1,247,1,247,1,247,1,247,3,247,5616, + 8,247,1,247,1,247,3,247,5620,8,247,1,247,1,247,1,247,3,247,5625, + 8,247,1,248,1,248,1,248,1,248,1,248,1,248,1,248,1,249,1,249,1,249, + 1,249,1,249,1,249,1,249,1,249,1,249,1,249,1,249,1,249,1,249,1,249, + 1,249,1,249,1,249,1,249,1,249,1,249,1,249,3,249,5655,8,249,1,249, + 1,249,1,249,1,249,1,249,1,249,1,249,1,249,1,249,1,249,1,249,1,249, + 1,249,3,249,5670,8,249,1,249,1,249,1,249,3,249,5675,8,249,1,250, + 1,250,3,250,5679,8,250,1,250,1,250,1,250,1,250,1,250,1,250,1,250, + 1,250,1,250,1,251,1,251,3,251,5692,8,251,1,251,1,251,3,251,5696, + 8,251,3,251,5698,8,251,1,251,1,251,1,251,1,251,1,251,5,251,5705, + 8,251,10,251,12,251,5708,9,251,1,251,1,251,1,251,3,251,5713,8,251, + 3,251,5715,8,251,1,252,1,252,3,252,5719,8,252,1,252,3,252,5722,8, + 252,1,252,3,252,5725,8,252,1,252,3,252,5728,8,252,1,252,3,252,5731, + 8,252,3,252,5733,8,252,1,252,3,252,5736,8,252,1,253,1,253,3,253, + 5740,8,253,1,253,1,253,1,253,1,253,5,253,5746,8,253,10,253,12,253, + 5749,9,253,1,253,1,253,3,253,5753,8,253,1,253,3,253,5756,8,253,1, + 254,1,254,1,255,1,255,3,255,5762,8,255,1,255,1,255,3,255,5766,8, + 255,1,256,1,256,3,256,5770,8,256,1,256,1,256,1,256,3,256,5775,8, + 256,3,256,5777,8,256,1,257,1,257,3,257,5781,8,257,1,258,1,258,3, + 258,5785,8,258,1,259,1,259,1,259,5,259,5790,8,259,10,259,12,259, + 5793,9,259,1,260,1,260,1,260,3,260,5798,8,260,1,260,1,260,3,260, + 5802,8,260,3,260,5804,8,260,3,260,5806,8,260,1,260,1,260,1,261,1, + 261,1,261,1,261,1,261,1,261,1,261,1,261,1,261,3,261,5819,8,261,1, + 262,1,262,1,262,1,262,5,262,5825,8,262,10,262,12,262,5828,9,262, + 1,262,1,262,1,263,1,263,1,263,3,263,5835,8,263,1,263,1,263,1,263, + 1,264,1,264,1,264,1,264,5,264,5844,8,264,10,264,12,264,5847,9,264, + 1,264,1,264,1,265,1,265,1,265,1,265,3,265,5855,8,265,1,266,1,266, + 1,266,3,266,5860,8,266,1,266,1,266,3,266,5864,8,266,1,266,1,266, + 3,266,5868,8,266,1,266,1,266,1,266,1,266,1,266,3,266,5875,8,266, + 1,266,3,266,5878,8,266,3,266,5880,8,266,1,267,1,267,1,267,1,267, + 1,268,1,268,3,268,5888,8,268,1,268,1,268,3,268,5892,8,268,1,269, + 3,269,5895,8,269,1,269,1,269,1,269,1,269,1,269,3,269,5902,8,269, + 1,269,1,269,1,269,1,269,1,269,3,269,5909,8,269,1,269,1,269,1,269, + 3,269,5914,8,269,1,269,1,269,1,269,1,269,1,269,3,269,5921,8,269, + 1,269,3,269,5924,8,269,3,269,5926,8,269,1,269,3,269,5929,8,269,1, + 270,1,270,1,270,1,270,3,270,5935,8,270,1,270,1,270,1,270,3,270,5940, + 8,270,1,270,1,270,3,270,5944,8,270,1,271,1,271,1,271,5,271,5949, + 8,271,10,271,12,271,5952,9,271,1,272,1,272,1,272,1,273,1,273,1,273, + 1,274,3,274,5961,8,274,1,274,1,274,1,274,1,274,1,274,3,274,5968, + 8,274,1,274,3,274,5971,8,274,1,274,3,274,5974,8,274,1,275,1,275, + 3,275,5978,8,275,1,275,1,275,1,275,1,275,1,275,1,275,1,275,1,275, + 1,275,3,275,5989,8,275,1,275,3,275,5992,8,275,1,275,3,275,5995,8, + 275,1,275,3,275,5998,8,275,1,276,3,276,6001,8,276,1,276,1,276,1, + 276,1,276,1,276,3,276,6008,8,276,1,276,3,276,6011,8,276,1,276,3, + 276,6014,8,276,1,277,1,277,1,277,5,277,6019,8,277,10,277,12,277, + 6022,9,277,1,278,1,278,1,278,1,278,1,278,1,278,1,278,1,278,1,278, + 3,278,6033,8,278,1,278,1,278,1,278,1,278,1,278,3,278,6040,8,278, + 3,278,6042,8,278,1,279,1,279,1,279,3,279,6047,8,279,1,279,1,279, + 1,279,5,279,6052,8,279,10,279,12,279,6055,9,279,1,279,1,279,1,279, + 3,279,6060,8,279,1,279,1,279,1,279,1,280,1,280,3,280,6067,8,280, + 1,281,1,281,1,281,3,281,6072,8,281,1,281,1,281,1,282,3,282,6077, + 8,282,1,282,1,282,3,282,6081,8,282,1,282,1,282,3,282,6085,8,282, + 1,282,1,282,3,282,6089,8,282,3,282,6091,8,282,1,283,1,283,3,283, + 6095,8,283,1,284,1,284,3,284,6099,8,284,1,284,3,284,6102,8,284,1, + 284,3,284,6105,8,284,3,284,6107,8,284,1,284,1,284,1,284,1,284,1, + 284,1,284,1,284,1,284,3,284,6117,8,284,3,284,6119,8,284,1,284,1, + 284,1,284,3,284,6124,8,284,5,284,6126,8,284,10,284,12,284,6129,9, + 284,1,285,1,285,3,285,6133,8,285,1,286,1,286,3,286,6137,8,286,1, + 286,1,286,1,286,5,286,6142,8,286,10,286,12,286,6145,9,286,1,287, + 1,287,3,287,6149,8,287,1,287,1,287,3,287,6153,8,287,1,287,3,287, + 6156,8,287,1,287,1,287,1,287,1,287,3,287,6162,8,287,1,287,3,287, + 6165,8,287,1,288,1,288,1,288,1,288,1,288,1,288,1,288,1,288,1,289, + 1,289,1,289,1,289,1,289,1,289,1,289,1,289,1,289,3,289,6184,8,289, + 1,289,1,289,1,289,1,290,1,290,3,290,6191,8,290,1,290,1,290,3,290, + 6195,8,290,1,291,3,291,6198,8,291,1,291,1,291,3,291,6202,8,291,1, + 291,1,291,3,291,6206,8,291,1,291,3,291,6209,8,291,1,291,3,291,6212, + 8,291,1,292,1,292,1,292,3,292,6217,8,292,1,293,1,293,1,293,1,293, + 1,293,5,293,6224,8,293,10,293,12,293,6227,9,293,1,294,1,294,1,294, + 1,294,3,294,6233,8,294,1,294,1,294,3,294,6237,8,294,1,295,1,295, + 3,295,6241,8,295,1,295,1,295,3,295,6245,8,295,1,295,3,295,6248,8, + 295,3,295,6250,8,295,1,296,1,296,1,296,3,296,6255,8,296,1,296,1, + 296,3,296,6259,8,296,1,297,1,297,1,297,3,297,6264,8,297,1,297,1, + 297,1,297,1,297,3,297,6270,8,297,1,298,1,298,1,298,1,298,1,298,3, + 298,6277,8,298,1,299,1,299,1,299,3,299,6282,8,299,1,300,1,300,1, + 300,3,300,6287,8,300,1,300,1,300,1,301,1,301,1,301,5,301,6294,8, + 301,10,301,12,301,6297,9,301,1,302,1,302,1,302,1,302,3,302,6303, + 8,302,1,302,1,302,1,302,1,302,5,302,6309,8,302,10,302,12,302,6312, + 9,302,1,302,1,302,1,302,1,302,1,302,1,302,1,302,1,302,3,302,6322, + 8,302,1,303,1,303,1,303,3,303,6327,8,303,1,303,1,303,3,303,6331, + 8,303,1,303,3,303,6334,8,303,1,303,1,303,3,303,6338,8,303,1,303, + 1,303,1,303,3,303,6343,8,303,4,303,6345,8,303,11,303,12,303,6346, + 1,303,1,303,1,303,3,303,6352,8,303,1,304,1,304,1,304,1,304,5,304, + 6358,8,304,10,304,12,304,6361,9,304,1,305,1,305,1,305,1,306,1,306, + 1,306,5,306,6369,8,306,10,306,12,306,6372,9,306,1,307,1,307,3,307, + 6376,8,307,1,307,1,307,3,307,6380,8,307,1,307,3,307,6383,8,307,1, + 307,3,307,6386,8,307,3,307,6388,8,307,1,307,3,307,6391,8,307,1,307, + 3,307,6394,8,307,1,307,3,307,6397,8,307,1,307,1,307,3,307,6401,8, + 307,1,307,1,307,3,307,6405,8,307,1,307,1,307,3,307,6409,8,307,3, + 307,6411,8,307,1,307,1,307,1,307,1,307,1,307,1,307,1,307,3,307,6420, + 8,307,1,307,1,307,1,307,3,307,6425,8,307,1,307,1,307,1,307,1,307, + 3,307,6431,8,307,1,307,1,307,3,307,6435,8,307,3,307,6437,8,307,1, + 307,1,307,1,307,1,307,1,307,3,307,6444,8,307,1,307,1,307,1,307,3, + 307,6449,8,307,1,307,1,307,1,307,1,307,5,307,6455,8,307,10,307,12, + 307,6458,9,307,1,308,3,308,6461,8,308,1,308,1,308,1,308,1,308,1, + 308,3,308,6468,8,308,1,309,1,309,1,309,3,309,6473,8,309,1,309,3, + 309,6476,8,309,1,309,1,309,1,309,1,309,3,309,6482,8,309,1,310,1, + 310,3,310,6486,8,310,1,311,1,311,1,311,1,311,3,311,6492,8,311,1, + 312,1,312,1,312,1,312,1,312,1,312,1,312,3,312,6501,8,312,1,312,1, + 312,1,312,1,312,3,312,6507,8,312,3,312,6509,8,312,1,313,1,313,1, + 313,3,313,6514,8,313,1,313,3,313,6517,8,313,1,313,1,313,1,313,1, + 313,1,313,1,313,1,313,3,313,6526,8,313,1,313,1,313,1,313,1,313,1, + 313,3,313,6533,8,313,3,313,6535,8,313,1,314,1,314,1,314,5,314,6540, + 8,314,10,314,12,314,6543,9,314,1,315,1,315,3,315,6547,8,315,1,315, + 3,315,6550,8,315,1,316,1,316,1,316,1,316,1,316,1,316,1,316,1,316, + 3,316,6560,8,316,1,317,1,317,1,317,1,317,1,317,1,317,1,317,5,317, + 6569,8,317,10,317,12,317,6572,9,317,1,317,1,317,3,317,6576,8,317, + 1,317,1,317,3,317,6580,8,317,1,318,1,318,1,318,1,318,1,318,1,318, + 3,318,6588,8,318,1,319,1,319,1,319,1,320,1,320,1,320,1,320,1,320, + 3,320,6598,8,320,1,321,1,321,1,321,5,321,6603,8,321,10,321,12,321, + 6606,9,321,1,322,1,322,1,322,3,322,6611,8,322,1,323,1,323,1,323, + 1,323,1,323,1,323,1,323,5,323,6620,8,323,10,323,12,323,6623,9,323, + 1,323,1,323,1,323,3,323,6628,8,323,1,323,1,323,1,323,1,323,1,323, + 1,323,5,323,6636,8,323,10,323,12,323,6639,9,323,1,323,1,323,1,324, + 1,324,1,324,1,324,3,324,6647,8,324,1,324,1,324,3,324,6651,8,324, + 1,324,4,324,6654,8,324,11,324,12,324,6655,3,324,6658,8,324,1,324, + 1,324,3,324,6662,8,324,1,325,1,325,1,325,1,325,1,325,1,325,3,325, + 6670,8,325,1,326,3,326,6673,8,326,1,326,1,326,1,326,3,326,6678,8, + 326,1,326,5,326,6681,8,326,10,326,12,326,6684,9,326,1,326,1,326, + 1,326,1,326,3,326,6690,8,326,3,326,6692,8,326,1,326,1,326,1,326, + 1,326,3,326,6698,8,326,1,327,1,327,3,327,6702,8,327,1,327,3,327, + 6705,8,327,1,327,1,327,1,327,3,327,6710,8,327,1,327,3,327,6713,8, + 327,3,327,6715,8,327,1,328,1,328,1,328,1,328,3,328,6721,8,328,1, + 329,1,329,1,329,1,329,1,329,1,329,1,329,3,329,6730,8,329,1,329,1, + 329,1,329,1,329,3,329,6736,8,329,1,329,3,329,6739,8,329,1,330,1, + 330,1,330,1,330,1,331,1,331,3,331,6747,8,331,1,331,3,331,6750,8, + 331,1,332,1,332,3,332,6754,8,332,1,332,1,332,1,332,1,332,3,332,6760, + 8,332,3,332,6762,8,332,1,332,3,332,6765,8,332,1,333,1,333,3,333, + 6769,8,333,1,333,1,333,1,333,3,333,6774,8,333,1,334,1,334,1,334, + 1,334,1,334,3,334,6781,8,334,1,334,1,334,1,334,1,334,1,334,3,334, + 6788,8,334,3,334,6790,8,334,1,334,1,334,1,334,1,334,3,334,6796,8, + 334,3,334,6798,8,334,1,334,1,334,1,334,3,334,6803,8,334,3,334,6805, + 8,334,1,335,1,335,3,335,6809,8,335,1,336,1,336,1,337,1,337,1,338, + 1,338,1,338,3,338,6818,8,338,1,338,1,338,3,338,6822,8,338,1,338, + 1,338,1,338,1,338,1,338,1,338,5,338,6830,8,338,10,338,12,338,6833, + 9,338,1,339,1,339,1,339,1,339,1,339,1,339,1,339,1,339,1,339,1,339, + 1,339,3,339,6846,8,339,1,339,3,339,6849,8,339,1,339,1,339,1,339, + 1,339,1,339,1,339,3,339,6857,8,339,1,339,1,339,1,339,1,339,1,339, + 5,339,6864,8,339,10,339,12,339,6867,9,339,1,339,1,339,1,339,3,339, + 6872,8,339,1,339,1,339,1,339,3,339,6877,8,339,1,339,1,339,1,339, + 1,339,1,339,1,339,3,339,6885,8,339,3,339,6887,8,339,1,339,1,339, + 1,339,3,339,6892,8,339,1,339,1,339,3,339,6896,8,339,1,339,1,339, + 1,339,3,339,6901,8,339,1,339,1,339,1,339,3,339,6906,8,339,1,340, + 1,340,1,340,1,340,3,340,6912,8,340,1,340,1,340,1,340,1,340,1,340, + 1,340,1,340,1,340,1,340,1,340,1,340,1,340,1,340,1,340,5,340,6928, + 8,340,10,340,12,340,6931,9,340,1,341,1,341,1,341,1,341,1,341,1,341, + 3,341,6939,8,341,1,341,1,341,1,341,1,341,1,341,1,341,1,341,1,341, + 1,341,1,341,1,341,1,341,1,341,3,341,6954,8,341,1,341,1,341,1,341, + 3,341,6959,8,341,1,341,3,341,6962,8,341,1,341,1,341,1,341,1,341, + 3,341,6968,8,341,1,341,1,341,1,341,3,341,6973,8,341,1,341,1,341, + 1,341,1,341,1,341,1,341,1,341,1,341,1,341,1,341,1,341,3,341,6986, + 8,341,1,341,4,341,6989,8,341,11,341,12,341,6990,1,341,1,341,3,341, + 6995,8,341,1,341,1,341,1,341,1,341,1,341,3,341,7002,8,341,1,341, + 1,341,1,341,1,341,1,341,1,341,1,341,1,341,1,341,1,341,1,341,1,341, + 1,341,1,341,1,341,1,341,1,341,3,341,7021,8,341,1,341,1,341,1,341, + 1,341,1,341,1,341,1,341,1,341,1,341,1,341,3,341,7033,8,341,1,341, + 1,341,1,341,3,341,7038,8,341,1,341,1,341,1,341,1,341,1,341,1,341, + 3,341,7046,8,341,5,341,7048,8,341,10,341,12,341,7051,9,341,1,342, + 1,342,1,342,1,342,1,342,1,342,3,342,7059,8,342,1,342,3,342,7062, + 8,342,1,342,1,342,1,342,3,342,7067,8,342,1,342,1,342,1,342,3,342, + 7072,8,342,1,342,1,342,3,342,7076,8,342,1,342,3,342,7079,8,342,1, + 343,1,343,1,343,1,343,1,343,1,343,1,343,3,343,7088,8,343,1,343,1, + 343,1,343,1,343,1,343,1,343,3,343,7096,8,343,1,343,1,343,1,343,3, + 343,7101,8,343,3,343,7103,8,343,1,343,3,343,7106,8,343,1,344,1,344, + 3,344,7110,8,344,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345, + 1,345,3,345,7121,8,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345, + 1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345, + 1,345,3,345,7142,8,345,1,345,1,345,1,345,1,345,1,345,1,345,3,345, + 7150,8,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345, + 1,345,1,345,3,345,7163,8,345,1,345,1,345,1,345,1,345,1,345,1,345, + 1,345,1,345,3,345,7173,8,345,1,345,1,345,1,345,1,345,3,345,7179, + 8,345,1,345,1,345,1,345,1,345,3,345,7185,8,345,1,345,3,345,7188, + 8,345,1,345,3,345,7191,8,345,1,345,1,345,1,345,1,345,1,345,1,345, + 1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345, + 1,345,1,345,1,345,1,345,1,345,1,345,1,345,3,345,7217,8,345,3,345, + 7219,8,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345, + 1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,3,345, + 7240,8,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,3,345, + 7250,8,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345,1,345, + 1,345,1,345,3,345,7263,8,345,1,345,1,345,1,345,3,345,7268,8,345, + 1,345,1,345,3,345,7272,8,345,3,345,7274,8,345,1,345,1,345,1,345, + 1,345,1,345,1,345,1,345,1,345,1,345,1,345,3,345,7286,8,345,1,346, + 1,346,1,346,5,346,7291,8,346,10,346,12,346,7294,9,346,1,347,1,347, + 1,347,3,347,7299,8,347,1,348,1,348,1,349,1,349,3,349,7305,8,349, + 1,349,1,349,3,349,7309,8,349,1,350,1,350,1,350,1,351,1,351,1,351, + 1,351,5,351,7318,8,351,10,351,12,351,7321,9,351,1,352,1,352,1,352, + 1,352,1,353,1,353,1,353,3,353,7330,8,353,1,354,1,354,3,354,7334, + 8,354,1,354,1,354,1,354,3,354,7339,8,354,1,354,3,354,7342,8,354, + 1,354,3,354,7345,8,354,1,354,1,354,1,355,1,355,1,355,1,355,1,355, + 3,355,7354,8,355,1,355,1,355,1,355,1,355,1,355,1,355,1,355,1,355, + 1,355,3,355,7365,8,355,3,355,7367,8,355,1,356,1,356,3,356,7371,8, + 356,1,356,1,356,1,356,3,356,7376,8,356,1,357,1,357,1,357,1,357,1, + 357,1,357,1,357,3,357,7385,8,357,1,358,1,358,1,358,3,358,7390,8, + 358,1,358,1,358,1,359,1,359,1,360,1,360,3,360,7398,8,360,1,361,1, + 361,1,362,1,362,1,362,1,362,1,362,1,362,3,362,7408,8,362,1,363,1, + 363,1,363,1,363,1,363,1,363,3,363,7416,8,363,1,364,1,364,3,364,7420, + 8,364,1,364,3,364,7423,8,364,1,365,1,365,1,365,5,365,7428,8,365, + 10,365,12,365,7431,9,365,1,366,1,366,1,366,1,366,1,366,3,366,7438, + 8,366,1,367,1,367,3,367,7442,8,367,1,368,1,368,1,368,5,368,7447, + 8,368,10,368,12,368,7450,9,368,1,369,1,369,1,369,1,369,1,369,3,369, + 7457,8,369,1,370,1,370,1,370,1,370,1,370,5,370,7464,8,370,10,370, + 12,370,7467,9,370,3,370,7469,8,370,1,370,1,370,1,371,1,371,1,371, + 1,371,1,371,1,371,1,371,1,371,3,371,7481,8,371,1,372,1,372,1,373, + 1,373,1,373,1,373,1,373,3,373,7490,8,373,1,373,1,373,1,373,1,373, + 1,373,3,373,7497,8,373,1,373,1,373,1,373,1,373,1,373,1,373,1,373, + 3,373,7506,8,373,1,374,1,374,1,374,1,374,1,374,1,375,1,375,1,375, + 3,375,7516,8,375,1,375,1,375,1,375,3,375,7521,8,375,1,375,1,375, + 3,375,7525,8,375,3,375,7527,8,375,1,375,3,375,7530,8,375,1,376,4, + 376,7533,8,376,11,376,12,376,7534,1,377,5,377,7538,8,377,10,377, + 12,377,7541,9,377,1,378,1,378,1,378,5,378,7546,8,378,10,378,12,378, + 7549,9,378,1,379,1,379,1,379,1,379,1,379,3,379,7556,8,379,1,379, + 3,379,7559,8,379,1,380,1,380,1,380,5,380,7564,8,380,10,380,12,380, + 7567,9,380,1,381,1,381,1,381,5,381,7572,8,381,10,381,12,381,7575, + 9,381,1,382,1,382,1,382,5,382,7580,8,382,10,382,12,382,7583,9,382, + 1,383,1,383,1,383,5,383,7588,8,383,10,383,12,383,7591,9,383,1,384, + 1,384,1,385,1,385,1,386,1,386,1,387,1,387,1,388,1,388,1,389,1,389, + 1,390,1,390,3,390,7607,8,390,1,391,1,391,1,391,5,391,7612,8,391, + 10,391,12,391,7615,9,391,1,392,1,392,1,392,5,392,7620,8,392,10,392, + 12,392,7623,9,392,1,393,1,393,1,394,1,394,1,395,1,395,1,396,1,396, + 1,397,1,397,1,398,1,398,1,398,1,398,3,398,7639,8,398,1,399,1,399, + 1,399,1,399,3,399,7645,8,399,1,400,1,400,1,400,1,400,3,400,7651, + 8,400,1,401,1,401,1,402,1,402,1,402,1,402,3,402,7659,8,402,1,403, + 1,403,1,403,1,403,3,403,7665,8,403,1,404,1,404,1,404,3,404,7670, + 8,404,1,405,1,405,1,405,1,405,5,405,7676,8,405,10,405,12,405,7679, + 9,405,1,405,1,405,3,405,7683,8,405,1,406,3,406,7686,8,406,1,406, + 1,406,1,407,1,407,1,407,1,407,1,407,3,407,7695,8,407,1,408,1,408, + 1,408,5,408,7700,8,408,10,408,12,408,7703,9,408,1,409,1,409,1,409, + 1,409,3,409,7709,8,409,1,410,1,410,1,410,1,410,3,410,7715,8,410, + 1,411,1,411,1,411,1,411,3,411,7721,8,411,1,412,1,412,1,412,3,412, + 7726,8,412,1,413,1,413,1,413,3,413,7731,8,413,1,413,1,413,1,413, + 1,413,1,413,1,413,3,413,7739,8,413,1,414,1,414,1,415,1,415,1,415, + 1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415, + 1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415, + 1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415, + 1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415,1,415, + 1,415,1,415,1,415,1,415,3,415,7794,8,415,1,416,1,416,1,417,1,417, + 1,418,3,418,7801,8,418,1,418,1,418,1,418,1,418,4,418,7807,8,418, + 11,418,12,418,7808,3,418,7811,8,418,3,418,7813,8,418,1,418,1,418, + 5,418,7817,8,418,10,418,12,418,7820,9,418,1,418,3,418,7823,8,418, + 1,418,1,418,3,418,7827,8,418,1,419,1,419,1,419,1,419,1,420,1,420, + 1,420,1,420,1,420,3,420,7838,8,420,1,420,3,420,7841,8,420,1,420, + 1,420,3,420,7845,8,420,1,420,1,420,3,420,7849,8,420,1,420,1,420, + 3,420,7853,8,420,1,420,3,420,7856,8,420,1,420,3,420,7859,8,420,1, + 420,3,420,7862,8,420,1,420,1,420,1,420,1,420,1,420,5,420,7869,8, + 420,10,420,12,420,7872,9,420,1,420,1,420,3,420,7876,8,420,1,420, + 1,420,3,420,7880,8,420,1,420,1,420,1,421,1,421,1,421,1,422,1,422, + 1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423, + 1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,423, + 1,423,1,423,3,423,7913,8,423,1,424,1,424,1,424,1,424,1,425,1,425, + 1,425,1,425,3,425,7923,8,425,1,425,1,425,3,425,7927,8,425,1,425, + 1,425,1,425,1,425,3,425,7933,8,425,1,425,1,425,1,425,3,425,7938, + 8,425,1,426,1,426,1,426,1,426,1,426,1,427,1,427,3,427,7947,8,427, + 1,427,1,427,1,427,1,427,5,427,7953,8,427,10,427,12,427,7956,9,427, + 1,427,1,427,1,428,1,428,1,428,1,428,1,429,1,429,3,429,7966,8,429, + 1,429,1,429,1,429,1,429,5,429,7972,8,429,10,429,12,429,7975,9,429, + 1,430,1,430,1,430,1,430,5,430,7981,8,430,10,430,12,430,7984,9,430, + 1,430,1,430,1,430,1,430,5,430,7990,8,430,10,430,12,430,7993,9,430, + 5,430,7995,8,430,10,430,12,430,7998,9,430,1,430,3,430,8001,8,430, + 1,430,1,430,1,430,1,430,1,431,1,431,5,431,8009,8,431,10,431,12,431, + 8012,9,431,1,432,1,432,3,432,8016,8,432,1,432,1,432,1,432,1,432, + 5,432,8022,8,432,10,432,12,432,8025,9,432,4,432,8027,8,432,11,432, + 12,432,8028,1,432,3,432,8032,8,432,1,432,1,432,1,432,1,432,1,433, + 3,433,8039,8,433,1,433,1,433,1,433,1,433,3,433,8045,8,433,1,433, + 1,433,1,434,1,434,1,434,1,434,3,434,8053,8,434,1,434,1,434,1,434, + 1,434,1,434,1,434,3,434,8061,8,434,1,434,3,434,8064,8,434,1,434, + 1,434,1,434,1,434,1,434,3,434,8071,8,434,3,434,8073,8,434,1,435, + 3,435,8076,8,435,1,435,1,435,1,435,1,435,3,435,8082,8,435,1,435, + 1,435,1,435,1,435,1,435,1,436,1,436,3,436,8091,8,436,1,436,1,436, + 3,436,8095,8,436,1,436,1,436,1,437,1,437,1,437,1,437,1,437,1,437, + 1,437,1,437,1,437,1,437,3,437,8109,8,437,1,437,3,437,8112,8,437, + 3,437,8114,8,437,1,437,1,437,1,438,1,438,3,438,8120,8,438,1,438, + 1,438,1,438,1,438,1,438,1,438,4,438,8128,8,438,11,438,12,438,8129, + 3,438,8132,8,438,3,438,8134,8,438,1,438,1,438,1,438,1,438,5,438, + 8140,8,438,10,438,12,438,8143,9,438,3,438,8145,8,438,1,438,3,438, + 8148,8,438,1,439,1,439,1,439,1,439,1,440,1,440,1,440,1,440,3,440, + 8158,8,440,1,440,1,440,1,441,1,441,5,441,8164,8,441,10,441,12,441, + 8167,9,441,1,441,1,441,1,441,3,441,8172,8,441,1,441,1,441,1,442, + 1,442,3,442,8178,8,442,1,442,1,442,1,443,1,443,1,443,3,443,8185, + 8,443,1,443,1,443,3,443,8189,8,443,1,443,1,443,3,443,8193,8,443, + 1,443,3,443,8196,8,443,1,443,3,443,8199,8,443,1,443,1,443,1,444, + 1,444,3,444,8205,8,444,1,444,1,444,1,445,1,445,1,445,3,445,8212, + 8,445,1,445,3,445,8215,8,445,1,445,1,445,1,445,1,445,1,445,1,445, + 3,445,8223,8,445,3,445,8225,8,445,1,445,1,445,1,445,1,445,1,445, + 5,445,8232,8,445,10,445,12,445,8235,9,445,1,445,1,445,3,445,8239, + 8,445,3,445,8241,8,445,1,445,1,445,1,446,1,446,1,446,3,446,8248, + 8,446,1,446,1,446,1,447,1,447,3,447,8254,8,447,1,447,3,447,8257, + 8,447,1,447,1,447,1,447,1,447,1,447,1,448,1,448,1,448,1,448,1,448, + 3,448,8269,8,448,1,448,1,448,1,448,1,448,1,448,3,448,8276,8,448, + 3,448,8278,8,448,1,449,1,449,3,449,8282,8,449,1,449,1,449,1,449, + 1,450,3,450,8288,8,450,1,450,1,450,1,450,3,450,8293,8,450,1,450, + 1,450,3,450,8297,8,450,1,450,3,450,8300,8,450,1,450,3,450,8303,8, + 450,1,450,1,450,1,450,1,450,1,450,4,450,8310,8,450,11,450,12,450, + 8311,1,451,3,451,8315,8,451,1,451,1,451,3,451,8319,8,451,1,451,1, + 451,3,451,8323,8,451,3,451,8325,8,451,1,451,3,451,8328,8,451,1,451, + 3,451,8331,8,451,1,452,1,452,1,452,1,452,3,452,8337,8,452,1,452, + 1,452,1,452,1,452,1,452,3,452,8344,8,452,1,452,1,452,1,452,1,452, + 1,452,3,452,8351,8,452,1,452,1,452,1,452,1,452,3,452,8357,8,452, + 3,452,8359,8,452,1,453,1,453,3,453,8363,8,453,1,453,1,453,1,453, + 3,453,8368,8,453,1,453,1,453,1,454,1,454,1,454,1,454,1,454,1,454, + 1,454,1,454,1,454,1,454,1,454,1,454,5,454,8384,8,454,10,454,12,454, + 8387,9,454,1,454,1,454,4,454,8391,8,454,11,454,12,454,8392,1,455, + 1,455,1,455,1,455,1,455,5,455,8400,8,455,10,455,12,455,8403,9,455, + 1,455,1,455,1,455,1,455,3,455,8409,8,455,1,456,1,456,3,456,8413, + 8,456,1,457,1,457,1,457,1,457,1,458,1,458,1,458,1,459,1,459,1,459, + 3,459,8425,8,459,1,459,3,459,8428,8,459,1,459,1,459,1,460,1,460, + 1,460,1,460,1,460,1,460,1,460,1,460,1,460,3,460,8441,8,460,1,460, + 3,460,8444,8,460,1,461,1,461,3,461,8448,8,461,1,462,1,462,1,462, + 1,462,1,462,5,462,8455,8,462,10,462,12,462,8458,9,462,1,462,1,462, + 5,462,8462,8,462,10,462,12,462,8465,9,462,4,462,8467,8,462,11,462, + 12,462,8468,1,463,1,463,1,463,3,463,8474,8,463,1,464,1,464,3,464, + 8478,8,464,1,465,1,465,1,466,3,466,8483,8,466,1,466,3,466,8486,8, + 466,1,466,3,466,8489,8,466,1,466,3,466,8492,8,466,1,466,3,466,8495, + 8,466,1,466,1,466,3,466,8499,8,466,1,466,3,466,8502,8,466,1,466, + 0,3,676,680,682,467,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32, + 34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76, + 78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114, + 116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,146, + 148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178, + 180,182,184,186,188,190,192,194,196,198,200,202,204,206,208,210, + 212,214,216,218,220,222,224,226,228,230,232,234,236,238,240,242, + 244,246,248,250,252,254,256,258,260,262,264,266,268,270,272,274, + 276,278,280,282,284,286,288,290,292,294,296,298,300,302,304,306, + 308,310,312,314,316,318,320,322,324,326,328,330,332,334,336,338, + 340,342,344,346,348,350,352,354,356,358,360,362,364,366,368,370, + 372,374,376,378,380,382,384,386,388,390,392,394,396,398,400,402, + 404,406,408,410,412,414,416,418,420,422,424,426,428,430,432,434, + 436,438,440,442,444,446,448,450,452,454,456,458,460,462,464,466, + 468,470,472,474,476,478,480,482,484,486,488,490,492,494,496,498, + 500,502,504,506,508,510,512,514,516,518,520,522,524,526,528,530, + 532,534,536,538,540,542,544,546,548,550,552,554,556,558,560,562, + 564,566,568,570,572,574,576,578,580,582,584,586,588,590,592,594, + 596,598,600,602,604,606,608,610,612,614,616,618,620,622,624,626, + 628,630,632,634,636,638,640,642,644,646,648,650,652,654,656,658, + 660,662,664,666,668,670,672,674,676,678,680,682,684,686,688,690, + 692,694,696,698,700,702,704,706,708,710,712,714,716,718,720,722, + 724,726,728,730,732,734,736,738,740,742,744,746,748,750,752,754, + 756,758,760,762,764,766,768,770,772,774,776,778,780,782,784,786, + 788,790,792,794,796,798,800,802,804,806,808,810,812,814,816,818, + 820,822,824,826,828,830,832,834,836,838,840,842,844,846,848,850, + 852,854,856,858,860,862,864,866,868,870,872,874,876,878,880,882, + 884,886,888,890,892,894,896,898,900,902,904,906,908,910,912,914, + 916,918,920,922,924,926,928,930,932,0,119,2,0,195,195,364,364,2, + 0,66,66,318,318,2,0,99,99,318,318,2,0,134,134,318,318,1,0,529,531, + 2,0,10,10,94,94,2,0,133,133,191,191,2,0,254,254,332,332,2,0,162, + 162,363,363,2,0,180,180,221,221,5,0,30,30,288,288,329,329,352,352, + 354,354,2,0,109,109,532,532,2,0,158,158,277,277,2,0,367,367,439, + 439,2,0,139,139,312,312,2,0,191,191,333,333,2,0,313,313,333,333, + 2,0,150,150,315,315,2,0,64,64,94,94,4,0,78,78,183,183,197,197,298, + 298,2,0,213,213,254,254,2,0,352,352,354,354,2,0,200,200,224,224, + 9,0,30,30,160,160,165,165,179,179,219,219,227,227,342,342,345,345, + 438,438,3,0,113,113,284,284,336,336,2,0,53,53,78,78,2,0,105,105, + 379,379,2,0,260,260,262,262,3,0,173,173,260,260,262,262,1,0,12,13, + 2,0,64,64,375,375,2,0,156,156,206,206,2,0,189,189,360,360,2,0,215, + 215,373,373,3,0,133,133,191,191,333,333,5,0,30,30,88,88,182,182, + 241,241,369,369,2,0,9,9,94,94,2,0,92,92,226,226,1,0,448,449,2,0, + 92,92,414,414,2,0,341,341,414,414,4,0,163,163,185,185,283,283,353, + 353,2,0,135,135,145,145,2,0,211,211,278,278,3,0,321,321,357,357, + 445,445,3,0,66,66,99,99,318,318,5,0,108,108,168,168,226,226,328, + 328,342,342,2,0,167,167,314,314,2,0,61,61,265,265,4,0,207,207,249, + 249,268,268,293,293,2,0,130,130,307,307,2,0,64,64,68,68,10,0,46, + 46,88,88,182,182,202,202,241,241,352,352,354,354,357,358,369,369, + 521,523,5,0,212,212,329,329,350,350,455,455,457,457,5,0,212,212, + 329,329,350,350,361,361,455,456,2,0,37,37,55,55,2,0,207,207,249, + 249,2,0,10,10,53,53,2,0,181,181,243,243,2,0,170,170,320,320,2,0, + 141,141,223,223,5,0,108,108,168,168,189,189,342,342,360,360,2,0, + 226,226,328,328,2,0,163,163,185,185,2,0,186,186,193,193,4,0,88,88, + 182,182,241,241,369,369,2,0,137,137,242,242,2,0,161,161,319,319, + 4,0,129,129,161,161,319,319,454,454,2,0,356,356,380,380,2,0,81,81, + 382,382,2,0,151,151,254,254,2,0,133,133,138,138,1,0,31,32,2,0,128, + 128,547,547,2,0,60,60,96,96,2,0,99,99,349,349,2,0,131,131,414,414, + 2,0,201,201,334,334,3,0,59,59,70,70,97,97,2,0,30,30,56,56,1,0,527, + 528,2,0,207,207,268,268,2,0,320,320,414,414,2,0,571,571,573,573, + 1,0,468,469,4,0,113,113,115,115,119,119,126,126,2,0,360,360,477, + 477,2,0,394,395,409,409,2,0,391,392,406,406,1,0,391,392,1,0,418, + 419,5,0,10,10,16,17,21,21,23,23,25,25,3,0,9,9,14,14,27,27,2,0,98, + 98,396,396,2,0,50,51,75,76,2,0,41,41,420,420,3,0,39,39,73,73,95, + 95,4,0,393,393,399,399,404,404,425,425,2,0,292,292,347,347,2,0,166, + 166,188,188,2,0,304,304,450,450,3,0,299,299,320,320,481,481,2,0, + 208,208,289,289,3,0,30,30,34,34,90,90,6,0,9,10,12,17,21,21,23,23, + 25,25,27,27,2,0,114,114,120,120,2,0,20,20,22,22,1,0,483,486,10,0, + 124,124,129,228,238,386,433,452,455,469,471,471,473,473,475,475, + 478,488,547,548,3,0,106,123,125,128,472,472,4,0,30,52,54,70,72,105, + 454,454,2,0,62,62,116,116,2,0,10,10,20,20,2,0,434,434,501,501,2, + 0,167,167,507,507,1,0,512,517,2,0,144,144,210,210,36,0,33,33,35, + 35,43,43,45,45,53,53,57,57,61,61,116,116,123,123,130,130,144,144, + 153,153,157,157,161,161,167,167,172,172,207,207,210,210,241,241, + 249,249,265,265,268,269,279,279,293,293,307,307,313,313,319,319, + 323,324,333,333,360,360,433,434,477,477,490,502,504,504,506,518, + 520,520,9941,0,937,1,0,0,0,2,942,1,0,0,0,4,1066,1,0,0,0,6,1068,1, + 0,0,0,8,1071,1,0,0,0,10,1121,1,0,0,0,12,1131,1,0,0,0,14,1133,1,0, + 0,0,16,1145,1,0,0,0,18,1157,1,0,0,0,20,1168,1,0,0,0,22,1202,1,0, + 0,0,24,1246,1,0,0,0,26,1248,1,0,0,0,28,1260,1,0,0,0,30,1267,1,0, + 0,0,32,1286,1,0,0,0,34,1294,1,0,0,0,36,1296,1,0,0,0,38,1310,1,0, + 0,0,40,1314,1,0,0,0,42,1351,1,0,0,0,44,1353,1,0,0,0,46,1361,1,0, + 0,0,48,1371,1,0,0,0,50,1378,1,0,0,0,52,1386,1,0,0,0,54,1392,1,0, + 0,0,56,1408,1,0,0,0,58,1412,1,0,0,0,60,1414,1,0,0,0,62,1426,1,0, + 0,0,64,1431,1,0,0,0,66,1436,1,0,0,0,68,1438,1,0,0,0,70,1450,1,0, + 0,0,72,1458,1,0,0,0,74,1460,1,0,0,0,76,1584,1,0,0,0,78,1586,1,0, + 0,0,80,1603,1,0,0,0,82,1605,1,0,0,0,84,1619,1,0,0,0,86,1621,1,0, + 0,0,88,1635,1,0,0,0,90,1637,1,0,0,0,92,1874,1,0,0,0,94,1881,1,0, + 0,0,96,1883,1,0,0,0,98,1885,1,0,0,0,100,1888,1,0,0,0,102,1899,1, + 0,0,0,104,1902,1,0,0,0,106,1938,1,0,0,0,108,1940,1,0,0,0,110,1981, + 1,0,0,0,112,1983,1,0,0,0,114,2037,1,0,0,0,116,2078,1,0,0,0,118,2080, + 1,0,0,0,120,2097,1,0,0,0,122,2178,1,0,0,0,124,2180,1,0,0,0,126,2191, + 1,0,0,0,128,2214,1,0,0,0,130,2232,1,0,0,0,132,2234,1,0,0,0,134,2269, + 1,0,0,0,136,2362,1,0,0,0,138,2367,1,0,0,0,140,2369,1,0,0,0,142,2467, + 1,0,0,0,144,2469,1,0,0,0,146,2473,1,0,0,0,148,2484,1,0,0,0,150,2492, + 1,0,0,0,152,2495,1,0,0,0,154,2498,1,0,0,0,156,2516,1,0,0,0,158,2518, + 1,0,0,0,160,2522,1,0,0,0,162,2535,1,0,0,0,164,2537,1,0,0,0,166,2542, + 1,0,0,0,168,2562,1,0,0,0,170,2570,1,0,0,0,172,2577,1,0,0,0,174,2579, + 1,0,0,0,176,2588,1,0,0,0,178,2591,1,0,0,0,180,2595,1,0,0,0,182,2599, + 1,0,0,0,184,2624,1,0,0,0,186,2634,1,0,0,0,188,2648,1,0,0,0,190,2664, + 1,0,0,0,192,2670,1,0,0,0,194,2697,1,0,0,0,196,2707,1,0,0,0,198,2723, + 1,0,0,0,200,2767,1,0,0,0,202,2774,1,0,0,0,204,2776,1,0,0,0,206,2802, + 1,0,0,0,208,2813,1,0,0,0,210,2832,1,0,0,0,212,2843,1,0,0,0,214,2881, + 1,0,0,0,216,2902,1,0,0,0,218,2904,1,0,0,0,220,2924,1,0,0,0,222,2936, + 1,0,0,0,224,2948,1,0,0,0,226,2951,1,0,0,0,228,2954,1,0,0,0,230,2974, + 1,0,0,0,232,2979,1,0,0,0,234,3028,1,0,0,0,236,3030,1,0,0,0,238,3053, + 1,0,0,0,240,3069,1,0,0,0,242,3081,1,0,0,0,244,3108,1,0,0,0,246,3123, + 1,0,0,0,248,3186,1,0,0,0,250,3188,1,0,0,0,252,3193,1,0,0,0,254,3199, + 1,0,0,0,256,3286,1,0,0,0,258,3292,1,0,0,0,260,3294,1,0,0,0,262,3310, + 1,0,0,0,264,3312,1,0,0,0,266,3321,1,0,0,0,268,3325,1,0,0,0,270,3338, + 1,0,0,0,272,3350,1,0,0,0,274,3352,1,0,0,0,276,3374,1,0,0,0,278,3386, + 1,0,0,0,280,3397,1,0,0,0,282,3488,1,0,0,0,284,3490,1,0,0,0,286,3501, + 1,0,0,0,288,3512,1,0,0,0,290,3514,1,0,0,0,292,3540,1,0,0,0,294,3542, + 1,0,0,0,296,3546,1,0,0,0,298,3596,1,0,0,0,300,3598,1,0,0,0,302,3604, + 1,0,0,0,304,3629,1,0,0,0,306,3633,1,0,0,0,308,3847,1,0,0,0,310,3865, + 1,0,0,0,312,3891,1,0,0,0,314,3893,1,0,0,0,316,3901,1,0,0,0,318,3907, + 1,0,0,0,320,3911,1,0,0,0,322,3931,1,0,0,0,324,3937,1,0,0,0,326,4004, + 1,0,0,0,328,4035,1,0,0,0,330,4081,1,0,0,0,332,4083,1,0,0,0,334,4085, + 1,0,0,0,336,4096,1,0,0,0,338,4133,1,0,0,0,340,4135,1,0,0,0,342,4141, + 1,0,0,0,344,4191,1,0,0,0,346,4194,1,0,0,0,348,4208,1,0,0,0,350,4229, + 1,0,0,0,352,4253,1,0,0,0,354,4294,1,0,0,0,356,4296,1,0,0,0,358,4298, + 1,0,0,0,360,4338,1,0,0,0,362,4355,1,0,0,0,364,4375,1,0,0,0,366,4428, + 1,0,0,0,368,4431,1,0,0,0,370,4437,1,0,0,0,372,4445,1,0,0,0,374,4458, + 1,0,0,0,376,4460,1,0,0,0,378,4473,1,0,0,0,380,4475,1,0,0,0,382,4488, + 1,0,0,0,384,4498,1,0,0,0,386,4509,1,0,0,0,388,4520,1,0,0,0,390,4522, + 1,0,0,0,392,4527,1,0,0,0,394,4541,1,0,0,0,396,4573,1,0,0,0,398,4610, + 1,0,0,0,400,4612,1,0,0,0,402,4615,1,0,0,0,404,4618,1,0,0,0,406,4635, + 1,0,0,0,408,4656,1,0,0,0,410,4672,1,0,0,0,412,4688,1,0,0,0,414,4710, + 1,0,0,0,416,4715,1,0,0,0,418,4718,1,0,0,0,420,4726,1,0,0,0,422,4751, + 1,0,0,0,424,4754,1,0,0,0,426,4782,1,0,0,0,428,4787,1,0,0,0,430,4827, + 1,0,0,0,432,5039,1,0,0,0,434,5041,1,0,0,0,436,5129,1,0,0,0,438,5131, + 1,0,0,0,440,5137,1,0,0,0,442,5148,1,0,0,0,444,5158,1,0,0,0,446,5238, + 1,0,0,0,448,5240,1,0,0,0,450,5254,1,0,0,0,452,5276,1,0,0,0,454,5349, + 1,0,0,0,456,5351,1,0,0,0,458,5392,1,0,0,0,460,5394,1,0,0,0,462,5399, + 1,0,0,0,464,5402,1,0,0,0,466,5405,1,0,0,0,468,5455,1,0,0,0,470,5457, + 1,0,0,0,472,5468,1,0,0,0,474,5470,1,0,0,0,476,5480,1,0,0,0,478,5515, + 1,0,0,0,480,5518,1,0,0,0,482,5539,1,0,0,0,484,5549,1,0,0,0,486,5569, + 1,0,0,0,488,5575,1,0,0,0,490,5581,1,0,0,0,492,5586,1,0,0,0,494,5599, + 1,0,0,0,496,5626,1,0,0,0,498,5674,1,0,0,0,500,5676,1,0,0,0,502,5714, + 1,0,0,0,504,5716,1,0,0,0,506,5737,1,0,0,0,508,5757,1,0,0,0,510,5761, + 1,0,0,0,512,5776,1,0,0,0,514,5778,1,0,0,0,516,5782,1,0,0,0,518,5786, + 1,0,0,0,520,5794,1,0,0,0,522,5818,1,0,0,0,524,5820,1,0,0,0,526,5831, + 1,0,0,0,528,5839,1,0,0,0,530,5854,1,0,0,0,532,5879,1,0,0,0,534,5881, + 1,0,0,0,536,5885,1,0,0,0,538,5894,1,0,0,0,540,5934,1,0,0,0,542,5945, + 1,0,0,0,544,5953,1,0,0,0,546,5956,1,0,0,0,548,5960,1,0,0,0,550,5975, + 1,0,0,0,552,6000,1,0,0,0,554,6015,1,0,0,0,556,6041,1,0,0,0,558,6043, + 1,0,0,0,560,6066,1,0,0,0,562,6068,1,0,0,0,564,6076,1,0,0,0,566,6094, + 1,0,0,0,568,6118,1,0,0,0,570,6130,1,0,0,0,572,6134,1,0,0,0,574,6146, + 1,0,0,0,576,6166,1,0,0,0,578,6174,1,0,0,0,580,6188,1,0,0,0,582,6211, + 1,0,0,0,584,6213,1,0,0,0,586,6218,1,0,0,0,588,6228,1,0,0,0,590,6249, + 1,0,0,0,592,6251,1,0,0,0,594,6260,1,0,0,0,596,6271,1,0,0,0,598,6281, + 1,0,0,0,600,6283,1,0,0,0,602,6290,1,0,0,0,604,6321,1,0,0,0,606,6351, + 1,0,0,0,608,6353,1,0,0,0,610,6362,1,0,0,0,612,6365,1,0,0,0,614,6436, + 1,0,0,0,616,6460,1,0,0,0,618,6481,1,0,0,0,620,6483,1,0,0,0,622,6491, + 1,0,0,0,624,6508,1,0,0,0,626,6534,1,0,0,0,628,6536,1,0,0,0,630,6544, + 1,0,0,0,632,6551,1,0,0,0,634,6575,1,0,0,0,636,6581,1,0,0,0,638,6589, + 1,0,0,0,640,6592,1,0,0,0,642,6599,1,0,0,0,644,6607,1,0,0,0,646,6612, + 1,0,0,0,648,6642,1,0,0,0,650,6669,1,0,0,0,652,6697,1,0,0,0,654,6714, + 1,0,0,0,656,6720,1,0,0,0,658,6738,1,0,0,0,660,6740,1,0,0,0,662,6744, + 1,0,0,0,664,6761,1,0,0,0,666,6766,1,0,0,0,668,6804,1,0,0,0,670,6806, + 1,0,0,0,672,6810,1,0,0,0,674,6812,1,0,0,0,676,6821,1,0,0,0,678,6905, + 1,0,0,0,680,6911,1,0,0,0,682,7020,1,0,0,0,684,7052,1,0,0,0,686,7105, + 1,0,0,0,688,7109,1,0,0,0,690,7285,1,0,0,0,692,7287,1,0,0,0,694,7295, + 1,0,0,0,696,7300,1,0,0,0,698,7302,1,0,0,0,700,7310,1,0,0,0,702,7313, + 1,0,0,0,704,7322,1,0,0,0,706,7326,1,0,0,0,708,7331,1,0,0,0,710,7348, + 1,0,0,0,712,7375,1,0,0,0,714,7384,1,0,0,0,716,7386,1,0,0,0,718,7393, + 1,0,0,0,720,7397,1,0,0,0,722,7399,1,0,0,0,724,7407,1,0,0,0,726,7415, + 1,0,0,0,728,7422,1,0,0,0,730,7424,1,0,0,0,732,7437,1,0,0,0,734,7441, + 1,0,0,0,736,7443,1,0,0,0,738,7456,1,0,0,0,740,7458,1,0,0,0,742,7480, + 1,0,0,0,744,7482,1,0,0,0,746,7505,1,0,0,0,748,7507,1,0,0,0,750,7529, + 1,0,0,0,752,7532,1,0,0,0,754,7539,1,0,0,0,756,7542,1,0,0,0,758,7558, + 1,0,0,0,760,7560,1,0,0,0,762,7568,1,0,0,0,764,7576,1,0,0,0,766,7584, + 1,0,0,0,768,7592,1,0,0,0,770,7594,1,0,0,0,772,7596,1,0,0,0,774,7598, + 1,0,0,0,776,7600,1,0,0,0,778,7602,1,0,0,0,780,7604,1,0,0,0,782,7608, + 1,0,0,0,784,7616,1,0,0,0,786,7624,1,0,0,0,788,7626,1,0,0,0,790,7628, + 1,0,0,0,792,7630,1,0,0,0,794,7632,1,0,0,0,796,7638,1,0,0,0,798,7644, + 1,0,0,0,800,7650,1,0,0,0,802,7652,1,0,0,0,804,7658,1,0,0,0,806,7664, + 1,0,0,0,808,7666,1,0,0,0,810,7682,1,0,0,0,812,7685,1,0,0,0,814,7694, + 1,0,0,0,816,7696,1,0,0,0,818,7708,1,0,0,0,820,7714,1,0,0,0,822,7720, + 1,0,0,0,824,7725,1,0,0,0,826,7738,1,0,0,0,828,7740,1,0,0,0,830,7793, + 1,0,0,0,832,7795,1,0,0,0,834,7797,1,0,0,0,836,7800,1,0,0,0,838,7828, + 1,0,0,0,840,7832,1,0,0,0,842,7883,1,0,0,0,844,7886,1,0,0,0,846,7912, + 1,0,0,0,848,7914,1,0,0,0,850,7937,1,0,0,0,852,7939,1,0,0,0,854,7944, + 1,0,0,0,856,7959,1,0,0,0,858,7965,1,0,0,0,860,7976,1,0,0,0,862,8006, + 1,0,0,0,864,8013,1,0,0,0,866,8038,1,0,0,0,868,8048,1,0,0,0,870,8075, + 1,0,0,0,872,8088,1,0,0,0,874,8098,1,0,0,0,876,8117,1,0,0,0,878,8149, + 1,0,0,0,880,8153,1,0,0,0,882,8161,1,0,0,0,884,8175,1,0,0,0,886,8181, + 1,0,0,0,888,8202,1,0,0,0,890,8208,1,0,0,0,892,8247,1,0,0,0,894,8251, + 1,0,0,0,896,8277,1,0,0,0,898,8279,1,0,0,0,900,8287,1,0,0,0,902,8324, + 1,0,0,0,904,8358,1,0,0,0,906,8360,1,0,0,0,908,8371,1,0,0,0,910,8408, + 1,0,0,0,912,8412,1,0,0,0,914,8414,1,0,0,0,916,8418,1,0,0,0,918,8421, + 1,0,0,0,920,8443,1,0,0,0,922,8447,1,0,0,0,924,8449,1,0,0,0,926,8473, + 1,0,0,0,928,8477,1,0,0,0,930,8479,1,0,0,0,932,8482,1,0,0,0,934,936, + 3,2,1,0,935,934,1,0,0,0,936,939,1,0,0,0,937,935,1,0,0,0,937,938, + 1,0,0,0,938,940,1,0,0,0,939,937,1,0,0,0,940,941,5,0,0,1,941,1,1, + 0,0,0,942,944,3,4,2,0,943,945,5,7,0,0,944,943,1,0,0,0,944,945,1, + 0,0,0,945,3,1,0,0,0,946,1067,3,278,139,0,947,1067,3,488,244,0,948, + 1067,3,484,242,0,949,1067,3,486,243,0,950,1067,3,352,176,0,951,1067, + 3,494,247,0,952,1067,3,292,146,0,953,1067,3,210,105,0,954,1067,3, + 212,106,0,955,1067,3,218,109,0,956,1067,3,232,116,0,957,1067,3,404, + 202,0,958,1067,3,28,14,0,959,1067,3,434,217,0,960,1067,3,436,218, + 0,961,1067,3,446,223,0,962,1067,3,438,219,0,963,1067,3,444,222,0, + 964,1067,3,244,122,0,965,1067,3,246,123,0,966,1067,3,198,99,0,967, + 1067,3,490,245,0,968,1067,3,76,38,0,969,1067,3,430,215,0,970,1067, + 3,108,54,0,971,1067,3,450,225,0,972,1067,3,18,9,0,973,1067,3,20, + 10,0,974,1067,3,16,8,0,975,1067,3,454,227,0,976,1067,3,184,92,0, + 977,1067,3,498,249,0,978,1067,3,496,248,0,979,1067,3,240,120,0,980, + 1067,3,506,253,0,981,1067,3,6,3,0,982,1067,3,72,36,0,983,1067,3, + 112,56,0,984,1067,3,502,251,0,985,1067,3,324,162,0,986,1067,3,70, + 35,0,987,1067,3,114,57,0,988,1067,3,254,127,0,989,1067,3,186,93, + 0,990,1067,3,280,140,0,991,1067,3,420,210,0,992,1067,3,500,250,0, + 993,1067,3,492,246,0,994,1067,3,208,104,0,995,1067,3,214,107,0,996, + 1067,3,228,114,0,997,1067,3,234,117,0,998,1067,3,364,182,0,999,1067, + 3,26,13,0,1000,1067,3,192,96,0,1001,1067,3,296,148,0,1002,1067,3, + 300,150,0,1003,1067,3,448,224,0,1004,1067,3,302,151,0,1005,1067, + 3,242,121,0,1006,1067,3,204,102,0,1007,1067,3,30,15,0,1008,1067, + 3,196,98,0,1009,1067,3,120,60,0,1010,1067,3,452,226,0,1011,1067, + 3,182,91,0,1012,1067,3,206,103,0,1013,1067,3,424,212,0,1014,1067, + 3,256,128,0,1015,1067,3,274,137,0,1016,1067,3,8,4,0,1017,1067,3, + 14,7,0,1018,1067,3,238,119,0,1019,1067,3,480,240,0,1020,1067,3,536, + 268,0,1021,1067,3,558,279,0,1022,1067,3,282,141,0,1023,1067,3,548, + 274,0,1024,1067,3,74,37,0,1025,1067,3,418,209,0,1026,1067,3,308, + 154,0,1027,1067,3,532,266,0,1028,1067,3,520,260,0,1029,1067,3,328, + 164,0,1030,1067,3,334,167,0,1031,1067,3,348,174,0,1032,1067,3,900, + 450,0,1033,1067,3,236,118,0,1034,1067,3,358,179,0,1035,1067,3,538, + 269,0,1036,1067,3,464,232,0,1037,1067,3,194,97,0,1038,1067,3,478, + 239,0,1039,1067,3,550,275,0,1040,1067,3,460,230,0,1041,1067,3,526, + 263,0,1042,1067,3,306,153,0,1043,1067,3,428,214,0,1044,1067,3,408, + 204,0,1045,1067,3,406,203,0,1046,1067,3,410,205,0,1047,1067,3,432, + 216,0,1048,1067,3,336,168,0,1049,1067,3,350,175,0,1050,1067,3,456, + 228,0,1051,1067,3,326,163,0,1052,1067,3,560,280,0,1053,1067,3,468, + 234,0,1054,1067,3,320,160,0,1055,1067,3,466,233,0,1056,1067,3,552, + 276,0,1057,1067,3,504,252,0,1058,1067,3,60,30,0,1059,1067,3,36,18, + 0,1060,1067,3,68,34,0,1061,1067,3,476,238,0,1062,1064,5,581,0,0, + 1063,1065,5,582,0,0,1064,1063,1,0,0,0,1064,1065,1,0,0,0,1065,1067, + 1,0,0,0,1066,946,1,0,0,0,1066,947,1,0,0,0,1066,948,1,0,0,0,1066, + 949,1,0,0,0,1066,950,1,0,0,0,1066,951,1,0,0,0,1066,952,1,0,0,0,1066, + 953,1,0,0,0,1066,954,1,0,0,0,1066,955,1,0,0,0,1066,956,1,0,0,0,1066, + 957,1,0,0,0,1066,958,1,0,0,0,1066,959,1,0,0,0,1066,960,1,0,0,0,1066, + 961,1,0,0,0,1066,962,1,0,0,0,1066,963,1,0,0,0,1066,964,1,0,0,0,1066, + 965,1,0,0,0,1066,966,1,0,0,0,1066,967,1,0,0,0,1066,968,1,0,0,0,1066, + 969,1,0,0,0,1066,970,1,0,0,0,1066,971,1,0,0,0,1066,972,1,0,0,0,1066, + 973,1,0,0,0,1066,974,1,0,0,0,1066,975,1,0,0,0,1066,976,1,0,0,0,1066, + 977,1,0,0,0,1066,978,1,0,0,0,1066,979,1,0,0,0,1066,980,1,0,0,0,1066, + 981,1,0,0,0,1066,982,1,0,0,0,1066,983,1,0,0,0,1066,984,1,0,0,0,1066, + 985,1,0,0,0,1066,986,1,0,0,0,1066,987,1,0,0,0,1066,988,1,0,0,0,1066, + 989,1,0,0,0,1066,990,1,0,0,0,1066,991,1,0,0,0,1066,992,1,0,0,0,1066, + 993,1,0,0,0,1066,994,1,0,0,0,1066,995,1,0,0,0,1066,996,1,0,0,0,1066, + 997,1,0,0,0,1066,998,1,0,0,0,1066,999,1,0,0,0,1066,1000,1,0,0,0, + 1066,1001,1,0,0,0,1066,1002,1,0,0,0,1066,1003,1,0,0,0,1066,1004, + 1,0,0,0,1066,1005,1,0,0,0,1066,1006,1,0,0,0,1066,1007,1,0,0,0,1066, + 1008,1,0,0,0,1066,1009,1,0,0,0,1066,1010,1,0,0,0,1066,1011,1,0,0, + 0,1066,1012,1,0,0,0,1066,1013,1,0,0,0,1066,1014,1,0,0,0,1066,1015, + 1,0,0,0,1066,1016,1,0,0,0,1066,1017,1,0,0,0,1066,1018,1,0,0,0,1066, + 1019,1,0,0,0,1066,1020,1,0,0,0,1066,1021,1,0,0,0,1066,1022,1,0,0, + 0,1066,1023,1,0,0,0,1066,1024,1,0,0,0,1066,1025,1,0,0,0,1066,1026, + 1,0,0,0,1066,1027,1,0,0,0,1066,1028,1,0,0,0,1066,1029,1,0,0,0,1066, + 1030,1,0,0,0,1066,1031,1,0,0,0,1066,1032,1,0,0,0,1066,1033,1,0,0, + 0,1066,1034,1,0,0,0,1066,1035,1,0,0,0,1066,1036,1,0,0,0,1066,1037, + 1,0,0,0,1066,1038,1,0,0,0,1066,1039,1,0,0,0,1066,1040,1,0,0,0,1066, + 1041,1,0,0,0,1066,1042,1,0,0,0,1066,1043,1,0,0,0,1066,1044,1,0,0, + 0,1066,1045,1,0,0,0,1066,1046,1,0,0,0,1066,1047,1,0,0,0,1066,1048, + 1,0,0,0,1066,1049,1,0,0,0,1066,1050,1,0,0,0,1066,1051,1,0,0,0,1066, + 1052,1,0,0,0,1066,1053,1,0,0,0,1066,1054,1,0,0,0,1066,1055,1,0,0, + 0,1066,1056,1,0,0,0,1066,1057,1,0,0,0,1066,1058,1,0,0,0,1066,1059, + 1,0,0,0,1066,1060,1,0,0,0,1066,1061,1,0,0,0,1066,1062,1,0,0,0,1067, + 5,1,0,0,0,1068,1069,5,433,0,0,1069,1070,3,684,342,0,1070,7,1,0,0, + 0,1071,1072,5,46,0,0,1072,1073,5,318,0,0,1073,1075,3,814,407,0,1074, + 1076,5,105,0,0,1075,1074,1,0,0,0,1075,1076,1,0,0,0,1076,1080,1,0, + 0,0,1077,1079,3,12,6,0,1078,1077,1,0,0,0,1079,1082,1,0,0,0,1080, + 1078,1,0,0,0,1080,1081,1,0,0,0,1081,9,1,0,0,0,1082,1080,1,0,0,0, + 1083,1086,5,287,0,0,1084,1087,3,808,404,0,1085,1087,5,78,0,0,1086, + 1084,1,0,0,0,1086,1085,1,0,0,0,1087,1122,1,0,0,0,1088,1089,7,0,0, + 0,1089,1090,5,287,0,0,1090,1122,3,808,404,0,1091,1122,5,228,0,0, + 1092,1122,5,229,0,0,1093,1122,5,236,0,0,1094,1122,5,237,0,0,1095, + 1122,5,234,0,0,1096,1122,5,235,0,0,1097,1122,5,232,0,0,1098,1122, + 5,233,0,0,1099,1122,5,230,0,0,1100,1122,5,231,0,0,1101,1122,5,535, + 0,0,1102,1122,5,536,0,0,1103,1122,5,537,0,0,1104,1122,5,538,0,0, + 1105,1122,5,539,0,0,1106,1122,5,540,0,0,1107,1108,5,164,0,0,1108, + 1109,5,74,0,0,1109,1122,3,812,406,0,1110,1111,5,371,0,0,1111,1112, + 5,368,0,0,1112,1122,3,808,404,0,1113,1114,5,68,0,0,1114,1115,7,1, + 0,0,1115,1122,3,784,392,0,1116,1117,7,2,0,0,1117,1122,3,816,408, + 0,1118,1119,5,134,0,0,1119,1122,3,784,392,0,1120,1122,3,826,413, + 0,1121,1083,1,0,0,0,1121,1088,1,0,0,0,1121,1091,1,0,0,0,1121,1092, + 1,0,0,0,1121,1093,1,0,0,0,1121,1094,1,0,0,0,1121,1095,1,0,0,0,1121, + 1096,1,0,0,0,1121,1097,1,0,0,0,1121,1098,1,0,0,0,1121,1099,1,0,0, + 0,1121,1100,1,0,0,0,1121,1101,1,0,0,0,1121,1102,1,0,0,0,1121,1103, + 1,0,0,0,1121,1104,1,0,0,0,1121,1105,1,0,0,0,1121,1106,1,0,0,0,1121, + 1107,1,0,0,0,1121,1110,1,0,0,0,1121,1113,1,0,0,0,1121,1116,1,0,0, + 0,1121,1118,1,0,0,0,1121,1120,1,0,0,0,1122,11,1,0,0,0,1123,1132, + 3,10,5,0,1124,1125,5,348,0,0,1125,1132,5,571,0,0,1126,1127,7,3,0, + 0,1127,1132,3,816,408,0,1128,1129,5,68,0,0,1129,1130,7,1,0,0,1130, + 1132,3,816,408,0,1131,1123,1,0,0,0,1131,1124,1,0,0,0,1131,1126,1, + 0,0,0,1131,1128,1,0,0,0,1132,13,1,0,0,0,1133,1134,5,46,0,0,1134, + 1135,5,99,0,0,1135,1137,3,814,407,0,1136,1138,5,105,0,0,1137,1136, + 1,0,0,0,1137,1138,1,0,0,0,1138,1142,1,0,0,0,1139,1141,3,12,6,0,1140, + 1139,1,0,0,0,1141,1144,1,0,0,0,1142,1140,1,0,0,0,1142,1143,1,0,0, + 0,1143,15,1,0,0,0,1144,1142,1,0,0,0,1145,1146,5,138,0,0,1146,1147, + 7,2,0,0,1147,1149,3,814,407,0,1148,1150,5,105,0,0,1149,1148,1,0, + 0,0,1149,1150,1,0,0,0,1150,1154,1,0,0,0,1151,1153,3,10,5,0,1152, + 1151,1,0,0,0,1153,1156,1,0,0,0,1154,1152,1,0,0,0,1154,1155,1,0,0, + 0,1155,17,1,0,0,0,1156,1154,1,0,0,0,1157,1158,5,138,0,0,1158,1161, + 7,2,0,0,1159,1162,5,30,0,0,1160,1162,3,814,407,0,1161,1159,1,0,0, + 0,1161,1160,1,0,0,0,1162,1163,1,0,0,0,1163,1164,5,68,0,0,1164,1165, + 5,175,0,0,1165,1166,3,788,394,0,1166,1167,3,64,32,0,1167,19,1,0, + 0,0,1168,1169,5,138,0,0,1169,1170,5,442,0,0,1170,1172,3,794,397, + 0,1171,1173,3,368,184,0,1172,1171,1,0,0,0,1172,1173,1,0,0,0,1173, + 1174,1,0,0,0,1174,1175,3,22,11,0,1175,21,1,0,0,0,1176,1180,3,24, + 12,0,1177,1179,3,24,12,0,1178,1177,1,0,0,0,1179,1182,1,0,0,0,1180, + 1178,1,0,0,0,1180,1181,1,0,0,0,1181,1184,1,0,0,0,1182,1180,1,0,0, + 0,1183,1185,5,315,0,0,1184,1183,1,0,0,0,1184,1185,1,0,0,0,1185,1203, + 1,0,0,0,1186,1187,5,309,0,0,1187,1188,5,94,0,0,1188,1203,3,792,396, + 0,1189,1190,5,282,0,0,1190,1191,5,94,0,0,1191,1203,3,814,407,0,1192, + 1193,5,333,0,0,1193,1194,5,323,0,0,1194,1203,3,32,16,0,1195,1197, + 5,269,0,0,1196,1195,1,0,0,0,1196,1197,1,0,0,0,1197,1198,1,0,0,0, + 1198,1199,5,462,0,0,1199,1200,5,80,0,0,1200,1201,5,204,0,0,1201, + 1203,3,818,409,0,1202,1176,1,0,0,0,1202,1186,1,0,0,0,1202,1189,1, + 0,0,0,1202,1192,1,0,0,0,1202,1196,1,0,0,0,1203,23,1,0,0,0,1204,1247, + 5,222,0,0,1205,1247,5,338,0,0,1206,1247,5,377,0,0,1207,1209,5,77, + 0,0,1208,1207,1,0,0,0,1208,1209,1,0,0,0,1209,1210,1,0,0,0,1210,1247, + 5,250,0,0,1211,1213,5,205,0,0,1212,1211,1,0,0,0,1212,1213,1,0,0, + 0,1213,1214,1,0,0,0,1214,1215,5,327,0,0,1215,1222,5,243,0,0,1216, + 1218,5,205,0,0,1217,1216,1,0,0,0,1217,1218,1,0,0,0,1218,1219,1,0, + 0,0,1219,1220,5,327,0,0,1220,1222,5,181,0,0,1221,1212,1,0,0,0,1221, + 1217,1,0,0,0,1222,1247,1,0,0,0,1223,1224,5,460,0,0,1224,1247,7,4, + 0,0,1225,1226,5,170,0,0,1226,1247,3,824,412,0,1227,1228,5,320,0, + 0,1228,1247,3,818,409,0,1229,1230,5,333,0,0,1230,1231,3,818,409, + 0,1231,1234,7,5,0,0,1232,1235,3,818,409,0,1233,1235,5,53,0,0,1234, + 1232,1,0,0,0,1234,1233,1,0,0,0,1235,1247,1,0,0,0,1236,1237,5,333, + 0,0,1237,1238,3,818,409,0,1238,1239,5,64,0,0,1239,1240,5,434,0,0, + 1240,1247,1,0,0,0,1241,1244,5,313,0,0,1242,1245,3,818,409,0,1243, + 1245,5,30,0,0,1244,1242,1,0,0,0,1244,1243,1,0,0,0,1245,1247,1,0, + 0,0,1246,1204,1,0,0,0,1246,1205,1,0,0,0,1246,1206,1,0,0,0,1246,1208, + 1,0,0,0,1246,1221,1,0,0,0,1246,1223,1,0,0,0,1246,1225,1,0,0,0,1246, + 1227,1,0,0,0,1246,1229,1,0,0,0,1246,1236,1,0,0,0,1246,1241,1,0,0, + 0,1247,25,1,0,0,0,1248,1249,5,46,0,0,1249,1250,5,66,0,0,1250,1252, + 3,814,407,0,1251,1253,5,105,0,0,1252,1251,1,0,0,0,1252,1253,1,0, + 0,0,1253,1257,1,0,0,0,1254,1256,3,12,6,0,1255,1254,1,0,0,0,1256, + 1259,1,0,0,0,1257,1255,1,0,0,0,1257,1258,1,0,0,0,1258,27,1,0,0,0, + 1259,1257,1,0,0,0,1260,1261,5,138,0,0,1261,1262,5,66,0,0,1262,1263, + 3,814,407,0,1263,1264,7,6,0,0,1264,1265,5,99,0,0,1265,1266,3,816, + 408,0,1266,29,1,0,0,0,1267,1268,5,46,0,0,1268,1270,5,323,0,0,1269, + 1271,3,294,147,0,1270,1269,1,0,0,0,1270,1271,1,0,0,0,1271,1278,1, + 0,0,0,1272,1274,3,32,16,0,1273,1272,1,0,0,0,1273,1274,1,0,0,0,1274, + 1275,1,0,0,0,1275,1276,5,106,0,0,1276,1279,3,814,407,0,1277,1279, + 3,32,16,0,1278,1273,1,0,0,0,1278,1277,1,0,0,0,1279,1283,1,0,0,0, + 1280,1282,3,34,17,0,1281,1280,1,0,0,0,1282,1285,1,0,0,0,1283,1281, + 1,0,0,0,1283,1284,1,0,0,0,1284,31,1,0,0,0,1285,1283,1,0,0,0,1286, + 1287,3,316,158,0,1287,33,1,0,0,0,1288,1295,3,120,60,0,1289,1295, + 3,358,179,0,1290,1295,3,196,98,0,1291,1295,3,256,128,0,1292,1295, + 3,334,167,0,1293,1295,3,476,238,0,1294,1288,1,0,0,0,1294,1289,1, + 0,0,0,1294,1290,1,0,0,0,1294,1291,1,0,0,0,1294,1292,1,0,0,0,1294, + 1293,1,0,0,0,1295,35,1,0,0,0,1296,1298,5,333,0,0,1297,1299,7,7,0, + 0,1298,1297,1,0,0,0,1298,1299,1,0,0,0,1299,1300,1,0,0,0,1300,1301, + 3,38,19,0,1301,37,1,0,0,0,1302,1303,5,356,0,0,1303,1311,3,474,237, + 0,1304,1305,5,332,0,0,1305,1306,5,154,0,0,1306,1307,5,36,0,0,1307, + 1308,5,356,0,0,1308,1311,3,474,237,0,1309,1311,3,42,21,0,1310,1302, + 1,0,0,0,1310,1304,1,0,0,0,1310,1309,1,0,0,0,1311,39,1,0,0,0,1312, + 1315,5,30,0,0,1313,1315,3,44,22,0,1314,1312,1,0,0,0,1314,1313,1, + 0,0,0,1315,1317,1,0,0,0,1316,1318,7,5,0,0,1317,1316,1,0,0,0,1317, + 1318,1,0,0,0,1318,1321,1,0,0,0,1319,1322,5,53,0,0,1320,1322,3,46, + 23,0,1321,1319,1,0,0,0,1321,1320,1,0,0,0,1321,1322,1,0,0,0,1322, + 41,1,0,0,0,1323,1324,5,418,0,0,1324,1325,5,386,0,0,1325,1352,3,56, + 28,0,1326,1327,5,152,0,0,1327,1352,3,808,404,0,1328,1329,5,323,0, + 0,1329,1352,3,790,395,0,1330,1333,5,267,0,0,1331,1334,3,808,404, + 0,1332,1334,5,53,0,0,1333,1331,1,0,0,0,1333,1332,1,0,0,0,1333,1334, + 1,0,0,0,1334,1352,1,0,0,0,1335,1336,5,318,0,0,1336,1352,3,58,29, + 0,1337,1338,5,332,0,0,1338,1339,5,106,0,0,1339,1352,3,58,29,0,1340, + 1341,5,383,0,0,1341,1342,5,279,0,0,1342,1352,3,696,348,0,1343,1344, + 5,356,0,0,1344,1345,5,337,0,0,1345,1352,3,808,404,0,1346,1347,3, + 44,22,0,1347,1348,5,64,0,0,1348,1349,5,434,0,0,1349,1352,1,0,0,0, + 1350,1352,3,40,20,0,1351,1323,1,0,0,0,1351,1326,1,0,0,0,1351,1328, + 1,0,0,0,1351,1330,1,0,0,0,1351,1335,1,0,0,0,1351,1337,1,0,0,0,1351, + 1340,1,0,0,0,1351,1343,1,0,0,0,1351,1346,1,0,0,0,1351,1350,1,0,0, + 0,1352,43,1,0,0,0,1353,1358,3,818,409,0,1354,1355,5,11,0,0,1355, + 1357,3,818,409,0,1356,1354,1,0,0,0,1357,1360,1,0,0,0,1358,1356,1, + 0,0,0,1358,1359,1,0,0,0,1359,45,1,0,0,0,1360,1358,1,0,0,0,1361,1366, + 3,48,24,0,1362,1363,5,6,0,0,1363,1365,3,48,24,0,1364,1362,1,0,0, + 0,1365,1368,1,0,0,0,1366,1364,1,0,0,0,1366,1367,1,0,0,0,1367,47, + 1,0,0,0,1368,1366,1,0,0,0,1369,1372,3,54,27,0,1370,1372,3,202,101, + 0,1371,1369,1,0,0,0,1371,1370,1,0,0,0,1372,49,1,0,0,0,1373,1374, + 5,300,0,0,1374,1379,7,8,0,0,1375,1376,5,310,0,0,1376,1379,5,300, + 0,0,1377,1379,5,330,0,0,1378,1373,1,0,0,0,1378,1375,1,0,0,0,1378, + 1377,1,0,0,0,1379,51,1,0,0,0,1380,1387,5,96,0,0,1381,1387,5,60,0, + 0,1382,1387,5,80,0,0,1383,1387,3,800,400,0,1384,1387,3,832,416,0, + 1385,1387,3,808,404,0,1386,1380,1,0,0,0,1386,1381,1,0,0,0,1386,1382, + 1,0,0,0,1386,1383,1,0,0,0,1386,1384,1,0,0,0,1386,1385,1,0,0,0,1387, + 53,1,0,0,0,1388,1393,5,96,0,0,1389,1393,5,60,0,0,1390,1393,5,80, + 0,0,1391,1393,3,58,29,0,1392,1388,1,0,0,0,1392,1389,1,0,0,0,1392, + 1390,1,0,0,0,1392,1391,1,0,0,0,1393,55,1,0,0,0,1394,1409,3,808,404, + 0,1395,1409,5,53,0,0,1396,1409,3,826,413,0,1397,1398,5,403,0,0,1398, + 1400,3,808,404,0,1399,1401,3,668,334,0,1400,1399,1,0,0,0,1400,1401, + 1,0,0,0,1401,1409,1,0,0,0,1402,1403,5,403,0,0,1403,1404,3,660,330, + 0,1404,1405,3,808,404,0,1405,1409,1,0,0,0,1406,1409,3,202,101,0, + 1407,1409,5,254,0,0,1408,1394,1,0,0,0,1408,1395,1,0,0,0,1408,1396, + 1,0,0,0,1408,1397,1,0,0,0,1408,1402,1,0,0,0,1408,1406,1,0,0,0,1408, + 1407,1,0,0,0,1409,57,1,0,0,0,1410,1413,3,822,411,0,1411,1413,3,808, + 404,0,1412,1410,1,0,0,0,1412,1411,1,0,0,0,1413,59,1,0,0,0,1414,1415, + 5,313,0,0,1415,1416,3,62,31,0,1416,61,1,0,0,0,1417,1418,5,418,0, + 0,1418,1427,5,386,0,0,1419,1420,5,356,0,0,1420,1421,5,244,0,0,1421, + 1427,5,251,0,0,1422,1423,5,332,0,0,1423,1427,5,106,0,0,1424,1427, + 5,30,0,0,1425,1427,3,44,22,0,1426,1417,1,0,0,0,1426,1419,1,0,0,0, + 1426,1422,1,0,0,0,1426,1424,1,0,0,0,1426,1425,1,0,0,0,1427,63,1, + 0,0,0,1428,1429,5,333,0,0,1429,1432,3,38,19,0,1430,1432,3,60,30, + 0,1431,1428,1,0,0,0,1431,1430,1,0,0,0,1432,65,1,0,0,0,1433,1434, + 5,333,0,0,1434,1437,3,42,21,0,1435,1437,3,60,30,0,1436,1433,1,0, + 0,0,1436,1435,1,0,0,0,1437,67,1,0,0,0,1438,1448,5,335,0,0,1439,1449, + 3,44,22,0,1440,1441,5,418,0,0,1441,1449,5,386,0,0,1442,1443,5,356, + 0,0,1443,1444,5,244,0,0,1444,1449,5,251,0,0,1445,1446,5,332,0,0, + 1446,1449,5,106,0,0,1447,1449,5,30,0,0,1448,1439,1,0,0,0,1448,1440, + 1,0,0,0,1448,1442,1,0,0,0,1448,1445,1,0,0,0,1448,1447,1,0,0,0,1449, + 69,1,0,0,0,1450,1451,5,333,0,0,1451,1454,5,165,0,0,1452,1455,5,30, + 0,0,1453,1455,3,760,380,0,1454,1452,1,0,0,0,1454,1453,1,0,0,0,1455, + 1456,1,0,0,0,1456,1457,7,9,0,0,1457,71,1,0,0,0,1458,1459,5,155,0, + 0,1459,73,1,0,0,0,1460,1461,5,187,0,0,1461,1462,7,10,0,0,1462,75, + 1,0,0,0,1463,1464,5,138,0,0,1464,1466,5,92,0,0,1465,1467,3,422,211, + 0,1466,1465,1,0,0,0,1466,1467,1,0,0,0,1467,1468,1,0,0,0,1468,1471, + 3,624,312,0,1469,1472,3,78,39,0,1470,1472,3,88,44,0,1471,1469,1, + 0,0,0,1471,1470,1,0,0,0,1472,1585,1,0,0,0,1473,1474,5,138,0,0,1474, + 1475,5,92,0,0,1475,1476,5,30,0,0,1476,1477,5,68,0,0,1477,1481,3, + 176,88,0,1478,1479,5,281,0,0,1479,1480,5,147,0,0,1480,1482,3,816, + 408,0,1481,1478,1,0,0,0,1481,1482,1,0,0,0,1482,1483,1,0,0,0,1483, + 1484,5,333,0,0,1484,1485,5,351,0,0,1485,1487,3,768,384,0,1486,1488, + 5,272,0,0,1487,1486,1,0,0,0,1487,1488,1,0,0,0,1488,1585,1,0,0,0, + 1489,1490,5,138,0,0,1490,1492,5,92,0,0,1491,1493,3,422,211,0,1492, + 1491,1,0,0,0,1492,1493,1,0,0,0,1493,1494,1,0,0,0,1494,1495,3,774, + 387,0,1495,1500,3,90,45,0,1496,1497,5,62,0,0,1497,1498,5,422,0,0, + 1498,1501,3,80,40,0,1499,1501,5,53,0,0,1500,1496,1,0,0,0,1500,1499, + 1,0,0,0,1501,1585,1,0,0,0,1502,1503,5,138,0,0,1503,1505,5,92,0,0, + 1504,1506,3,422,211,0,1505,1504,1,0,0,0,1505,1506,1,0,0,0,1506,1507, + 1,0,0,0,1507,1508,3,774,387,0,1508,1509,5,436,0,0,1509,1510,5,285, + 0,0,1510,1512,3,780,390,0,1511,1513,7,11,0,0,1512,1511,1,0,0,0,1512, + 1513,1,0,0,0,1513,1585,1,0,0,0,1514,1515,5,138,0,0,1515,1517,5,226, + 0,0,1516,1518,3,422,211,0,1517,1516,1,0,0,0,1517,1518,1,0,0,0,1518, + 1519,1,0,0,0,1519,1522,3,780,390,0,1520,1523,3,78,39,0,1521,1523, + 3,90,45,0,1522,1520,1,0,0,0,1522,1521,1,0,0,0,1523,1585,1,0,0,0, + 1524,1525,5,138,0,0,1525,1526,5,226,0,0,1526,1527,5,30,0,0,1527, + 1528,5,68,0,0,1528,1532,3,176,88,0,1529,1530,5,281,0,0,1530,1531, + 5,147,0,0,1531,1533,3,816,408,0,1532,1529,1,0,0,0,1532,1533,1,0, + 0,0,1533,1534,1,0,0,0,1534,1535,5,333,0,0,1535,1537,3,176,88,0,1536, + 1538,5,272,0,0,1537,1536,1,0,0,0,1537,1538,1,0,0,0,1538,1585,1,0, + 0,0,1539,1540,5,138,0,0,1540,1542,5,328,0,0,1541,1543,3,422,211, + 0,1542,1541,1,0,0,0,1542,1543,1,0,0,0,1543,1544,1,0,0,0,1544,1545, + 3,780,390,0,1545,1546,3,78,39,0,1546,1585,1,0,0,0,1547,1549,5,138, + 0,0,1548,1550,5,259,0,0,1549,1548,1,0,0,0,1549,1550,1,0,0,0,1550, + 1551,1,0,0,0,1551,1553,5,376,0,0,1552,1554,3,422,211,0,1553,1552, + 1,0,0,0,1553,1554,1,0,0,0,1554,1555,1,0,0,0,1555,1556,3,778,389, + 0,1556,1557,3,78,39,0,1557,1585,1,0,0,0,1558,1559,5,138,0,0,1559, + 1560,5,259,0,0,1560,1561,5,376,0,0,1561,1562,5,30,0,0,1562,1563, + 5,68,0,0,1563,1567,3,176,88,0,1564,1565,5,281,0,0,1565,1566,5,147, + 0,0,1566,1568,3,816,408,0,1567,1564,1,0,0,0,1567,1568,1,0,0,0,1568, + 1569,1,0,0,0,1569,1570,5,333,0,0,1570,1571,5,351,0,0,1571,1573,3, + 768,384,0,1572,1574,5,272,0,0,1573,1572,1,0,0,0,1573,1574,1,0,0, + 0,1574,1585,1,0,0,0,1575,1576,5,138,0,0,1576,1577,5,63,0,0,1577, + 1579,5,92,0,0,1578,1580,3,422,211,0,1579,1578,1,0,0,0,1579,1580, + 1,0,0,0,1580,1581,1,0,0,0,1581,1582,3,624,312,0,1582,1583,3,78,39, + 0,1583,1585,1,0,0,0,1584,1463,1,0,0,0,1584,1473,1,0,0,0,1584,1489, + 1,0,0,0,1584,1502,1,0,0,0,1584,1514,1,0,0,0,1584,1524,1,0,0,0,1584, + 1539,1,0,0,0,1584,1547,1,0,0,0,1584,1558,1,0,0,0,1584,1575,1,0,0, + 0,1585,77,1,0,0,0,1586,1591,3,92,46,0,1587,1588,5,6,0,0,1588,1590, + 3,92,46,0,1589,1587,1,0,0,0,1590,1593,1,0,0,0,1591,1589,1,0,0,0, + 1591,1592,1,0,0,0,1592,79,1,0,0,0,1593,1591,1,0,0,0,1594,1595,5, + 68,0,0,1595,1604,3,534,267,0,1596,1597,5,64,0,0,1597,1598,3,82,41, + 0,1598,1599,5,94,0,0,1599,1600,3,82,41,0,1600,1604,1,0,0,0,1601, + 1602,5,105,0,0,1602,1604,3,86,43,0,1603,1594,1,0,0,0,1603,1596,1, + 0,0,0,1603,1601,1,0,0,0,1604,81,1,0,0,0,1605,1606,5,2,0,0,1606,1611, + 3,84,42,0,1607,1608,5,6,0,0,1608,1610,3,84,42,0,1609,1607,1,0,0, + 0,1610,1613,1,0,0,0,1611,1609,1,0,0,0,1611,1612,1,0,0,0,1612,1614, + 1,0,0,0,1613,1611,1,0,0,0,1614,1615,5,3,0,0,1615,83,1,0,0,0,1616, + 1620,3,534,267,0,1617,1620,5,262,0,0,1618,1620,5,260,0,0,1619,1616, + 1,0,0,0,1619,1617,1,0,0,0,1619,1618,1,0,0,0,1620,85,1,0,0,0,1621, + 1622,5,2,0,0,1622,1623,5,533,0,0,1623,1624,3,202,101,0,1624,1625, + 5,6,0,0,1625,1626,5,534,0,0,1626,1627,3,202,101,0,1627,1628,5,3, + 0,0,1628,87,1,0,0,0,1629,1630,3,90,45,0,1630,1631,3,106,53,0,1631, + 1636,1,0,0,0,1632,1633,5,436,0,0,1633,1634,5,285,0,0,1634,1636,3, + 780,390,0,1635,1629,1,0,0,0,1635,1632,1,0,0,0,1636,89,1,0,0,0,1637, + 1638,5,435,0,0,1638,1639,5,285,0,0,1639,1640,3,780,390,0,1640,91, + 1,0,0,0,1641,1644,5,133,0,0,1642,1643,5,45,0,0,1643,1645,3,818,409, + 0,1644,1642,1,0,0,0,1644,1645,1,0,0,0,1645,1646,1,0,0,0,1646,1875, + 3,142,71,0,1647,1648,5,138,0,0,1648,1649,5,45,0,0,1649,1653,3,818, + 409,0,1650,1652,3,272,136,0,1651,1650,1,0,0,0,1652,1655,1,0,0,0, + 1653,1651,1,0,0,0,1653,1654,1,0,0,0,1654,1875,1,0,0,0,1655,1653, + 1,0,0,0,1656,1657,5,372,0,0,1657,1658,5,45,0,0,1658,1875,3,818,409, + 0,1659,1660,5,191,0,0,1660,1662,5,45,0,0,1661,1663,3,422,211,0,1662, + 1661,1,0,0,0,1662,1663,1,0,0,0,1663,1664,1,0,0,0,1664,1666,3,818, + 409,0,1665,1667,3,96,48,0,1666,1665,1,0,0,0,1666,1667,1,0,0,0,1667, + 1875,1,0,0,0,1668,1669,5,333,0,0,1669,1670,5,379,0,0,1670,1875,7, + 12,0,0,1671,1672,5,158,0,0,1672,1673,5,80,0,0,1673,1875,3,818,409, + 0,1674,1675,5,333,0,0,1675,1875,7,13,0,0,1676,1678,5,193,0,0,1677, + 1679,7,14,0,0,1678,1677,1,0,0,0,1678,1679,1,0,0,0,1679,1680,1,0, + 0,0,1680,1875,5,357,0,0,1681,1682,5,186,0,0,1682,1686,5,357,0,0, + 1683,1687,5,30,0,0,1684,1687,5,99,0,0,1685,1687,3,818,409,0,1686, + 1683,1,0,0,0,1686,1684,1,0,0,0,1686,1685,1,0,0,0,1687,1875,1,0,0, + 0,1688,1689,5,193,0,0,1689,1690,7,14,0,0,1690,1691,5,321,0,0,1691, + 1875,3,818,409,0,1692,1693,5,186,0,0,1693,1694,5,321,0,0,1694,1875, + 3,818,409,0,1695,1697,5,269,0,0,1696,1695,1,0,0,0,1696,1697,1,0, + 0,0,1697,1698,1,0,0,0,1698,1699,5,228,0,0,1699,1875,3,780,390,0, + 1700,1701,5,275,0,0,1701,1875,3,316,158,0,1702,1703,5,77,0,0,1703, + 1875,5,275,0,0,1704,1705,5,282,0,0,1705,1706,5,94,0,0,1706,1875, + 3,814,407,0,1707,1708,5,333,0,0,1708,1709,5,351,0,0,1709,1875,3, + 768,384,0,1710,1711,5,312,0,0,1711,1716,5,219,0,0,1712,1717,5,270, + 0,0,1713,1717,5,113,0,0,1714,1717,5,53,0,0,1715,1717,3,180,90,0, + 1716,1712,1,0,0,0,1716,1713,1,0,0,0,1716,1714,1,0,0,0,1716,1715, + 1,0,0,0,1717,1875,1,0,0,0,1718,1725,5,193,0,0,1719,1725,5,186,0, + 0,1720,1722,5,269,0,0,1721,1720,1,0,0,0,1721,1722,1,0,0,0,1722,1723, + 1,0,0,0,1723,1725,5,209,0,0,1724,1718,1,0,0,0,1724,1719,1,0,0,0, + 1724,1721,1,0,0,0,1725,1726,1,0,0,0,1726,1727,5,414,0,0,1727,1728, + 5,251,0,0,1728,1875,5,327,0,0,1729,1731,5,191,0,0,1730,1732,5,44, + 0,0,1731,1730,1,0,0,0,1731,1732,1,0,0,0,1732,1734,1,0,0,0,1733,1735, + 3,422,211,0,1734,1733,1,0,0,0,1734,1735,1,0,0,0,1735,1736,1,0,0, + 0,1736,1738,3,800,400,0,1737,1739,3,96,48,0,1738,1737,1,0,0,0,1738, + 1739,1,0,0,0,1739,1875,1,0,0,0,1740,1742,5,133,0,0,1741,1743,5,44, + 0,0,1742,1741,1,0,0,0,1742,1743,1,0,0,0,1743,1745,1,0,0,0,1744,1746, + 3,294,147,0,1745,1744,1,0,0,0,1745,1746,1,0,0,0,1746,1747,1,0,0, + 0,1747,1875,3,132,66,0,1748,1750,5,138,0,0,1749,1751,5,44,0,0,1750, + 1749,1,0,0,0,1750,1751,1,0,0,0,1751,1752,1,0,0,0,1752,1755,3,800, + 400,0,1753,1756,3,94,47,0,1754,1756,3,222,111,0,1755,1753,1,0,0, + 0,1755,1754,1,0,0,0,1756,1875,1,0,0,0,1757,1759,5,138,0,0,1758,1760, + 5,44,0,0,1759,1758,1,0,0,0,1759,1760,1,0,0,0,1760,1761,1,0,0,0,1761, + 1762,3,800,400,0,1762,1763,7,15,0,0,1763,1764,5,77,0,0,1764,1765, + 5,78,0,0,1765,1875,1,0,0,0,1766,1768,5,138,0,0,1767,1769,5,44,0, + 0,1768,1767,1,0,0,0,1768,1769,1,0,0,0,1769,1770,1,0,0,0,1770,1771, + 3,800,400,0,1771,1772,5,191,0,0,1772,1774,5,437,0,0,1773,1775,3, + 422,211,0,1774,1773,1,0,0,0,1774,1775,1,0,0,0,1775,1875,1,0,0,0, + 1776,1778,5,138,0,0,1777,1779,5,44,0,0,1778,1777,1,0,0,0,1778,1779, + 1,0,0,0,1779,1780,1,0,0,0,1780,1781,3,800,400,0,1781,1782,5,333, + 0,0,1782,1783,5,342,0,0,1783,1784,3,812,406,0,1784,1875,1,0,0,0, + 1785,1787,5,138,0,0,1786,1788,5,44,0,0,1787,1786,1,0,0,0,1787,1788, + 1,0,0,0,1788,1789,1,0,0,0,1789,1791,3,800,400,0,1790,1785,1,0,0, + 0,1790,1791,1,0,0,0,1791,1792,1,0,0,0,1792,1793,7,16,0,0,1793,1875, + 3,100,50,0,1794,1796,5,138,0,0,1795,1797,5,44,0,0,1796,1795,1,0, + 0,0,1796,1797,1,0,0,0,1797,1798,1,0,0,0,1798,1799,3,800,400,0,1799, + 1800,5,333,0,0,1800,1801,5,345,0,0,1801,1802,3,818,409,0,1802,1875, + 1,0,0,0,1803,1805,5,138,0,0,1804,1806,5,44,0,0,1805,1804,1,0,0,0, + 1805,1806,1,0,0,0,1806,1807,1,0,0,0,1807,1808,3,800,400,0,1808,1809, + 5,133,0,0,1809,1810,5,438,0,0,1810,1811,3,138,69,0,1811,1812,5,36, + 0,0,1812,1821,5,219,0,0,1813,1815,5,2,0,0,1814,1816,3,200,100,0, + 1815,1814,1,0,0,0,1816,1817,1,0,0,0,1817,1815,1,0,0,0,1817,1818, + 1,0,0,0,1818,1819,1,0,0,0,1819,1820,5,3,0,0,1820,1822,1,0,0,0,1821, + 1813,1,0,0,0,1821,1822,1,0,0,0,1822,1875,1,0,0,0,1823,1825,5,138, + 0,0,1824,1826,5,44,0,0,1825,1824,1,0,0,0,1825,1826,1,0,0,0,1826, + 1827,1,0,0,0,1827,1841,3,800,400,0,1828,1833,5,314,0,0,1829,1831, + 5,105,0,0,1830,1829,1,0,0,0,1830,1831,1,0,0,0,1831,1832,1,0,0,0, + 1832,1834,3,202,101,0,1833,1830,1,0,0,0,1833,1834,1,0,0,0,1834,1842, + 1,0,0,0,1835,1839,5,333,0,0,1836,1840,3,200,100,0,1837,1838,5,438, + 0,0,1838,1840,3,138,69,0,1839,1836,1,0,0,0,1839,1837,1,0,0,0,1840, + 1842,1,0,0,0,1841,1828,1,0,0,0,1841,1835,1,0,0,0,1842,1843,1,0,0, + 0,1843,1841,1,0,0,0,1843,1844,1,0,0,0,1844,1875,1,0,0,0,1845,1847, + 5,138,0,0,1846,1848,5,44,0,0,1847,1846,1,0,0,0,1847,1848,1,0,0,0, + 1848,1849,1,0,0,0,1849,1850,3,800,400,0,1850,1851,5,191,0,0,1851, + 1853,5,219,0,0,1852,1854,3,422,211,0,1853,1852,1,0,0,0,1853,1854, + 1,0,0,0,1854,1875,1,0,0,0,1855,1857,5,138,0,0,1856,1858,5,44,0,0, + 1857,1856,1,0,0,0,1857,1858,1,0,0,0,1858,1859,1,0,0,0,1859,1862, + 3,800,400,0,1860,1861,5,333,0,0,1861,1863,5,174,0,0,1862,1860,1, + 0,0,0,1862,1863,1,0,0,0,1863,1864,1,0,0,0,1864,1865,5,360,0,0,1865, + 1867,3,652,326,0,1866,1868,3,98,49,0,1867,1866,1,0,0,0,1867,1868, + 1,0,0,0,1868,1871,1,0,0,0,1869,1870,5,100,0,0,1870,1872,3,674,337, + 0,1871,1869,1,0,0,0,1871,1872,1,0,0,0,1872,1875,1,0,0,0,1873,1875, + 3,222,111,0,1874,1641,1,0,0,0,1874,1647,1,0,0,0,1874,1656,1,0,0, + 0,1874,1659,1,0,0,0,1874,1668,1,0,0,0,1874,1671,1,0,0,0,1874,1674, + 1,0,0,0,1874,1676,1,0,0,0,1874,1681,1,0,0,0,1874,1688,1,0,0,0,1874, + 1692,1,0,0,0,1874,1696,1,0,0,0,1874,1700,1,0,0,0,1874,1702,1,0,0, + 0,1874,1704,1,0,0,0,1874,1707,1,0,0,0,1874,1710,1,0,0,0,1874,1724, + 1,0,0,0,1874,1729,1,0,0,0,1874,1740,1,0,0,0,1874,1748,1,0,0,0,1874, + 1757,1,0,0,0,1874,1766,1,0,0,0,1874,1776,1,0,0,0,1874,1790,1,0,0, + 0,1874,1794,1,0,0,0,1874,1803,1,0,0,0,1874,1823,1,0,0,0,1874,1845, + 1,0,0,0,1874,1855,1,0,0,0,1874,1873,1,0,0,0,1875,93,1,0,0,0,1876, + 1877,5,333,0,0,1877,1878,5,53,0,0,1878,1882,3,674,337,0,1879,1880, + 5,191,0,0,1880,1882,5,53,0,0,1881,1876,1,0,0,0,1881,1879,1,0,0,0, + 1882,95,1,0,0,0,1883,1884,7,17,0,0,1884,97,1,0,0,0,1885,1886,5,43, + 0,0,1886,1887,3,316,158,0,1887,99,1,0,0,0,1888,1889,5,2,0,0,1889, + 1894,3,104,52,0,1890,1891,5,6,0,0,1891,1893,3,104,52,0,1892,1890, + 1,0,0,0,1893,1896,1,0,0,0,1894,1892,1,0,0,0,1894,1895,1,0,0,0,1895, + 1897,1,0,0,0,1896,1894,1,0,0,0,1897,1898,5,3,0,0,1898,101,1,0,0, + 0,1899,1900,5,105,0,0,1900,1901,3,100,50,0,1901,103,1,0,0,0,1902, + 1907,3,824,412,0,1903,1904,5,10,0,0,1904,1908,3,288,144,0,1905,1906, + 5,11,0,0,1906,1908,3,286,143,0,1907,1903,1,0,0,0,1907,1905,1,0,0, + 0,1907,1908,1,0,0,0,1908,105,1,0,0,0,1909,1910,5,62,0,0,1910,1911, + 5,422,0,0,1911,1912,5,105,0,0,1912,1913,5,2,0,0,1913,1914,3,822, + 411,0,1914,1921,5,571,0,0,1915,1916,5,6,0,0,1916,1917,3,822,411, + 0,1917,1918,5,571,0,0,1918,1920,1,0,0,0,1919,1915,1,0,0,0,1920,1923, + 1,0,0,0,1921,1919,1,0,0,0,1921,1922,1,0,0,0,1922,1924,1,0,0,0,1923, + 1921,1,0,0,0,1924,1925,5,3,0,0,1925,1939,1,0,0,0,1926,1927,5,62, + 0,0,1927,1928,5,422,0,0,1928,1929,5,68,0,0,1929,1939,3,534,267,0, + 1930,1931,5,62,0,0,1931,1932,5,422,0,0,1932,1933,5,64,0,0,1933,1934, + 3,534,267,0,1934,1935,5,94,0,0,1935,1936,3,534,267,0,1936,1939,1, + 0,0,0,1937,1939,5,53,0,0,1938,1909,1,0,0,0,1938,1926,1,0,0,0,1938, + 1930,1,0,0,0,1938,1937,1,0,0,0,1939,107,1,0,0,0,1940,1941,5,138, + 0,0,1941,1942,5,360,0,0,1942,1943,3,316,158,0,1943,1948,3,110,55, + 0,1944,1945,5,6,0,0,1945,1947,3,110,55,0,1946,1944,1,0,0,0,1947, + 1950,1,0,0,0,1948,1946,1,0,0,0,1948,1949,1,0,0,0,1949,109,1,0,0, + 0,1950,1948,1,0,0,0,1951,1952,5,133,0,0,1952,1953,5,143,0,0,1953, + 1955,3,644,322,0,1954,1956,3,96,48,0,1955,1954,1,0,0,0,1955,1956, + 1,0,0,0,1956,1982,1,0,0,0,1957,1958,5,191,0,0,1958,1960,5,143,0, + 0,1959,1961,3,422,211,0,1960,1959,1,0,0,0,1960,1961,1,0,0,0,1961, + 1962,1,0,0,0,1962,1964,3,818,409,0,1963,1965,3,96,48,0,1964,1963, + 1,0,0,0,1964,1965,1,0,0,0,1965,1982,1,0,0,0,1966,1967,5,138,0,0, + 1967,1968,5,143,0,0,1968,1971,3,818,409,0,1969,1970,5,333,0,0,1970, + 1972,5,174,0,0,1971,1969,1,0,0,0,1971,1972,1,0,0,0,1972,1973,1,0, + 0,0,1973,1974,5,360,0,0,1974,1976,3,652,326,0,1975,1977,3,98,49, + 0,1976,1975,1,0,0,0,1976,1977,1,0,0,0,1977,1979,1,0,0,0,1978,1980, + 3,96,48,0,1979,1978,1,0,0,0,1979,1980,1,0,0,0,1980,1982,1,0,0,0, + 1981,1951,1,0,0,0,1981,1957,1,0,0,0,1981,1966,1,0,0,0,1982,111,1, + 0,0,0,1983,1986,5,157,0,0,1984,1987,3,818,409,0,1985,1987,5,30,0, + 0,1986,1984,1,0,0,0,1986,1985,1,0,0,0,1987,113,1,0,0,0,1988,1990, + 5,169,0,0,1989,1991,5,107,0,0,1990,1989,1,0,0,0,1990,1991,1,0,0, + 0,1991,1992,1,0,0,0,1992,1994,3,774,387,0,1993,1995,3,144,72,0,1994, + 1993,1,0,0,0,1994,1995,1,0,0,0,1995,1996,1,0,0,0,1996,1998,7,18, + 0,0,1997,1999,5,297,0,0,1998,1997,1,0,0,0,1998,1999,1,0,0,0,1999, + 2003,1,0,0,0,2000,2004,3,808,404,0,2001,2004,5,343,0,0,2002,2004, + 5,344,0,0,2003,2000,1,0,0,0,2003,2001,1,0,0,0,2003,2002,1,0,0,0, + 2004,2010,1,0,0,0,2005,2007,5,100,0,0,2006,2005,1,0,0,0,2006,2007, + 1,0,0,0,2007,2008,1,0,0,0,2008,2009,5,184,0,0,2009,2011,3,808,404, + 0,2010,2006,1,0,0,0,2010,2011,1,0,0,0,2011,2013,1,0,0,0,2012,2014, + 5,105,0,0,2013,2012,1,0,0,0,2013,2014,1,0,0,0,2014,2015,1,0,0,0, + 2015,2017,3,116,58,0,2016,2018,3,638,319,0,2017,2016,1,0,0,0,2017, + 2018,1,0,0,0,2018,2038,1,0,0,0,2019,2020,5,169,0,0,2020,2021,5,2, + 0,0,2021,2022,3,530,265,0,2022,2023,5,3,0,0,2023,2025,5,94,0,0,2024, + 2026,5,297,0,0,2025,2024,1,0,0,0,2025,2026,1,0,0,0,2026,2030,1,0, + 0,0,2027,2031,3,808,404,0,2028,2031,5,343,0,0,2029,2031,5,344,0, + 0,2030,2027,1,0,0,0,2030,2028,1,0,0,0,2030,2029,1,0,0,0,2031,2033, + 1,0,0,0,2032,2034,5,105,0,0,2033,2032,1,0,0,0,2033,2034,1,0,0,0, + 2034,2035,1,0,0,0,2035,2036,3,116,58,0,2036,2038,1,0,0,0,2037,1988, + 1,0,0,0,2037,2019,1,0,0,0,2038,115,1,0,0,0,2039,2063,5,107,0,0,2040, + 2063,5,112,0,0,2041,2043,7,19,0,0,2042,2044,5,36,0,0,2043,2042,1, + 0,0,0,2043,2044,1,0,0,0,2044,2045,1,0,0,0,2045,2063,3,808,404,0, + 2046,2063,5,171,0,0,2047,2063,5,216,0,0,2048,2049,5,209,0,0,2049, + 2052,5,298,0,0,2050,2053,3,148,74,0,2051,2053,5,9,0,0,2052,2050, + 1,0,0,0,2052,2051,1,0,0,0,2053,2063,1,0,0,0,2054,2056,5,209,0,0, + 2055,2057,5,77,0,0,2056,2055,1,0,0,0,2056,2057,1,0,0,0,2057,2058, + 1,0,0,0,2058,2059,5,78,0,0,2059,2063,3,148,74,0,2060,2061,5,194, + 0,0,2061,2063,3,808,404,0,2062,2039,1,0,0,0,2062,2040,1,0,0,0,2062, + 2041,1,0,0,0,2062,2046,1,0,0,0,2062,2047,1,0,0,0,2062,2048,1,0,0, + 0,2062,2054,1,0,0,0,2062,2060,1,0,0,0,2063,2066,1,0,0,0,2064,2062, + 1,0,0,0,2064,2065,1,0,0,0,2065,2079,1,0,0,0,2066,2064,1,0,0,0,2067, + 2068,5,2,0,0,2068,2073,3,118,59,0,2069,2070,5,6,0,0,2070,2072,3, + 118,59,0,2071,2069,1,0,0,0,2072,2075,1,0,0,0,2073,2071,1,0,0,0,2073, + 2074,1,0,0,0,2074,2076,1,0,0,0,2075,2073,1,0,0,0,2076,2077,5,3,0, + 0,2077,2079,1,0,0,0,2078,2064,1,0,0,0,2078,2067,1,0,0,0,2079,117, + 1,0,0,0,2080,2095,3,824,412,0,2081,2096,3,54,27,0,2082,2096,3,202, + 101,0,2083,2096,5,9,0,0,2084,2085,5,2,0,0,2085,2090,3,52,26,0,2086, + 2087,5,6,0,0,2087,2089,3,52,26,0,2088,2086,1,0,0,0,2089,2092,1,0, + 0,0,2090,2088,1,0,0,0,2090,2091,1,0,0,0,2091,2093,1,0,0,0,2092,2090, + 1,0,0,0,2093,2094,5,3,0,0,2094,2096,1,0,0,0,2095,2081,1,0,0,0,2095, + 2082,1,0,0,0,2095,2083,1,0,0,0,2095,2084,1,0,0,0,2095,2096,1,0,0, + 0,2096,119,1,0,0,0,2097,2099,5,46,0,0,2098,2100,3,122,61,0,2099, + 2098,1,0,0,0,2099,2100,1,0,0,0,2100,2101,1,0,0,0,2101,2103,5,92, + 0,0,2102,2104,3,294,147,0,2103,2102,1,0,0,0,2103,2104,1,0,0,0,2104, + 2105,1,0,0,0,2105,2171,3,772,386,0,2106,2108,5,2,0,0,2107,2109,3, + 126,63,0,2108,2107,1,0,0,0,2108,2109,1,0,0,0,2109,2110,1,0,0,0,2110, + 2112,5,3,0,0,2111,2113,3,164,82,0,2112,2111,1,0,0,0,2112,2113,1, + 0,0,0,2113,2115,1,0,0,0,2114,2116,3,166,83,0,2115,2114,1,0,0,0,2115, + 2116,1,0,0,0,2116,2118,1,0,0,0,2117,2119,3,170,85,0,2118,2117,1, + 0,0,0,2118,2119,1,0,0,0,2119,2121,1,0,0,0,2120,2122,3,172,86,0,2121, + 2120,1,0,0,0,2121,2122,1,0,0,0,2122,2124,1,0,0,0,2123,2125,3,174, + 87,0,2124,2123,1,0,0,0,2124,2125,1,0,0,0,2125,2127,1,0,0,0,2126, + 2128,3,176,88,0,2127,2126,1,0,0,0,2127,2128,1,0,0,0,2128,2172,1, + 0,0,0,2129,2130,5,275,0,0,2130,2132,3,316,158,0,2131,2133,3,124, + 62,0,2132,2131,1,0,0,0,2132,2133,1,0,0,0,2133,2135,1,0,0,0,2134, + 2136,3,166,83,0,2135,2134,1,0,0,0,2135,2136,1,0,0,0,2136,2138,1, + 0,0,0,2137,2139,3,170,85,0,2138,2137,1,0,0,0,2138,2139,1,0,0,0,2139, + 2141,1,0,0,0,2140,2142,3,172,86,0,2141,2140,1,0,0,0,2141,2142,1, + 0,0,0,2142,2144,1,0,0,0,2143,2145,3,174,87,0,2144,2143,1,0,0,0,2144, + 2145,1,0,0,0,2145,2147,1,0,0,0,2146,2148,3,176,88,0,2147,2146,1, + 0,0,0,2147,2148,1,0,0,0,2148,2172,1,0,0,0,2149,2150,5,285,0,0,2150, + 2151,5,275,0,0,2151,2153,3,780,390,0,2152,2154,3,124,62,0,2153,2152, + 1,0,0,0,2153,2154,1,0,0,0,2154,2155,1,0,0,0,2155,2157,3,106,53,0, + 2156,2158,3,166,83,0,2157,2156,1,0,0,0,2157,2158,1,0,0,0,2158,2160, + 1,0,0,0,2159,2161,3,170,85,0,2160,2159,1,0,0,0,2160,2161,1,0,0,0, + 2161,2163,1,0,0,0,2162,2164,3,172,86,0,2163,2162,1,0,0,0,2163,2164, + 1,0,0,0,2164,2166,1,0,0,0,2165,2167,3,174,87,0,2166,2165,1,0,0,0, + 2166,2167,1,0,0,0,2167,2169,1,0,0,0,2168,2170,3,176,88,0,2169,2168, + 1,0,0,0,2169,2170,1,0,0,0,2170,2172,1,0,0,0,2171,2106,1,0,0,0,2171, + 2129,1,0,0,0,2171,2149,1,0,0,0,2172,121,1,0,0,0,2173,2179,5,354, + 0,0,2174,2179,5,352,0,0,2175,2176,7,20,0,0,2176,2179,7,21,0,0,2177, + 2179,5,367,0,0,2178,2173,1,0,0,0,2178,2174,1,0,0,0,2178,2175,1,0, + 0,0,2178,2177,1,0,0,0,2179,123,1,0,0,0,2180,2181,5,2,0,0,2181,2186, + 3,130,65,0,2182,2183,5,6,0,0,2183,2185,3,130,65,0,2184,2182,1,0, + 0,0,2185,2188,1,0,0,0,2186,2184,1,0,0,0,2186,2187,1,0,0,0,2187,2189, + 1,0,0,0,2188,2186,1,0,0,0,2189,2190,5,3,0,0,2190,125,1,0,0,0,2191, + 2196,3,128,64,0,2192,2193,5,6,0,0,2193,2195,3,128,64,0,2194,2192, + 1,0,0,0,2195,2198,1,0,0,0,2196,2194,1,0,0,0,2196,2197,1,0,0,0,2197, + 127,1,0,0,0,2198,2196,1,0,0,0,2199,2215,3,132,66,0,2200,2201,5,120, + 0,0,2201,2206,3,780,390,0,2202,2203,7,22,0,0,2203,2205,3,140,70, + 0,2204,2202,1,0,0,0,2205,2208,1,0,0,0,2206,2204,1,0,0,0,2206,2207, + 1,0,0,0,2207,2215,1,0,0,0,2208,2206,1,0,0,0,2209,2210,5,45,0,0,2210, + 2212,3,818,409,0,2211,2209,1,0,0,0,2211,2212,1,0,0,0,2212,2213,1, + 0,0,0,2213,2215,3,142,71,0,2214,2199,1,0,0,0,2214,2200,1,0,0,0,2214, + 2211,1,0,0,0,2215,129,1,0,0,0,2216,2219,3,802,401,0,2217,2218,5, + 105,0,0,2218,2220,5,280,0,0,2219,2217,1,0,0,0,2219,2220,1,0,0,0, + 2220,2224,1,0,0,0,2221,2223,3,134,67,0,2222,2221,1,0,0,0,2223,2226, + 1,0,0,0,2224,2222,1,0,0,0,2224,2225,1,0,0,0,2225,2233,1,0,0,0,2226, + 2224,1,0,0,0,2227,2228,5,45,0,0,2228,2230,3,818,409,0,2229,2227, + 1,0,0,0,2229,2230,1,0,0,0,2230,2231,1,0,0,0,2231,2233,3,142,71,0, + 2232,2216,1,0,0,0,2232,2229,1,0,0,0,2233,131,1,0,0,0,2234,2235,3, + 802,401,0,2235,2237,3,652,326,0,2236,2238,3,220,110,0,2237,2236, + 1,0,0,0,2237,2238,1,0,0,0,2238,2248,1,0,0,0,2239,2246,5,345,0,0, + 2240,2247,5,544,0,0,2241,2247,5,205,0,0,2242,2247,5,545,0,0,2243, + 2247,5,546,0,0,2244,2247,5,53,0,0,2245,2247,3,818,409,0,2246,2240, + 1,0,0,0,2246,2241,1,0,0,0,2246,2242,1,0,0,0,2246,2243,1,0,0,0,2246, + 2244,1,0,0,0,2246,2245,1,0,0,0,2247,2249,1,0,0,0,2248,2239,1,0,0, + 0,2248,2249,1,0,0,0,2249,2252,1,0,0,0,2250,2251,5,543,0,0,2251,2253, + 3,818,409,0,2252,2250,1,0,0,0,2252,2253,1,0,0,0,2253,2255,1,0,0, + 0,2254,2256,3,98,49,0,2255,2254,1,0,0,0,2255,2256,1,0,0,0,2256,2259, + 1,0,0,0,2257,2258,5,105,0,0,2258,2260,5,280,0,0,2259,2257,1,0,0, + 0,2259,2260,1,0,0,0,2260,2264,1,0,0,0,2261,2263,3,134,67,0,2262, + 2261,1,0,0,0,2263,2266,1,0,0,0,2264,2262,1,0,0,0,2264,2265,1,0,0, + 0,2265,133,1,0,0,0,2266,2264,1,0,0,0,2267,2268,5,45,0,0,2268,2270, + 3,818,409,0,2269,2267,1,0,0,0,2269,2270,1,0,0,0,2270,2271,1,0,0, + 0,2271,2276,3,136,68,0,2272,2274,5,77,0,0,2273,2272,1,0,0,0,2273, + 2274,1,0,0,0,2274,2275,1,0,0,0,2275,2277,5,54,0,0,2276,2273,1,0, + 0,0,2276,2277,1,0,0,0,2277,2280,1,0,0,0,2278,2279,5,69,0,0,2279, + 2281,7,9,0,0,2280,2278,1,0,0,0,2280,2281,1,0,0,0,2281,135,1,0,0, + 0,2282,2284,5,77,0,0,2283,2282,1,0,0,0,2283,2284,1,0,0,0,2284,2285, + 1,0,0,0,2285,2363,5,78,0,0,2286,2288,5,98,0,0,2287,2289,3,400,200, + 0,2288,2287,1,0,0,0,2288,2289,1,0,0,0,2289,2291,1,0,0,0,2290,2292, + 3,178,89,0,2291,2290,1,0,0,0,2291,2292,1,0,0,0,2292,2363,1,0,0,0, + 2293,2299,5,98,0,0,2294,2296,5,273,0,0,2295,2297,5,77,0,0,2296,2295, + 1,0,0,0,2296,2297,1,0,0,0,2297,2298,1,0,0,0,2298,2300,5,56,0,0,2299, + 2294,1,0,0,0,2299,2300,1,0,0,0,2300,2303,1,0,0,0,2301,2302,5,441, + 0,0,2302,2304,3,360,180,0,2303,2301,1,0,0,0,2303,2304,1,0,0,0,2304, + 2306,1,0,0,0,2305,2307,3,572,286,0,2306,2305,1,0,0,0,2306,2307,1, + 0,0,0,2307,2309,1,0,0,0,2308,2310,3,178,89,0,2309,2308,1,0,0,0,2309, + 2310,1,0,0,0,2310,2363,1,0,0,0,2311,2312,5,85,0,0,2312,2314,5,245, + 0,0,2313,2315,3,400,200,0,2314,2313,1,0,0,0,2314,2315,1,0,0,0,2315, + 2317,1,0,0,0,2316,2318,3,178,89,0,2317,2316,1,0,0,0,2317,2318,1, + 0,0,0,2318,2363,1,0,0,0,2319,2320,5,42,0,0,2320,2321,5,2,0,0,2321, + 2322,3,674,337,0,2322,2325,5,3,0,0,2323,2324,5,269,0,0,2324,2326, + 5,228,0,0,2325,2323,1,0,0,0,2325,2326,1,0,0,0,2326,2363,1,0,0,0, + 2327,2328,5,53,0,0,2328,2363,3,682,341,0,2329,2330,5,438,0,0,2330, + 2331,3,138,69,0,2331,2348,5,36,0,0,2332,2341,5,219,0,0,2333,2335, + 5,2,0,0,2334,2336,3,200,100,0,2335,2334,1,0,0,0,2336,2337,1,0,0, + 0,2337,2335,1,0,0,0,2337,2338,1,0,0,0,2338,2339,1,0,0,0,2339,2340, + 5,3,0,0,2340,2342,1,0,0,0,2341,2333,1,0,0,0,2341,2342,1,0,0,0,2342, + 2349,1,0,0,0,2343,2344,5,2,0,0,2344,2345,3,674,337,0,2345,2346,5, + 3,0,0,2346,2347,5,440,0,0,2347,2349,1,0,0,0,2348,2332,1,0,0,0,2348, + 2343,1,0,0,0,2349,2363,1,0,0,0,2350,2351,5,86,0,0,2351,2353,3,780, + 390,0,2352,2354,3,144,72,0,2353,2352,1,0,0,0,2353,2354,1,0,0,0,2354, + 2356,1,0,0,0,2355,2357,3,152,76,0,2356,2355,1,0,0,0,2356,2357,1, + 0,0,0,2357,2359,1,0,0,0,2358,2360,3,156,78,0,2359,2358,1,0,0,0,2359, + 2360,1,0,0,0,2360,2363,1,0,0,0,2361,2363,3,98,49,0,2362,2283,1,0, + 0,0,2362,2286,1,0,0,0,2362,2293,1,0,0,0,2362,2311,1,0,0,0,2362,2319, + 1,0,0,0,2362,2327,1,0,0,0,2362,2329,1,0,0,0,2362,2350,1,0,0,0,2362, + 2361,1,0,0,0,2363,137,1,0,0,0,2364,2368,5,139,0,0,2365,2366,5,147, + 0,0,2366,2368,5,53,0,0,2367,2364,1,0,0,0,2367,2365,1,0,0,0,2368, + 139,1,0,0,0,2369,2370,7,23,0,0,2370,141,1,0,0,0,2371,2372,5,42,0, + 0,2372,2373,5,2,0,0,2373,2374,3,674,337,0,2374,2378,5,3,0,0,2375, + 2377,3,272,136,0,2376,2375,1,0,0,0,2377,2380,1,0,0,0,2378,2376,1, + 0,0,0,2378,2379,1,0,0,0,2379,2468,1,0,0,0,2380,2378,1,0,0,0,2381, + 2385,5,98,0,0,2382,2383,5,85,0,0,2383,2385,5,245,0,0,2384,2381,1, + 0,0,0,2384,2382,1,0,0,0,2385,2409,1,0,0,0,2386,2388,3,144,72,0,2387, + 2389,3,150,75,0,2388,2387,1,0,0,0,2388,2389,1,0,0,0,2389,2391,1, + 0,0,0,2390,2392,3,400,200,0,2391,2390,1,0,0,0,2391,2392,1,0,0,0, + 2392,2394,1,0,0,0,2393,2395,3,178,89,0,2394,2393,1,0,0,0,2394,2395, + 1,0,0,0,2395,2399,1,0,0,0,2396,2398,3,272,136,0,2397,2396,1,0,0, + 0,2398,2401,1,0,0,0,2399,2397,1,0,0,0,2399,2400,1,0,0,0,2400,2410, + 1,0,0,0,2401,2399,1,0,0,0,2402,2406,3,180,90,0,2403,2405,3,272,136, + 0,2404,2403,1,0,0,0,2405,2408,1,0,0,0,2406,2404,1,0,0,0,2406,2407, + 1,0,0,0,2407,2410,1,0,0,0,2408,2406,1,0,0,0,2409,2386,1,0,0,0,2409, + 2402,1,0,0,0,2410,2468,1,0,0,0,2411,2413,5,199,0,0,2412,2414,3,170, + 85,0,2413,2412,1,0,0,0,2413,2414,1,0,0,0,2414,2415,1,0,0,0,2415, + 2416,5,2,0,0,2416,2421,3,154,77,0,2417,2418,5,6,0,0,2418,2420,3, + 154,77,0,2419,2417,1,0,0,0,2420,2423,1,0,0,0,2421,2419,1,0,0,0,2421, + 2422,1,0,0,0,2422,2424,1,0,0,0,2423,2421,1,0,0,0,2424,2426,5,3,0, + 0,2425,2427,3,150,75,0,2426,2425,1,0,0,0,2426,2427,1,0,0,0,2427, + 2429,1,0,0,0,2428,2430,3,400,200,0,2429,2428,1,0,0,0,2429,2430,1, + 0,0,0,2430,2432,1,0,0,0,2431,2433,3,178,89,0,2432,2431,1,0,0,0,2432, + 2433,1,0,0,0,2433,2439,1,0,0,0,2434,2435,5,103,0,0,2435,2436,5,2, + 0,0,2436,2437,3,674,337,0,2437,2438,5,3,0,0,2438,2440,1,0,0,0,2439, + 2434,1,0,0,0,2439,2440,1,0,0,0,2440,2444,1,0,0,0,2441,2443,3,272, + 136,0,2442,2441,1,0,0,0,2443,2446,1,0,0,0,2444,2442,1,0,0,0,2444, + 2445,1,0,0,0,2445,2468,1,0,0,0,2446,2444,1,0,0,0,2447,2448,5,63, + 0,0,2448,2449,5,245,0,0,2449,2450,3,144,72,0,2450,2451,5,86,0,0, + 2451,2453,3,780,390,0,2452,2454,3,144,72,0,2453,2452,1,0,0,0,2453, + 2454,1,0,0,0,2454,2456,1,0,0,0,2455,2457,3,152,76,0,2456,2455,1, + 0,0,0,2456,2457,1,0,0,0,2457,2459,1,0,0,0,2458,2460,3,156,78,0,2459, + 2458,1,0,0,0,2459,2460,1,0,0,0,2460,2464,1,0,0,0,2461,2463,3,272, + 136,0,2462,2461,1,0,0,0,2463,2466,1,0,0,0,2464,2462,1,0,0,0,2464, + 2465,1,0,0,0,2465,2468,1,0,0,0,2466,2464,1,0,0,0,2467,2371,1,0,0, + 0,2467,2384,1,0,0,0,2467,2411,1,0,0,0,2467,2447,1,0,0,0,2468,143, + 1,0,0,0,2469,2470,5,2,0,0,2470,2471,3,148,74,0,2471,2472,5,3,0,0, + 2472,145,1,0,0,0,2473,2474,5,2,0,0,2474,2479,3,802,401,0,2475,2476, + 5,6,0,0,2476,2478,3,802,401,0,2477,2475,1,0,0,0,2478,2481,1,0,0, + 0,2479,2477,1,0,0,0,2479,2480,1,0,0,0,2480,2482,1,0,0,0,2481,2479, + 1,0,0,0,2482,2483,5,3,0,0,2483,147,1,0,0,0,2484,2489,3,800,400,0, + 2485,2486,5,6,0,0,2486,2488,3,800,400,0,2487,2485,1,0,0,0,2488,2491, + 1,0,0,0,2489,2487,1,0,0,0,2489,2490,1,0,0,0,2490,149,1,0,0,0,2491, + 2489,1,0,0,0,2492,2493,5,441,0,0,2493,2494,3,144,72,0,2494,151,1, + 0,0,0,2495,2496,5,258,0,0,2496,2497,7,24,0,0,2497,153,1,0,0,0,2498, + 2499,3,362,181,0,2499,2506,5,105,0,0,2500,2507,3,414,207,0,2501, + 2502,5,278,0,0,2502,2503,5,2,0,0,2503,2504,3,414,207,0,2504,2505, + 5,3,0,0,2505,2507,1,0,0,0,2506,2500,1,0,0,0,2506,2501,1,0,0,0,2507, + 155,1,0,0,0,2508,2510,3,158,79,0,2509,2511,3,160,80,0,2510,2509, + 1,0,0,0,2510,2511,1,0,0,0,2511,2517,1,0,0,0,2512,2514,3,160,80,0, + 2513,2515,3,158,79,0,2514,2513,1,0,0,0,2514,2515,1,0,0,0,2515,2517, + 1,0,0,0,2516,2508,1,0,0,0,2516,2512,1,0,0,0,2517,157,1,0,0,0,2518, + 2519,5,80,0,0,2519,2520,5,369,0,0,2520,2521,3,162,81,0,2521,159, + 1,0,0,0,2522,2523,5,80,0,0,2523,2524,5,182,0,0,2524,2525,3,162,81, + 0,2525,161,1,0,0,0,2526,2527,5,269,0,0,2527,2536,5,132,0,0,2528, + 2536,5,315,0,0,2529,2536,5,150,0,0,2530,2531,5,333,0,0,2531,2533, + 7,25,0,0,2532,2534,3,148,74,0,2533,2532,1,0,0,0,2533,2534,1,0,0, + 0,2534,2536,1,0,0,0,2535,2526,1,0,0,0,2535,2528,1,0,0,0,2535,2529, + 1,0,0,0,2535,2530,1,0,0,0,2536,163,1,0,0,0,2537,2538,5,238,0,0,2538, + 2539,5,2,0,0,2539,2540,3,760,380,0,2540,2541,5,3,0,0,2541,165,1, + 0,0,0,2542,2543,5,285,0,0,2543,2544,5,147,0,0,2544,2545,3,818,409, + 0,2545,2546,5,2,0,0,2546,2551,3,168,84,0,2547,2548,5,6,0,0,2548, + 2550,3,168,84,0,2549,2547,1,0,0,0,2550,2553,1,0,0,0,2551,2549,1, + 0,0,0,2551,2552,1,0,0,0,2552,2554,1,0,0,0,2553,2551,1,0,0,0,2554, + 2555,5,3,0,0,2555,167,1,0,0,0,2556,2563,3,800,400,0,2557,2563,3, + 688,344,0,2558,2559,5,2,0,0,2559,2560,3,674,337,0,2560,2561,5,3, + 0,0,2561,2563,1,0,0,0,2562,2556,1,0,0,0,2562,2557,1,0,0,0,2562,2558, + 1,0,0,0,2563,2565,1,0,0,0,2564,2566,3,98,49,0,2565,2564,1,0,0,0, + 2565,2566,1,0,0,0,2566,2568,1,0,0,0,2567,2569,3,316,158,0,2568,2567, + 1,0,0,0,2568,2569,1,0,0,0,2569,169,1,0,0,0,2570,2571,5,100,0,0,2571, + 2572,3,818,409,0,2572,171,1,0,0,0,2573,2574,5,105,0,0,2574,2578, + 3,100,50,0,2575,2576,7,26,0,0,2576,2578,5,277,0,0,2577,2573,1,0, + 0,0,2577,2575,1,0,0,0,2578,173,1,0,0,0,2579,2580,5,80,0,0,2580,2586, + 5,161,0,0,2581,2587,5,191,0,0,2582,2583,5,182,0,0,2583,2587,5,320, + 0,0,2584,2585,5,292,0,0,2585,2587,5,320,0,0,2586,2581,1,0,0,0,2586, + 2582,1,0,0,0,2586,2584,1,0,0,0,2587,175,1,0,0,0,2588,2589,5,351, + 0,0,2589,2590,3,770,385,0,2590,177,1,0,0,0,2591,2592,5,100,0,0,2592, + 2593,5,226,0,0,2593,2594,3,176,88,0,2594,179,1,0,0,0,2595,2596,5, + 100,0,0,2596,2597,5,226,0,0,2597,2598,3,818,409,0,2598,181,1,0,0, + 0,2599,2600,5,46,0,0,2600,2605,5,342,0,0,2601,2603,3,294,147,0,2602, + 2601,1,0,0,0,2602,2603,1,0,0,0,2603,2604,1,0,0,0,2604,2606,3,316, + 158,0,2605,2602,1,0,0,0,2605,2606,1,0,0,0,2606,2608,1,0,0,0,2607, + 2609,3,144,72,0,2608,2607,1,0,0,0,2608,2609,1,0,0,0,2609,2610,1, + 0,0,0,2610,2620,5,80,0,0,2611,2616,3,732,366,0,2612,2613,5,6,0,0, + 2613,2615,3,732,366,0,2614,2612,1,0,0,0,2615,2618,1,0,0,0,2616,2614, + 1,0,0,0,2616,2617,1,0,0,0,2617,2621,1,0,0,0,2618,2616,1,0,0,0,2619, + 2621,3,730,365,0,2620,2611,1,0,0,0,2620,2619,1,0,0,0,2621,2622,1, + 0,0,0,2622,2623,3,610,305,0,2623,183,1,0,0,0,2624,2625,5,138,0,0, + 2625,2627,5,342,0,0,2626,2628,3,422,211,0,2627,2626,1,0,0,0,2627, + 2628,1,0,0,0,2628,2629,1,0,0,0,2629,2630,3,316,158,0,2630,2631,5, + 333,0,0,2631,2632,5,342,0,0,2632,2633,3,812,406,0,2633,185,1,0,0, + 0,2634,2636,5,46,0,0,2635,2637,3,122,61,0,2636,2635,1,0,0,0,2636, + 2637,1,0,0,0,2637,2638,1,0,0,0,2638,2640,5,92,0,0,2639,2641,3,294, + 147,0,2640,2639,1,0,0,0,2640,2641,1,0,0,0,2641,2642,1,0,0,0,2642, + 2643,3,188,94,0,2643,2644,5,36,0,0,2644,2646,3,560,280,0,2645,2647, + 3,190,95,0,2646,2645,1,0,0,0,2646,2647,1,0,0,0,2647,187,1,0,0,0, + 2648,2650,3,772,386,0,2649,2651,3,146,73,0,2650,2649,1,0,0,0,2650, + 2651,1,0,0,0,2651,2653,1,0,0,0,2652,2654,3,170,85,0,2653,2652,1, + 0,0,0,2653,2654,1,0,0,0,2654,2656,1,0,0,0,2655,2657,3,172,86,0,2656, + 2655,1,0,0,0,2656,2657,1,0,0,0,2657,2659,1,0,0,0,2658,2660,3,174, + 87,0,2659,2658,1,0,0,0,2659,2660,1,0,0,0,2660,2662,1,0,0,0,2661, + 2663,3,176,88,0,2662,2661,1,0,0,0,2662,2663,1,0,0,0,2663,189,1,0, + 0,0,2664,2668,5,105,0,0,2665,2669,5,174,0,0,2666,2667,5,269,0,0, + 2667,2669,5,174,0,0,2668,2665,1,0,0,0,2668,2666,1,0,0,0,2669,191, + 1,0,0,0,2670,2672,5,46,0,0,2671,2673,5,367,0,0,2672,2671,1,0,0,0, + 2672,2673,1,0,0,0,2673,2674,1,0,0,0,2674,2675,5,259,0,0,2675,2677, + 5,376,0,0,2676,2678,3,294,147,0,2677,2676,1,0,0,0,2677,2678,1,0, + 0,0,2678,2679,1,0,0,0,2679,2681,3,776,388,0,2680,2682,3,146,73,0, + 2681,2680,1,0,0,0,2681,2682,1,0,0,0,2682,2684,1,0,0,0,2683,2685, + 3,170,85,0,2684,2683,1,0,0,0,2684,2685,1,0,0,0,2685,2687,1,0,0,0, + 2686,2688,3,102,51,0,2687,2686,1,0,0,0,2687,2688,1,0,0,0,2688,2690, + 1,0,0,0,2689,2691,3,176,88,0,2690,2689,1,0,0,0,2690,2691,1,0,0,0, + 2691,2692,1,0,0,0,2692,2693,5,36,0,0,2693,2695,3,560,280,0,2694, + 2696,3,190,95,0,2695,2694,1,0,0,0,2695,2696,1,0,0,0,2696,193,1,0, + 0,0,2697,2698,5,305,0,0,2698,2699,5,259,0,0,2699,2701,5,376,0,0, + 2700,2702,5,109,0,0,2701,2700,1,0,0,0,2701,2702,1,0,0,0,2702,2703, + 1,0,0,0,2703,2705,3,778,389,0,2704,2706,3,190,95,0,2705,2704,1,0, + 0,0,2705,2706,1,0,0,0,2706,195,1,0,0,0,2707,2709,5,46,0,0,2708,2710, + 3,122,61,0,2709,2708,1,0,0,0,2709,2710,1,0,0,0,2710,2711,1,0,0,0, + 2711,2713,5,328,0,0,2712,2714,3,294,147,0,2713,2712,1,0,0,0,2713, + 2714,1,0,0,0,2714,2715,1,0,0,0,2715,2721,3,780,390,0,2716,2718,3, + 200,100,0,2717,2716,1,0,0,0,2718,2719,1,0,0,0,2719,2717,1,0,0,0, + 2719,2720,1,0,0,0,2720,2722,1,0,0,0,2721,2717,1,0,0,0,2721,2722, + 1,0,0,0,2722,197,1,0,0,0,2723,2724,5,138,0,0,2724,2726,5,328,0,0, + 2725,2727,3,422,211,0,2726,2725,1,0,0,0,2726,2727,1,0,0,0,2727,2728, + 1,0,0,0,2728,2730,3,780,390,0,2729,2731,3,200,100,0,2730,2729,1, + 0,0,0,2731,2732,1,0,0,0,2732,2730,1,0,0,0,2732,2733,1,0,0,0,2733, + 199,1,0,0,0,2734,2735,5,36,0,0,2735,2768,3,654,327,0,2736,2738,5, + 148,0,0,2737,2739,3,202,101,0,2738,2737,1,0,0,0,2738,2739,1,0,0, + 0,2739,2768,1,0,0,0,2740,2742,5,225,0,0,2741,2743,5,147,0,0,2742, + 2741,1,0,0,0,2742,2743,1,0,0,0,2743,2744,1,0,0,0,2744,2768,3,202, + 101,0,2745,2746,7,27,0,0,2746,2768,3,202,101,0,2747,2748,5,269,0, + 0,2748,2768,7,28,0,0,2749,2750,5,281,0,0,2750,2751,5,147,0,0,2751, + 2768,3,800,400,0,2752,2753,5,328,0,0,2753,2754,5,266,0,0,2754,2768, + 3,316,158,0,2755,2757,5,340,0,0,2756,2758,5,105,0,0,2757,2756,1, + 0,0,0,2757,2758,1,0,0,0,2758,2759,1,0,0,0,2759,2768,3,202,101,0, + 2760,2762,5,314,0,0,2761,2763,5,105,0,0,2762,2761,1,0,0,0,2762,2763, + 1,0,0,0,2763,2765,1,0,0,0,2764,2766,3,202,101,0,2765,2764,1,0,0, + 0,2765,2766,1,0,0,0,2766,2768,1,0,0,0,2767,2734,1,0,0,0,2767,2736, + 1,0,0,0,2767,2740,1,0,0,0,2767,2745,1,0,0,0,2767,2747,1,0,0,0,2767, + 2749,1,0,0,0,2767,2752,1,0,0,0,2767,2755,1,0,0,0,2767,2760,1,0,0, + 0,2768,201,1,0,0,0,2769,2771,7,29,0,0,2770,2769,1,0,0,0,2770,2771, + 1,0,0,0,2771,2772,1,0,0,0,2772,2775,5,573,0,0,2773,2775,3,812,406, + 0,2774,2770,1,0,0,0,2774,2773,1,0,0,0,2775,203,1,0,0,0,2776,2778, + 5,46,0,0,2777,2779,3,366,183,0,2778,2777,1,0,0,0,2778,2779,1,0,0, + 0,2779,2781,1,0,0,0,2780,2782,5,359,0,0,2781,2780,1,0,0,0,2781,2782, + 1,0,0,0,2782,2784,1,0,0,0,2783,2785,5,295,0,0,2784,2783,1,0,0,0, + 2784,2785,1,0,0,0,2785,2786,1,0,0,0,2786,2787,5,247,0,0,2787,2800, + 3,818,409,0,2788,2789,5,215,0,0,2789,2792,3,316,158,0,2790,2791, + 5,239,0,0,2791,2793,3,316,158,0,2792,2790,1,0,0,0,2792,2793,1,0, + 0,0,2793,2798,1,0,0,0,2794,2795,5,373,0,0,2795,2799,3,316,158,0, + 2796,2797,5,269,0,0,2797,2799,5,373,0,0,2798,2794,1,0,0,0,2798,2796, + 1,0,0,0,2798,2799,1,0,0,0,2799,2801,1,0,0,0,2800,2788,1,0,0,0,2800, + 2801,1,0,0,0,2801,205,1,0,0,0,2802,2803,5,46,0,0,2803,2806,3,176, + 88,0,2804,2805,5,282,0,0,2805,2807,3,814,407,0,2806,2804,1,0,0,0, + 2806,2807,1,0,0,0,2807,2808,1,0,0,0,2808,2809,5,255,0,0,2809,2811, + 3,808,404,0,2810,2812,3,102,51,0,2811,2810,1,0,0,0,2811,2812,1,0, + 0,0,2812,207,1,0,0,0,2813,2814,5,46,0,0,2814,2816,5,204,0,0,2815, + 2817,3,294,147,0,2816,2815,1,0,0,0,2816,2817,1,0,0,0,2817,2818,1, + 0,0,0,2818,2820,3,818,409,0,2819,2821,5,105,0,0,2820,2819,1,0,0, + 0,2820,2821,1,0,0,0,2821,2829,1,0,0,0,2822,2823,5,323,0,0,2823,2828, + 3,790,395,0,2824,2825,7,30,0,0,2825,2828,3,58,29,0,2826,2828,5,150, + 0,0,2827,2822,1,0,0,0,2827,2824,1,0,0,0,2827,2826,1,0,0,0,2828,2831, + 1,0,0,0,2829,2827,1,0,0,0,2829,2830,1,0,0,0,2830,209,1,0,0,0,2831, + 2829,1,0,0,0,2832,2833,5,138,0,0,2833,2834,5,204,0,0,2834,2835,3, + 818,409,0,2835,2840,5,369,0,0,2836,2837,5,94,0,0,2837,2839,3,58, + 29,0,2838,2836,1,0,0,0,2839,2842,1,0,0,0,2840,2838,1,0,0,0,2840, + 2841,1,0,0,0,2841,211,1,0,0,0,2842,2840,1,0,0,0,2843,2844,5,138, + 0,0,2844,2845,5,204,0,0,2845,2846,3,818,409,0,2846,2879,7,6,0,0, + 2847,2848,5,443,0,0,2848,2849,5,62,0,0,2849,2850,3,652,326,0,2850, + 2851,5,247,0,0,2851,2852,3,818,409,0,2852,2880,1,0,0,0,2853,2854, + 5,442,0,0,2854,2880,3,374,187,0,2855,2856,5,296,0,0,2856,2880,3, + 378,189,0,2857,2858,5,278,0,0,2858,2859,7,31,0,0,2859,2860,3,316, + 158,0,2860,2861,3,170,85,0,2861,2880,1,0,0,0,2862,2863,5,278,0,0, + 2863,2880,3,416,208,0,2864,2865,5,211,0,0,2865,2880,3,382,191,0, + 2866,2867,7,32,0,0,2867,2880,3,652,326,0,2868,2869,5,41,0,0,2869, + 2870,5,2,0,0,2870,2871,3,652,326,0,2871,2872,5,36,0,0,2872,2873, + 3,652,326,0,2873,2874,5,3,0,0,2874,2880,1,0,0,0,2875,2876,5,136, + 0,0,2876,2880,3,394,197,0,2877,2880,3,312,156,0,2878,2880,3,310, + 155,0,2879,2847,1,0,0,0,2879,2853,1,0,0,0,2879,2855,1,0,0,0,2879, + 2857,1,0,0,0,2879,2862,1,0,0,0,2879,2864,1,0,0,0,2879,2866,1,0,0, + 0,2879,2868,1,0,0,0,2879,2875,1,0,0,0,2879,2877,1,0,0,0,2879,2878, + 1,0,0,0,2880,213,1,0,0,0,2881,2882,5,46,0,0,2882,2883,5,63,0,0,2883, + 2884,5,174,0,0,2884,2885,5,381,0,0,2885,2891,3,818,409,0,2886,2888, + 3,216,108,0,2887,2886,1,0,0,0,2888,2889,1,0,0,0,2889,2887,1,0,0, + 0,2889,2890,1,0,0,0,2890,2892,1,0,0,0,2891,2887,1,0,0,0,2891,2892, + 1,0,0,0,2892,2894,1,0,0,0,2893,2895,3,220,110,0,2894,2893,1,0,0, + 0,2894,2895,1,0,0,0,2895,215,1,0,0,0,2896,2898,7,33,0,0,2897,2899, + 3,316,158,0,2898,2897,1,0,0,0,2898,2899,1,0,0,0,2899,2903,1,0,0, + 0,2900,2901,5,269,0,0,2901,2903,7,33,0,0,2902,2896,1,0,0,0,2902, + 2900,1,0,0,0,2903,217,1,0,0,0,2904,2905,5,138,0,0,2905,2906,5,63, + 0,0,2906,2907,5,174,0,0,2907,2908,5,381,0,0,2908,2922,3,818,409, + 0,2909,2911,3,216,108,0,2910,2909,1,0,0,0,2911,2912,1,0,0,0,2912, + 2910,1,0,0,0,2912,2913,1,0,0,0,2913,2915,1,0,0,0,2914,2910,1,0,0, + 0,2914,2915,1,0,0,0,2915,2916,1,0,0,0,2916,2923,3,222,111,0,2917, + 2919,3,216,108,0,2918,2917,1,0,0,0,2919,2920,1,0,0,0,2920,2918,1, + 0,0,0,2920,2921,1,0,0,0,2921,2923,1,0,0,0,2922,2914,1,0,0,0,2922, + 2918,1,0,0,0,2923,219,1,0,0,0,2924,2925,5,280,0,0,2925,2926,5,2, + 0,0,2926,2931,3,226,113,0,2927,2928,5,6,0,0,2928,2930,3,226,113, + 0,2929,2927,1,0,0,0,2930,2933,1,0,0,0,2931,2929,1,0,0,0,2931,2932, + 1,0,0,0,2932,2934,1,0,0,0,2933,2931,1,0,0,0,2934,2935,5,3,0,0,2935, + 221,1,0,0,0,2936,2937,5,280,0,0,2937,2938,5,2,0,0,2938,2943,3,224, + 112,0,2939,2940,5,6,0,0,2940,2942,3,224,112,0,2941,2939,1,0,0,0, + 2942,2945,1,0,0,0,2943,2941,1,0,0,0,2943,2944,1,0,0,0,2944,2946, + 1,0,0,0,2945,2943,1,0,0,0,2946,2947,5,3,0,0,2947,223,1,0,0,0,2948, + 2949,7,34,0,0,2949,2950,3,226,113,0,2950,225,1,0,0,0,2951,2952,3, + 824,412,0,2952,2953,3,808,404,0,2953,227,1,0,0,0,2954,2955,5,46, + 0,0,2955,2957,5,331,0,0,2956,2958,3,294,147,0,2957,2956,1,0,0,0, + 2957,2958,1,0,0,0,2958,2959,1,0,0,0,2959,2962,3,818,409,0,2960,2961, + 5,360,0,0,2961,2963,3,808,404,0,2962,2960,1,0,0,0,2962,2963,1,0, + 0,0,2963,2965,1,0,0,0,2964,2966,3,230,115,0,2965,2964,1,0,0,0,2965, + 2966,1,0,0,0,2966,2967,1,0,0,0,2967,2968,5,63,0,0,2968,2969,5,174, + 0,0,2969,2970,5,381,0,0,2970,2972,3,818,409,0,2971,2973,3,220,110, + 0,2972,2971,1,0,0,0,2972,2973,1,0,0,0,2973,229,1,0,0,0,2974,2977, + 5,375,0,0,2975,2978,3,808,404,0,2976,2978,5,78,0,0,2977,2975,1,0, + 0,0,2977,2976,1,0,0,0,2978,231,1,0,0,0,2979,2980,5,138,0,0,2980, + 2981,5,331,0,0,2981,2987,3,818,409,0,2982,2988,3,222,111,0,2983, + 2985,3,230,115,0,2984,2986,3,222,111,0,2985,2984,1,0,0,0,2985,2986, + 1,0,0,0,2986,2988,1,0,0,0,2987,2982,1,0,0,0,2987,2983,1,0,0,0,2988, + 233,1,0,0,0,2989,2990,5,46,0,0,2990,2991,5,63,0,0,2991,2993,5,92, + 0,0,2992,2994,3,294,147,0,2993,2992,1,0,0,0,2993,2994,1,0,0,0,2994, + 2995,1,0,0,0,2995,2996,3,772,386,0,2996,2998,5,2,0,0,2997,2999,3, + 126,63,0,2998,2997,1,0,0,0,2998,2999,1,0,0,0,2999,3000,1,0,0,0,3000, + 3002,5,3,0,0,3001,3003,3,164,82,0,3002,3001,1,0,0,0,3002,3003,1, + 0,0,0,3003,3004,1,0,0,0,3004,3005,5,331,0,0,3005,3007,3,818,409, + 0,3006,3008,3,220,110,0,3007,3006,1,0,0,0,3007,3008,1,0,0,0,3008, + 3029,1,0,0,0,3009,3010,5,46,0,0,3010,3011,5,63,0,0,3011,3013,5,92, + 0,0,3012,3014,3,294,147,0,3013,3012,1,0,0,0,3013,3014,1,0,0,0,3014, + 3015,1,0,0,0,3015,3016,3,772,386,0,3016,3017,5,285,0,0,3017,3018, + 5,275,0,0,3018,3020,3,774,387,0,3019,3021,3,124,62,0,3020,3019,1, + 0,0,0,3020,3021,1,0,0,0,3021,3022,1,0,0,0,3022,3023,3,106,53,0,3023, + 3024,5,331,0,0,3024,3026,3,818,409,0,3025,3027,3,220,110,0,3026, + 3025,1,0,0,0,3026,3027,1,0,0,0,3027,3029,1,0,0,0,3028,2989,1,0,0, + 0,3028,3009,1,0,0,0,3029,235,1,0,0,0,3030,3031,5,444,0,0,3031,3032, + 5,63,0,0,3032,3033,5,323,0,0,3033,3043,3,790,395,0,3034,3035,5,74, + 0,0,3035,3038,5,94,0,0,3036,3038,5,59,0,0,3037,3034,1,0,0,0,3037, + 3036,1,0,0,0,3038,3039,1,0,0,0,3039,3040,5,2,0,0,3040,3041,3,628, + 314,0,3041,3042,5,3,0,0,3042,3044,1,0,0,0,3043,3037,1,0,0,0,3043, + 3044,1,0,0,0,3044,3045,1,0,0,0,3045,3046,5,64,0,0,3046,3047,5,331, + 0,0,3047,3048,3,818,409,0,3048,3049,5,71,0,0,3049,3051,3,818,409, + 0,3050,3052,3,220,110,0,3051,3050,1,0,0,0,3051,3052,1,0,0,0,3052, + 237,1,0,0,0,3053,3054,5,46,0,0,3054,3055,5,99,0,0,3055,3057,5,257, + 0,0,3056,3058,3,294,147,0,3057,3056,1,0,0,0,3057,3058,1,0,0,0,3058, + 3059,1,0,0,0,3059,3062,5,62,0,0,3060,3063,3,814,407,0,3061,3063, + 5,99,0,0,3062,3060,1,0,0,0,3062,3061,1,0,0,0,3063,3064,1,0,0,0,3064, + 3065,5,331,0,0,3065,3067,3,818,409,0,3066,3068,3,220,110,0,3067, + 3066,1,0,0,0,3067,3068,1,0,0,0,3068,239,1,0,0,0,3069,3070,5,138, + 0,0,3070,3071,5,99,0,0,3071,3072,5,257,0,0,3072,3075,5,62,0,0,3073, + 3076,3,814,407,0,3074,3076,5,99,0,0,3075,3073,1,0,0,0,3075,3074, + 1,0,0,0,3076,3077,1,0,0,0,3077,3078,5,331,0,0,3078,3079,3,818,409, + 0,3079,3080,3,222,111,0,3080,241,1,0,0,0,3081,3082,5,46,0,0,3082, + 3083,5,445,0,0,3083,3084,3,818,409,0,3084,3085,5,80,0,0,3085,3092, + 3,780,390,0,3086,3090,5,36,0,0,3087,3091,5,541,0,0,3088,3091,5,542, + 0,0,3089,3091,3,826,413,0,3090,3087,1,0,0,0,3090,3088,1,0,0,0,3090, + 3089,1,0,0,0,3091,3093,1,0,0,0,3092,3086,1,0,0,0,3092,3093,1,0,0, + 0,3093,3096,1,0,0,0,3094,3095,5,62,0,0,3095,3097,7,35,0,0,3096,3094, + 1,0,0,0,3096,3097,1,0,0,0,3097,3100,1,0,0,0,3098,3099,5,94,0,0,3099, + 3101,3,816,408,0,3100,3098,1,0,0,0,3100,3101,1,0,0,0,3101,3103,1, + 0,0,0,3102,3104,3,250,125,0,3103,3102,1,0,0,0,3103,3104,1,0,0,0, + 3104,3106,1,0,0,0,3105,3107,3,252,126,0,3106,3105,1,0,0,0,3106,3107, + 1,0,0,0,3107,243,1,0,0,0,3108,3109,5,138,0,0,3109,3110,5,445,0,0, + 3110,3111,3,818,409,0,3111,3112,5,80,0,0,3112,3115,3,780,390,0,3113, + 3114,5,94,0,0,3114,3116,3,816,408,0,3115,3113,1,0,0,0,3115,3116, + 1,0,0,0,3116,3118,1,0,0,0,3117,3119,3,250,125,0,3118,3117,1,0,0, + 0,3118,3119,1,0,0,0,3119,3121,1,0,0,0,3120,3122,3,252,126,0,3121, + 3120,1,0,0,0,3121,3122,1,0,0,0,3122,245,1,0,0,0,3123,3124,5,138, + 0,0,3124,3125,5,296,0,0,3125,3127,3,796,398,0,3126,3128,3,368,184, + 0,3127,3126,1,0,0,0,3127,3128,1,0,0,0,3128,3155,1,0,0,0,3129,3133, + 3,248,124,0,3130,3132,3,248,124,0,3131,3130,1,0,0,0,3132,3135,1, + 0,0,0,3133,3131,1,0,0,0,3133,3134,1,0,0,0,3134,3137,1,0,0,0,3135, + 3133,1,0,0,0,3136,3138,5,315,0,0,3137,3136,1,0,0,0,3137,3138,1,0, + 0,0,3138,3156,1,0,0,0,3139,3140,5,309,0,0,3140,3141,5,94,0,0,3141, + 3156,3,798,399,0,3142,3143,5,282,0,0,3143,3144,5,94,0,0,3144,3156, + 3,814,407,0,3145,3146,5,333,0,0,3146,3147,5,323,0,0,3147,3156,3, + 32,16,0,3148,3150,5,269,0,0,3149,3148,1,0,0,0,3149,3150,1,0,0,0, + 3150,3151,1,0,0,0,3151,3152,5,462,0,0,3152,3153,5,80,0,0,3153,3154, + 5,204,0,0,3154,3156,3,818,409,0,3155,3129,1,0,0,0,3155,3139,1,0, + 0,0,3155,3142,1,0,0,0,3155,3145,1,0,0,0,3155,3149,1,0,0,0,3156,247, + 1,0,0,0,3157,3159,5,205,0,0,3158,3157,1,0,0,0,3158,3159,1,0,0,0, + 3159,3160,1,0,0,0,3160,3161,5,327,0,0,3161,3168,5,243,0,0,3162,3164, + 5,205,0,0,3163,3162,1,0,0,0,3163,3164,1,0,0,0,3164,3165,1,0,0,0, + 3165,3166,5,327,0,0,3166,3168,5,181,0,0,3167,3158,1,0,0,0,3167,3163, + 1,0,0,0,3168,3187,1,0,0,0,3169,3170,5,333,0,0,3170,3171,3,818,409, + 0,3171,3174,7,36,0,0,3172,3175,3,818,409,0,3173,3175,5,53,0,0,3174, + 3172,1,0,0,0,3174,3173,1,0,0,0,3175,3187,1,0,0,0,3176,3177,5,333, + 0,0,3177,3178,3,818,409,0,3178,3179,5,64,0,0,3179,3180,5,434,0,0, + 3180,3187,1,0,0,0,3181,3184,5,313,0,0,3182,3185,3,818,409,0,3183, + 3185,5,30,0,0,3184,3182,1,0,0,0,3184,3183,1,0,0,0,3185,3187,1,0, + 0,0,3186,3167,1,0,0,0,3186,3169,1,0,0,0,3186,3176,1,0,0,0,3186,3181, + 1,0,0,0,3187,249,1,0,0,0,3188,3189,5,100,0,0,3189,3190,5,2,0,0,3190, + 3191,3,674,337,0,3191,3192,5,3,0,0,3192,251,1,0,0,0,3193,3194,5, + 105,0,0,3194,3195,5,42,0,0,3195,3196,5,2,0,0,3196,3197,3,674,337, + 0,3197,3198,5,3,0,0,3198,253,1,0,0,0,3199,3200,5,46,0,0,3200,3201, + 5,131,0,0,3201,3202,5,446,0,0,3202,3203,3,818,409,0,3203,3204,5, + 360,0,0,3204,3205,7,37,0,0,3205,3206,5,215,0,0,3206,3207,3,316,158, + 0,3207,255,1,0,0,0,3208,3210,5,46,0,0,3209,3211,3,366,183,0,3210, + 3209,1,0,0,0,3210,3211,1,0,0,0,3211,3212,1,0,0,0,3212,3213,5,357, + 0,0,3213,3214,3,818,409,0,3214,3215,3,258,129,0,3215,3216,3,260, + 130,0,3216,3217,5,80,0,0,3217,3229,3,774,387,0,3218,3225,5,447,0, + 0,3219,3220,7,38,0,0,3220,3222,7,39,0,0,3221,3223,5,36,0,0,3222, + 3221,1,0,0,0,3222,3223,1,0,0,0,3223,3224,1,0,0,0,3224,3226,3,818, + 409,0,3225,3219,1,0,0,0,3226,3227,1,0,0,0,3227,3225,1,0,0,0,3227, + 3228,1,0,0,0,3228,3230,1,0,0,0,3229,3218,1,0,0,0,3229,3230,1,0,0, + 0,3230,3236,1,0,0,0,3231,3233,5,62,0,0,3232,3234,5,192,0,0,3233, + 3232,1,0,0,0,3233,3234,1,0,0,0,3234,3235,1,0,0,0,3235,3237,7,40, + 0,0,3236,3231,1,0,0,0,3236,3237,1,0,0,0,3237,3239,1,0,0,0,3238,3240, + 3,264,132,0,3239,3238,1,0,0,0,3239,3240,1,0,0,0,3240,3241,1,0,0, + 0,3241,3242,5,202,0,0,3242,3243,3,266,133,0,3243,3244,5,2,0,0,3244, + 3245,3,268,134,0,3245,3246,5,3,0,0,3246,3287,1,0,0,0,3247,3249,5, + 46,0,0,3248,3250,3,366,183,0,3249,3248,1,0,0,0,3249,3250,1,0,0,0, + 3250,3252,1,0,0,0,3251,3253,5,45,0,0,3252,3251,1,0,0,0,3252,3253, + 1,0,0,0,3253,3254,1,0,0,0,3254,3255,5,357,0,0,3255,3256,3,818,409, + 0,3256,3257,3,258,129,0,3257,3258,3,260,130,0,3258,3259,5,80,0,0, + 3259,3262,3,774,387,0,3260,3261,5,64,0,0,3261,3263,3,780,390,0,3262, + 3260,1,0,0,0,3262,3263,1,0,0,0,3263,3267,1,0,0,0,3264,3266,3,272, + 136,0,3265,3264,1,0,0,0,3266,3269,1,0,0,0,3267,3265,1,0,0,0,3267, + 3268,1,0,0,0,3268,3275,1,0,0,0,3269,3267,1,0,0,0,3270,3272,5,62, + 0,0,3271,3273,5,192,0,0,3272,3271,1,0,0,0,3272,3273,1,0,0,0,3273, + 3274,1,0,0,0,3274,3276,7,40,0,0,3275,3270,1,0,0,0,3275,3276,1,0, + 0,0,3276,3278,1,0,0,0,3277,3279,3,264,132,0,3278,3277,1,0,0,0,3278, + 3279,1,0,0,0,3279,3280,1,0,0,0,3280,3281,5,202,0,0,3281,3282,3,266, + 133,0,3282,3283,5,2,0,0,3283,3284,3,268,134,0,3284,3285,5,3,0,0, + 3285,3287,1,0,0,0,3286,3208,1,0,0,0,3286,3247,1,0,0,0,3287,257,1, + 0,0,0,3288,3293,5,145,0,0,3289,3293,5,135,0,0,3290,3291,5,242,0, + 0,3291,3293,5,275,0,0,3292,3288,1,0,0,0,3292,3289,1,0,0,0,3292,3290, + 1,0,0,0,3293,259,1,0,0,0,3294,3299,3,262,131,0,3295,3296,5,82,0, + 0,3296,3298,3,262,131,0,3297,3295,1,0,0,0,3298,3301,1,0,0,0,3299, + 3297,1,0,0,0,3299,3300,1,0,0,0,3300,261,1,0,0,0,3301,3299,1,0,0, + 0,3302,3311,5,241,0,0,3303,3311,5,182,0,0,3304,3307,5,369,0,0,3305, + 3306,5,275,0,0,3306,3308,3,148,74,0,3307,3305,1,0,0,0,3307,3308, + 1,0,0,0,3308,3311,1,0,0,0,3309,3311,5,358,0,0,3310,3302,1,0,0,0, + 3310,3303,1,0,0,0,3310,3304,1,0,0,0,3310,3309,1,0,0,0,3311,263,1, + 0,0,0,3312,3313,5,102,0,0,3313,3314,5,2,0,0,3314,3315,3,674,337, + 0,3315,3316,5,3,0,0,3316,265,1,0,0,0,3317,3318,5,211,0,0,3318,3322, + 3,806,403,0,3319,3320,5,296,0,0,3320,3322,3,796,398,0,3321,3317, + 1,0,0,0,3321,3319,1,0,0,0,3322,267,1,0,0,0,3323,3326,3,270,135,0, + 3324,3326,1,0,0,0,3325,3323,1,0,0,0,3325,3324,1,0,0,0,3326,3331, + 1,0,0,0,3327,3328,5,6,0,0,3328,3330,3,270,135,0,3329,3327,1,0,0, + 0,3330,3333,1,0,0,0,3331,3329,1,0,0,0,3331,3332,1,0,0,0,3332,269, + 1,0,0,0,3333,3331,1,0,0,0,3334,3339,5,571,0,0,3335,3339,5,573,0, + 0,3336,3339,3,808,404,0,3337,3339,3,824,412,0,3338,3334,1,0,0,0, + 3338,3335,1,0,0,0,3338,3336,1,0,0,0,3338,3337,1,0,0,0,3339,271,1, + 0,0,0,3340,3342,5,77,0,0,3341,3340,1,0,0,0,3341,3342,1,0,0,0,3342, + 3343,1,0,0,0,3343,3351,5,54,0,0,3344,3345,5,69,0,0,3345,3351,7,9, + 0,0,3346,3347,5,77,0,0,3347,3351,5,371,0,0,3348,3349,5,269,0,0,3349, + 3351,5,228,0,0,3350,3341,1,0,0,0,3350,3344,1,0,0,0,3350,3346,1,0, + 0,0,3350,3348,1,0,0,0,3351,273,1,0,0,0,3352,3353,5,46,0,0,3353,3354, + 5,198,0,0,3354,3355,5,357,0,0,3355,3356,3,818,409,0,3356,3357,5, + 80,0,0,3357,3367,3,824,412,0,3358,3359,5,102,0,0,3359,3364,3,276, + 138,0,3360,3361,5,33,0,0,3361,3363,3,276,138,0,3362,3360,1,0,0,0, + 3363,3366,1,0,0,0,3364,3362,1,0,0,0,3364,3365,1,0,0,0,3365,3368, + 1,0,0,0,3366,3364,1,0,0,0,3367,3358,1,0,0,0,3367,3368,1,0,0,0,3368, + 3369,1,0,0,0,3369,3370,5,202,0,0,3370,3371,3,266,133,0,3371,3372, + 5,2,0,0,3372,3373,5,3,0,0,3373,275,1,0,0,0,3374,3375,3,818,409,0, + 3375,3376,5,68,0,0,3376,3377,5,2,0,0,3377,3381,3,808,404,0,3378, + 3380,3,462,231,0,3379,3378,1,0,0,0,3380,3383,1,0,0,0,3381,3379,1, + 0,0,0,3381,3382,1,0,0,0,3382,3384,1,0,0,0,3383,3381,1,0,0,0,3384, + 3385,5,3,0,0,3385,277,1,0,0,0,3386,3387,5,138,0,0,3387,3388,5,198, + 0,0,3388,3389,5,357,0,0,3389,3395,3,818,409,0,3390,3392,5,193,0, + 0,3391,3393,7,14,0,0,3392,3391,1,0,0,0,3392,3393,1,0,0,0,3393,3396, + 1,0,0,0,3394,3396,5,186,0,0,3395,3390,1,0,0,0,3395,3394,1,0,0,0, + 3396,279,1,0,0,0,3397,3398,5,46,0,0,3398,3399,5,140,0,0,3399,3400, + 3,316,158,0,3400,3401,5,42,0,0,3401,3402,5,2,0,0,3402,3403,3,674, + 337,0,3403,3407,5,3,0,0,3404,3406,3,272,136,0,3405,3404,1,0,0,0, + 3406,3409,1,0,0,0,3407,3405,1,0,0,0,3407,3408,1,0,0,0,3408,281,1, + 0,0,0,3409,3407,1,0,0,0,3410,3412,5,46,0,0,3411,3413,3,366,183,0, + 3412,3411,1,0,0,0,3412,3413,1,0,0,0,3413,3414,1,0,0,0,3414,3415, + 5,136,0,0,3415,3430,3,806,403,0,3416,3417,3,392,196,0,3417,3418, + 3,284,142,0,3418,3431,1,0,0,0,3419,3420,5,2,0,0,3420,3425,3,290, + 145,0,3421,3422,5,6,0,0,3422,3424,3,290,145,0,3423,3421,1,0,0,0, + 3424,3427,1,0,0,0,3425,3423,1,0,0,0,3425,3426,1,0,0,0,3426,3428, + 1,0,0,0,3427,3425,1,0,0,0,3428,3429,5,3,0,0,3429,3431,1,0,0,0,3430, + 3416,1,0,0,0,3430,3419,1,0,0,0,3431,3489,1,0,0,0,3432,3433,5,46, + 0,0,3433,3434,5,278,0,0,3434,3435,3,414,207,0,3435,3436,3,284,142, + 0,3436,3489,1,0,0,0,3437,3438,5,46,0,0,3438,3439,5,360,0,0,3439, + 3440,3,316,158,0,3440,3458,5,36,0,0,3441,3443,5,2,0,0,3442,3444, + 3,642,321,0,3443,3442,1,0,0,0,3443,3444,1,0,0,0,3444,3445,1,0,0, + 0,3445,3459,5,3,0,0,3446,3447,5,196,0,0,3447,3455,5,2,0,0,3448,3452, + 3,808,404,0,3449,3451,3,462,231,0,3450,3449,1,0,0,0,3451,3454,1, + 0,0,0,3452,3450,1,0,0,0,3452,3453,1,0,0,0,3453,3456,1,0,0,0,3454, + 3452,1,0,0,0,3455,3448,1,0,0,0,3455,3456,1,0,0,0,3456,3457,1,0,0, + 0,3457,3459,5,3,0,0,3458,3441,1,0,0,0,3458,3446,1,0,0,0,3459,3489, + 1,0,0,0,3460,3461,5,46,0,0,3461,3462,5,360,0,0,3462,3468,3,316,158, + 0,3463,3464,5,36,0,0,3464,3466,5,299,0,0,3465,3463,1,0,0,0,3465, + 3466,1,0,0,0,3466,3467,1,0,0,0,3467,3469,3,284,142,0,3468,3465,1, + 0,0,0,3468,3469,1,0,0,0,3469,3489,1,0,0,0,3470,3471,5,46,0,0,3471, + 3472,5,355,0,0,3472,3473,5,325,0,0,3473,3474,7,41,0,0,3474,3475, + 3,316,158,0,3475,3476,3,284,142,0,3476,3489,1,0,0,0,3477,3478,5, + 46,0,0,3478,3480,5,108,0,0,3479,3481,3,294,147,0,3480,3479,1,0,0, + 0,3480,3481,1,0,0,0,3481,3482,1,0,0,0,3482,3486,3,316,158,0,3483, + 3487,3,284,142,0,3484,3485,5,64,0,0,3485,3487,3,316,158,0,3486,3483, + 1,0,0,0,3486,3484,1,0,0,0,3487,3489,1,0,0,0,3488,3410,1,0,0,0,3488, + 3432,1,0,0,0,3488,3437,1,0,0,0,3488,3460,1,0,0,0,3488,3470,1,0,0, + 0,3488,3477,1,0,0,0,3489,283,1,0,0,0,3490,3491,5,2,0,0,3491,3496, + 3,286,143,0,3492,3493,5,6,0,0,3493,3495,3,286,143,0,3494,3492,1, + 0,0,0,3495,3498,1,0,0,0,3496,3494,1,0,0,0,3496,3497,1,0,0,0,3497, + 3499,1,0,0,0,3498,3496,1,0,0,0,3499,3500,5,3,0,0,3500,285,1,0,0, + 0,3501,3504,3,824,412,0,3502,3503,5,10,0,0,3503,3505,3,288,144,0, + 3504,3502,1,0,0,0,3504,3505,1,0,0,0,3505,287,1,0,0,0,3506,3513,3, + 388,194,0,3507,3513,3,834,417,0,3508,3513,3,726,363,0,3509,3513, + 3,202,101,0,3510,3513,3,808,404,0,3511,3513,5,407,0,0,3512,3506, + 1,0,0,0,3512,3507,1,0,0,0,3512,3508,1,0,0,0,3512,3509,1,0,0,0,3512, + 3510,1,0,0,0,3512,3511,1,0,0,0,3513,289,1,0,0,0,3514,3515,3,826, + 413,0,3515,3516,5,10,0,0,3516,3517,3,288,144,0,3517,291,1,0,0,0, + 3518,3519,5,138,0,0,3519,3520,5,360,0,0,3520,3521,3,316,158,0,3521, + 3522,5,133,0,0,3522,3524,5,450,0,0,3523,3525,3,294,147,0,3524,3523, + 1,0,0,0,3524,3525,1,0,0,0,3525,3526,1,0,0,0,3526,3529,3,808,404, + 0,3527,3528,7,42,0,0,3528,3530,3,808,404,0,3529,3527,1,0,0,0,3529, + 3530,1,0,0,0,3530,3541,1,0,0,0,3531,3532,5,138,0,0,3532,3533,5,360, + 0,0,3533,3534,3,316,158,0,3534,3535,5,309,0,0,3535,3536,5,450,0, + 0,3536,3537,3,808,404,0,3537,3538,5,94,0,0,3538,3539,3,808,404,0, + 3539,3541,1,0,0,0,3540,3518,1,0,0,0,3540,3531,1,0,0,0,3541,293,1, + 0,0,0,3542,3543,5,220,0,0,3543,3544,5,77,0,0,3544,3545,5,396,0,0, + 3545,295,1,0,0,0,3546,3547,5,46,0,0,3547,3548,5,278,0,0,3548,3549, + 5,156,0,0,3549,3551,3,316,158,0,3550,3552,5,53,0,0,3551,3550,1,0, + 0,0,3551,3552,1,0,0,0,3552,3553,1,0,0,0,3553,3554,5,62,0,0,3554, + 3555,5,360,0,0,3555,3556,3,652,326,0,3556,3559,3,170,85,0,3557,3558, + 5,206,0,0,3558,3560,3,316,158,0,3559,3557,1,0,0,0,3559,3560,1,0, + 0,0,3560,3561,1,0,0,0,3561,3562,5,36,0,0,3562,3567,3,298,149,0,3563, + 3564,5,6,0,0,3564,3566,3,298,149,0,3565,3563,1,0,0,0,3566,3569,1, + 0,0,0,3567,3565,1,0,0,0,3567,3568,1,0,0,0,3568,297,1,0,0,0,3569, + 3567,1,0,0,0,3570,3571,5,278,0,0,3571,3572,5,571,0,0,3572,3574,3, + 414,207,0,3573,3575,3,412,206,0,3574,3573,1,0,0,0,3574,3575,1,0, + 0,0,3575,3583,1,0,0,0,3576,3581,5,62,0,0,3577,3582,5,325,0,0,3578, + 3579,5,83,0,0,3579,3580,5,147,0,0,3580,3582,3,316,158,0,3581,3577, + 1,0,0,0,3581,3578,1,0,0,0,3582,3584,1,0,0,0,3583,3576,1,0,0,0,3583, + 3584,1,0,0,0,3584,3586,1,0,0,0,3585,3587,5,302,0,0,3586,3585,1,0, + 0,0,3586,3587,1,0,0,0,3587,3597,1,0,0,0,3588,3589,5,211,0,0,3589, + 3591,5,571,0,0,3590,3592,3,528,264,0,3591,3590,1,0,0,0,3591,3592, + 1,0,0,0,3592,3593,1,0,0,0,3593,3597,3,382,191,0,3594,3595,5,345, + 0,0,3595,3597,3,652,326,0,3596,3570,1,0,0,0,3596,3588,1,0,0,0,3596, + 3594,1,0,0,0,3597,299,1,0,0,0,3598,3599,5,46,0,0,3599,3600,5,278, + 0,0,3600,3601,5,206,0,0,3601,3602,3,316,158,0,3602,3603,3,170,85, + 0,3603,301,1,0,0,0,3604,3605,5,138,0,0,3605,3606,5,278,0,0,3606, + 3607,5,206,0,0,3607,3608,3,316,158,0,3608,3627,3,170,85,0,3609,3610, + 5,133,0,0,3610,3615,3,298,149,0,3611,3612,5,6,0,0,3612,3614,3,298, + 149,0,3613,3611,1,0,0,0,3614,3617,1,0,0,0,3615,3613,1,0,0,0,3615, + 3616,1,0,0,0,3616,3628,1,0,0,0,3617,3615,1,0,0,0,3618,3619,5,191, + 0,0,3619,3624,3,304,152,0,3620,3621,5,6,0,0,3621,3623,3,304,152, + 0,3622,3620,1,0,0,0,3623,3626,1,0,0,0,3624,3622,1,0,0,0,3624,3625, + 1,0,0,0,3625,3628,1,0,0,0,3626,3624,1,0,0,0,3627,3609,1,0,0,0,3627, + 3618,1,0,0,0,3628,303,1,0,0,0,3629,3630,7,43,0,0,3630,3631,5,571, + 0,0,3631,3632,3,528,264,0,3632,305,1,0,0,0,3633,3634,5,301,0,0,3634, + 3635,5,281,0,0,3635,3636,5,147,0,0,3636,3637,3,816,408,0,3637,3638, + 5,94,0,0,3638,3639,3,814,407,0,3639,307,1,0,0,0,3640,3663,5,191, + 0,0,3641,3664,5,328,0,0,3642,3664,5,226,0,0,3643,3664,5,108,0,0, + 3644,3664,5,168,0,0,3645,3664,5,342,0,0,3646,3664,5,452,0,0,3647, + 3664,5,331,0,0,3648,3649,5,131,0,0,3649,3664,5,446,0,0,3650,3651, + 5,198,0,0,3651,3664,5,357,0,0,3652,3664,5,204,0,0,3653,3655,5,295, + 0,0,3654,3653,1,0,0,0,3654,3655,1,0,0,0,3655,3656,1,0,0,0,3656,3664, + 5,247,0,0,3657,3658,5,63,0,0,3658,3659,5,174,0,0,3659,3664,5,381, + 0,0,3660,3661,5,355,0,0,3661,3662,5,325,0,0,3662,3664,7,41,0,0,3663, + 3641,1,0,0,0,3663,3642,1,0,0,0,3663,3643,1,0,0,0,3663,3644,1,0,0, + 0,3663,3645,1,0,0,0,3663,3646,1,0,0,0,3663,3647,1,0,0,0,3663,3648, + 1,0,0,0,3663,3650,1,0,0,0,3663,3652,1,0,0,0,3663,3654,1,0,0,0,3663, + 3657,1,0,0,0,3663,3660,1,0,0,0,3664,3666,1,0,0,0,3665,3667,3,422, + 211,0,3666,3665,1,0,0,0,3666,3667,1,0,0,0,3667,3668,1,0,0,0,3668, + 3670,3,784,392,0,3669,3671,3,96,48,0,3670,3669,1,0,0,0,3670,3671, + 1,0,0,0,3671,3848,1,0,0,0,3672,3674,5,191,0,0,3673,3675,5,259,0, + 0,3674,3673,1,0,0,0,3674,3675,1,0,0,0,3675,3676,1,0,0,0,3676,3678, + 5,376,0,0,3677,3679,3,422,211,0,3678,3677,1,0,0,0,3678,3679,1,0, + 0,0,3679,3680,1,0,0,0,3680,3685,3,778,389,0,3681,3682,5,6,0,0,3682, + 3684,3,778,389,0,3683,3681,1,0,0,0,3684,3687,1,0,0,0,3685,3683,1, + 0,0,0,3685,3686,1,0,0,0,3686,3689,1,0,0,0,3687,3685,1,0,0,0,3688, + 3690,3,96,48,0,3689,3688,1,0,0,0,3689,3690,1,0,0,0,3690,3848,1,0, + 0,0,3691,3693,5,191,0,0,3692,3694,5,63,0,0,3693,3692,1,0,0,0,3693, + 3694,1,0,0,0,3694,3695,1,0,0,0,3695,3697,5,92,0,0,3696,3698,3,422, + 211,0,3697,3696,1,0,0,0,3697,3698,1,0,0,0,3698,3699,1,0,0,0,3699, + 3701,3,762,381,0,3700,3702,3,96,48,0,3701,3700,1,0,0,0,3701,3702, + 1,0,0,0,3702,3848,1,0,0,0,3703,3704,5,191,0,0,3704,3706,5,323,0, + 0,3705,3707,3,422,211,0,3706,3705,1,0,0,0,3706,3707,1,0,0,0,3707, + 3708,1,0,0,0,3708,3710,3,764,382,0,3709,3711,3,96,48,0,3710,3709, + 1,0,0,0,3710,3711,1,0,0,0,3711,3848,1,0,0,0,3712,3713,5,191,0,0, + 3713,3715,7,44,0,0,3714,3716,3,422,211,0,3715,3714,1,0,0,0,3715, + 3716,1,0,0,0,3716,3717,1,0,0,0,3717,3718,3,818,409,0,3718,3719,5, + 80,0,0,3719,3721,3,316,158,0,3720,3722,3,96,48,0,3721,3720,1,0,0, + 0,3721,3722,1,0,0,0,3722,3848,1,0,0,0,3723,3724,5,191,0,0,3724,3726, + 7,32,0,0,3725,3727,3,422,211,0,3726,3725,1,0,0,0,3726,3727,1,0,0, + 0,3727,3728,1,0,0,0,3728,3733,3,652,326,0,3729,3730,5,6,0,0,3730, + 3732,3,652,326,0,3731,3729,1,0,0,0,3732,3735,1,0,0,0,3733,3731,1, + 0,0,0,3733,3734,1,0,0,0,3734,3737,1,0,0,0,3735,3733,1,0,0,0,3736, + 3738,3,96,48,0,3737,3736,1,0,0,0,3737,3738,1,0,0,0,3738,3848,1,0, + 0,0,3739,3740,5,191,0,0,3740,3741,5,226,0,0,3741,3743,5,109,0,0, + 3742,3744,3,422,211,0,3743,3742,1,0,0,0,3743,3744,1,0,0,0,3744,3745, + 1,0,0,0,3745,3747,3,314,157,0,3746,3748,3,96,48,0,3747,3746,1,0, + 0,0,3747,3748,1,0,0,0,3748,3848,1,0,0,0,3749,3750,5,191,0,0,3750, + 3752,5,41,0,0,3751,3753,3,422,211,0,3752,3751,1,0,0,0,3752,3753, + 1,0,0,0,3753,3754,1,0,0,0,3754,3755,5,2,0,0,3755,3756,3,652,326, + 0,3756,3757,5,36,0,0,3757,3758,3,652,326,0,3758,3760,5,3,0,0,3759, + 3761,3,96,48,0,3760,3759,1,0,0,0,3760,3761,1,0,0,0,3761,3848,1,0, + 0,0,3762,3763,5,191,0,0,3763,3764,5,278,0,0,3764,3766,7,31,0,0,3765, + 3767,3,422,211,0,3766,3765,1,0,0,0,3766,3767,1,0,0,0,3767,3768,1, + 0,0,0,3768,3769,3,316,158,0,3769,3771,3,170,85,0,3770,3772,3,96, + 48,0,3771,3770,1,0,0,0,3771,3772,1,0,0,0,3772,3848,1,0,0,0,3773, + 3774,5,191,0,0,3774,3775,5,281,0,0,3775,3776,5,147,0,0,3776,3778, + 3,816,408,0,3777,3779,3,96,48,0,3778,3777,1,0,0,0,3778,3779,1,0, + 0,0,3779,3848,1,0,0,0,3780,3781,5,191,0,0,3781,3783,5,451,0,0,3782, + 3784,3,422,211,0,3783,3782,1,0,0,0,3783,3784,1,0,0,0,3784,3785,1, + 0,0,0,3785,3787,3,818,409,0,3786,3788,3,96,48,0,3787,3786,1,0,0, + 0,3787,3788,1,0,0,0,3788,3848,1,0,0,0,3789,3790,5,191,0,0,3790,3792, + 5,351,0,0,3791,3793,3,422,211,0,3792,3791,1,0,0,0,3792,3793,1,0, + 0,0,3793,3794,1,0,0,0,3794,3848,3,770,385,0,3795,3796,5,191,0,0, + 3796,3798,5,443,0,0,3797,3799,3,422,211,0,3798,3797,1,0,0,0,3798, + 3799,1,0,0,0,3799,3800,1,0,0,0,3800,3801,5,62,0,0,3801,3802,3,652, + 326,0,3802,3803,5,247,0,0,3803,3805,3,818,409,0,3804,3806,3,96,48, + 0,3805,3804,1,0,0,0,3805,3806,1,0,0,0,3806,3848,1,0,0,0,3807,3808, + 5,191,0,0,3808,3810,7,45,0,0,3809,3811,3,422,211,0,3810,3809,1,0, + 0,0,3810,3811,1,0,0,0,3811,3812,1,0,0,0,3812,3848,3,816,408,0,3813, + 3814,5,191,0,0,3814,3815,5,99,0,0,3815,3817,5,257,0,0,3816,3818, + 3,422,211,0,3817,3816,1,0,0,0,3817,3818,1,0,0,0,3818,3819,1,0,0, + 0,3819,3822,5,62,0,0,3820,3823,3,814,407,0,3821,3823,5,99,0,0,3822, + 3820,1,0,0,0,3822,3821,1,0,0,0,3823,3824,1,0,0,0,3824,3825,5,331, + 0,0,3825,3848,3,818,409,0,3826,3827,5,191,0,0,3827,3829,5,175,0, + 0,3828,3830,3,422,211,0,3829,3828,1,0,0,0,3829,3830,1,0,0,0,3830, + 3831,1,0,0,0,3831,3845,3,788,394,0,3832,3834,5,105,0,0,3833,3832, + 1,0,0,0,3833,3834,1,0,0,0,3834,3835,1,0,0,0,3835,3836,5,2,0,0,3836, + 3841,5,209,0,0,3837,3838,5,6,0,0,3838,3840,5,209,0,0,3839,3837,1, + 0,0,0,3840,3843,1,0,0,0,3841,3839,1,0,0,0,3841,3842,1,0,0,0,3842, + 3844,1,0,0,0,3843,3841,1,0,0,0,3844,3846,5,3,0,0,3845,3833,1,0,0, + 0,3845,3846,1,0,0,0,3846,3848,1,0,0,0,3847,3640,1,0,0,0,3847,3672, + 1,0,0,0,3847,3691,1,0,0,0,3847,3703,1,0,0,0,3847,3712,1,0,0,0,3847, + 3723,1,0,0,0,3847,3739,1,0,0,0,3847,3749,1,0,0,0,3847,3762,1,0,0, + 0,3847,3773,1,0,0,0,3847,3780,1,0,0,0,3847,3789,1,0,0,0,3847,3795, + 1,0,0,0,3847,3807,1,0,0,0,3847,3813,1,0,0,0,3847,3826,1,0,0,0,3848, + 309,1,0,0,0,3849,3851,5,63,0,0,3850,3849,1,0,0,0,3850,3851,1,0,0, + 0,3851,3852,1,0,0,0,3852,3853,5,92,0,0,3853,3866,3,774,387,0,3854, + 3856,5,259,0,0,3855,3854,1,0,0,0,3855,3856,1,0,0,0,3856,3857,1,0, + 0,0,3857,3858,5,376,0,0,3858,3866,3,778,389,0,3859,3860,7,46,0,0, + 3860,3866,3,316,158,0,3861,3862,5,355,0,0,3862,3863,5,325,0,0,3863, + 3864,7,41,0,0,3864,3866,3,316,158,0,3865,3850,1,0,0,0,3865,3855, + 1,0,0,0,3865,3859,1,0,0,0,3865,3861,1,0,0,0,3866,311,1,0,0,0,3867, + 3868,5,198,0,0,3868,3884,5,357,0,0,3869,3870,5,131,0,0,3870,3884, + 5,446,0,0,3871,3884,5,204,0,0,3872,3884,5,452,0,0,3873,3884,5,331, + 0,0,3874,3884,5,318,0,0,3875,3884,5,451,0,0,3876,3877,5,63,0,0,3877, + 3878,5,174,0,0,3878,3884,5,381,0,0,3879,3881,5,295,0,0,3880,3879, + 1,0,0,0,3880,3881,1,0,0,0,3881,3882,1,0,0,0,3882,3884,5,247,0,0, + 3883,3867,1,0,0,0,3883,3869,1,0,0,0,3883,3871,1,0,0,0,3883,3872, + 1,0,0,0,3883,3873,1,0,0,0,3883,3874,1,0,0,0,3883,3875,1,0,0,0,3883, + 3876,1,0,0,0,3883,3880,1,0,0,0,3884,3885,1,0,0,0,3885,3892,3,818, + 409,0,3886,3887,5,323,0,0,3887,3892,3,790,395,0,3888,3889,5,175, + 0,0,3889,3892,3,788,394,0,3890,3892,3,176,88,0,3891,3883,1,0,0,0, + 3891,3886,1,0,0,0,3891,3888,1,0,0,0,3891,3890,1,0,0,0,3892,313,1, + 0,0,0,3893,3898,3,316,158,0,3894,3895,5,6,0,0,3895,3897,3,316,158, + 0,3896,3894,1,0,0,0,3897,3900,1,0,0,0,3898,3896,1,0,0,0,3898,3899, + 1,0,0,0,3899,315,1,0,0,0,3900,3898,1,0,0,0,3901,3903,3,818,409,0, + 3902,3904,3,318,159,0,3903,3902,1,0,0,0,3903,3904,1,0,0,0,3904,317, + 1,0,0,0,3905,3906,5,11,0,0,3906,3908,3,824,412,0,3907,3905,1,0,0, + 0,3908,3909,1,0,0,0,3909,3907,1,0,0,0,3909,3910,1,0,0,0,3910,319, + 1,0,0,0,3911,3913,5,358,0,0,3912,3914,5,92,0,0,3913,3912,1,0,0,0, + 3913,3914,1,0,0,0,3914,3915,1,0,0,0,3915,3920,3,322,161,0,3916,3917, + 5,6,0,0,3917,3919,3,322,161,0,3918,3916,1,0,0,0,3919,3922,1,0,0, + 0,3920,3918,1,0,0,0,3920,3921,1,0,0,0,3921,3925,1,0,0,0,3922,3920, + 1,0,0,0,3923,3924,7,47,0,0,3924,3926,5,219,0,0,3925,3923,1,0,0,0, + 3925,3926,1,0,0,0,3926,3928,1,0,0,0,3927,3929,3,96,48,0,3928,3927, + 1,0,0,0,3928,3929,1,0,0,0,3929,321,1,0,0,0,3930,3932,5,81,0,0,3931, + 3930,1,0,0,0,3931,3932,1,0,0,0,3932,3933,1,0,0,0,3933,3935,3,774, + 387,0,3934,3936,5,9,0,0,3935,3934,1,0,0,0,3935,3936,1,0,0,0,3936, + 323,1,0,0,0,3937,3938,5,159,0,0,3938,3997,5,80,0,0,3939,3998,3,310, + 155,0,3940,3998,3,312,156,0,3941,3942,5,44,0,0,3942,3944,3,818,409, + 0,3943,3945,3,318,159,0,3944,3943,1,0,0,0,3944,3945,1,0,0,0,3945, + 3946,1,0,0,0,3946,3947,5,11,0,0,3947,3948,3,800,400,0,3948,3998, + 1,0,0,0,3949,3950,7,32,0,0,3950,3998,3,652,326,0,3951,3952,5,136, + 0,0,3952,3998,3,394,197,0,3953,3954,5,211,0,0,3954,3998,3,382,191, + 0,3955,3956,5,278,0,0,3956,3998,3,416,208,0,3957,3958,5,45,0,0,3958, + 3959,3,818,409,0,3959,3965,5,80,0,0,3960,3966,3,774,387,0,3961,3963, + 5,189,0,0,3962,3961,1,0,0,0,3962,3963,1,0,0,0,3963,3964,1,0,0,0, + 3964,3966,3,316,158,0,3965,3960,1,0,0,0,3965,3962,1,0,0,0,3966,3998, + 1,0,0,0,3967,3968,7,44,0,0,3968,3969,3,818,409,0,3969,3970,5,80, + 0,0,3970,3971,3,316,158,0,3971,3998,1,0,0,0,3972,3973,5,296,0,0, + 3973,3998,3,378,189,0,3974,3975,5,442,0,0,3975,3998,3,374,187,0, + 3976,3977,5,443,0,0,3977,3978,5,62,0,0,3978,3979,3,652,326,0,3979, + 3980,5,247,0,0,3980,3981,3,818,409,0,3981,3998,1,0,0,0,3982,3983, + 5,278,0,0,3983,3984,7,31,0,0,3984,3985,3,316,158,0,3985,3986,3,170, + 85,0,3986,3998,1,0,0,0,3987,3988,5,248,0,0,3988,3989,5,274,0,0,3989, + 3998,3,202,101,0,3990,3991,5,41,0,0,3991,3992,5,2,0,0,3992,3993, + 3,652,326,0,3993,3994,5,36,0,0,3994,3995,3,652,326,0,3995,3996,5, + 3,0,0,3996,3998,1,0,0,0,3997,3939,1,0,0,0,3997,3940,1,0,0,0,3997, + 3941,1,0,0,0,3997,3949,1,0,0,0,3997,3951,1,0,0,0,3997,3953,1,0,0, + 0,3997,3955,1,0,0,0,3997,3957,1,0,0,0,3997,3967,1,0,0,0,3997,3972, + 1,0,0,0,3997,3974,1,0,0,0,3997,3976,1,0,0,0,3997,3982,1,0,0,0,3997, + 3987,1,0,0,0,3997,3990,1,0,0,0,3998,3999,1,0,0,0,3999,4002,5,116, + 0,0,4000,4003,3,808,404,0,4001,4003,5,78,0,0,4002,4000,1,0,0,0,4002, + 4001,1,0,0,0,4003,325,1,0,0,0,4004,4005,5,327,0,0,4005,4008,5,246, + 0,0,4006,4007,5,62,0,0,4007,4009,3,58,29,0,4008,4006,1,0,0,0,4008, + 4009,1,0,0,0,4009,4010,1,0,0,0,4010,4028,5,80,0,0,4011,4012,7,32, + 0,0,4012,4029,3,652,326,0,4013,4014,5,136,0,0,4014,4029,3,394,197, + 0,4015,4016,5,44,0,0,4016,4029,3,800,400,0,4017,4018,5,211,0,0,4018, + 4029,3,382,191,0,4019,4020,5,248,0,0,4020,4021,5,274,0,0,4021,4029, + 3,202,101,0,4022,4023,5,296,0,0,4023,4029,3,378,189,0,4024,4025, + 5,442,0,0,4025,4029,3,374,187,0,4026,4029,3,310,155,0,4027,4029, + 3,312,156,0,4028,4011,1,0,0,0,4028,4013,1,0,0,0,4028,4015,1,0,0, + 0,4028,4017,1,0,0,0,4028,4019,1,0,0,0,4028,4022,1,0,0,0,4028,4024, + 1,0,0,0,4028,4026,1,0,0,0,4028,4027,1,0,0,0,4029,4030,1,0,0,0,4030, + 4033,5,116,0,0,4031,4034,3,808,404,0,4032,4034,5,78,0,0,4033,4031, + 1,0,0,0,4033,4032,1,0,0,0,4034,327,1,0,0,0,4035,4036,7,48,0,0,4036, + 4037,3,330,165,0,4037,329,1,0,0,0,4038,4040,7,49,0,0,4039,4038,1, + 0,0,0,4039,4040,1,0,0,0,4040,4042,1,0,0,0,4041,4043,3,332,166,0, + 4042,4041,1,0,0,0,4042,4043,1,0,0,0,4043,4044,1,0,0,0,4044,4082, + 3,818,409,0,4045,4047,7,50,0,0,4046,4045,1,0,0,0,4046,4047,1,0,0, + 0,4047,4048,1,0,0,0,4048,4050,3,812,406,0,4049,4051,3,332,166,0, + 4050,4049,1,0,0,0,4050,4051,1,0,0,0,4051,4052,1,0,0,0,4052,4053, + 3,818,409,0,4053,4082,1,0,0,0,4054,4056,5,210,0,0,4055,4057,3,812, + 406,0,4056,4055,1,0,0,0,4056,4057,1,0,0,0,4057,4059,1,0,0,0,4058, + 4060,3,332,166,0,4059,4058,1,0,0,0,4059,4060,1,0,0,0,4060,4061,1, + 0,0,0,4061,4082,3,818,409,0,4062,4064,5,210,0,0,4063,4062,1,0,0, + 0,4063,4064,1,0,0,0,4064,4065,1,0,0,0,4065,4067,5,30,0,0,4066,4068, + 3,332,166,0,4067,4066,1,0,0,0,4067,4068,1,0,0,0,4068,4069,1,0,0, + 0,4069,4082,3,818,409,0,4070,4075,5,144,0,0,4071,4073,5,30,0,0,4072, + 4071,1,0,0,0,4072,4073,1,0,0,0,4073,4076,1,0,0,0,4074,4076,3,812, + 406,0,4075,4072,1,0,0,0,4075,4074,1,0,0,0,4076,4078,1,0,0,0,4077, + 4079,3,332,166,0,4078,4077,1,0,0,0,4078,4079,1,0,0,0,4079,4080,1, + 0,0,0,4080,4082,3,818,409,0,4081,4039,1,0,0,0,4081,4046,1,0,0,0, + 4081,4054,1,0,0,0,4081,4063,1,0,0,0,4081,4070,1,0,0,0,4082,331,1, + 0,0,0,4083,4084,7,51,0,0,4084,333,1,0,0,0,4085,4086,5,65,0,0,4086, + 4087,3,338,169,0,4087,4088,5,80,0,0,4088,4089,3,344,172,0,4089,4090, + 5,94,0,0,4090,4094,3,346,173,0,4091,4092,5,105,0,0,4092,4093,5,65, + 0,0,4093,4095,5,279,0,0,4094,4091,1,0,0,0,4094,4095,1,0,0,0,4095, + 335,1,0,0,0,4096,4100,5,317,0,0,4097,4098,5,65,0,0,4098,4099,5,279, + 0,0,4099,4101,5,62,0,0,4100,4097,1,0,0,0,4100,4101,1,0,0,0,4101, + 4102,1,0,0,0,4102,4103,3,338,169,0,4103,4104,5,80,0,0,4104,4105, + 3,344,172,0,4105,4106,5,64,0,0,4106,4108,3,346,173,0,4107,4109,3, + 96,48,0,4108,4107,1,0,0,0,4108,4109,1,0,0,0,4109,337,1,0,0,0,4110, + 4115,3,342,171,0,4111,4112,5,6,0,0,4112,4114,3,342,171,0,4113,4111, + 1,0,0,0,4114,4117,1,0,0,0,4115,4113,1,0,0,0,4115,4116,1,0,0,0,4116, + 4134,1,0,0,0,4117,4115,1,0,0,0,4118,4120,5,30,0,0,4119,4121,5,294, + 0,0,4120,4119,1,0,0,0,4120,4121,1,0,0,0,4121,4123,1,0,0,0,4122,4124, + 3,144,72,0,4123,4122,1,0,0,0,4123,4124,1,0,0,0,4124,4134,1,0,0,0, + 4125,4130,3,340,170,0,4126,4127,5,6,0,0,4127,4129,3,340,170,0,4128, + 4126,1,0,0,0,4129,4132,1,0,0,0,4130,4128,1,0,0,0,4130,4131,1,0,0, + 0,4131,4134,1,0,0,0,4132,4130,1,0,0,0,4133,4110,1,0,0,0,4133,4118, + 1,0,0,0,4133,4125,1,0,0,0,4134,339,1,0,0,0,4135,4136,7,52,0,0,4136, + 341,1,0,0,0,4137,4142,5,88,0,0,4138,4142,5,86,0,0,4139,4142,5,46, + 0,0,4140,4142,3,818,409,0,4141,4137,1,0,0,0,4141,4138,1,0,0,0,4141, + 4139,1,0,0,0,4141,4140,1,0,0,0,4142,4144,1,0,0,0,4143,4145,3,144, + 72,0,4144,4143,1,0,0,0,4144,4145,1,0,0,0,4145,343,1,0,0,0,4146,4147, + 5,92,0,0,4147,4192,3,762,381,0,4148,4150,5,328,0,0,4149,4148,1,0, + 0,0,4149,4150,1,0,0,0,4150,4151,1,0,0,0,4151,4192,3,760,380,0,4152, + 4156,5,63,0,0,4153,4154,5,174,0,0,4154,4157,5,381,0,0,4155,4157, + 5,331,0,0,4156,4153,1,0,0,0,4156,4155,1,0,0,0,4157,4160,1,0,0,0, + 4158,4160,5,247,0,0,4159,4152,1,0,0,0,4159,4158,1,0,0,0,4160,4161, + 1,0,0,0,4161,4192,3,784,392,0,4162,4163,5,211,0,0,4163,4192,3,380, + 190,0,4164,4165,5,296,0,0,4165,4192,3,376,188,0,4166,4167,5,442, + 0,0,4167,4192,3,372,186,0,4168,4169,5,175,0,0,4169,4192,3,766,383, + 0,4170,4171,7,32,0,0,4171,4192,3,314,157,0,4172,4173,5,248,0,0,4173, + 4174,5,274,0,0,4174,4179,3,202,101,0,4175,4176,5,6,0,0,4176,4178, + 3,202,101,0,4177,4175,1,0,0,0,4178,4181,1,0,0,0,4179,4177,1,0,0, + 0,4179,4180,1,0,0,0,4180,4192,1,0,0,0,4181,4179,1,0,0,0,4182,4183, + 5,323,0,0,4183,4192,3,764,382,0,4184,4185,5,351,0,0,4185,4192,3, + 782,391,0,4186,4187,5,30,0,0,4187,4188,7,53,0,0,4188,4189,5,68,0, + 0,4189,4190,5,323,0,0,4190,4192,3,764,382,0,4191,4146,1,0,0,0,4191, + 4149,1,0,0,0,4191,4159,1,0,0,0,4191,4162,1,0,0,0,4191,4164,1,0,0, + 0,4191,4166,1,0,0,0,4191,4168,1,0,0,0,4191,4170,1,0,0,0,4191,4172, + 1,0,0,0,4191,4182,1,0,0,0,4191,4184,1,0,0,0,4191,4186,1,0,0,0,4192, + 345,1,0,0,0,4193,4195,5,66,0,0,4194,4193,1,0,0,0,4194,4195,1,0,0, + 0,4195,4196,1,0,0,0,4196,4197,3,814,407,0,4197,4205,1,0,0,0,4198, + 4200,5,6,0,0,4199,4201,5,66,0,0,4200,4199,1,0,0,0,4200,4201,1,0, + 0,0,4201,4202,1,0,0,0,4202,4204,3,814,407,0,4203,4198,1,0,0,0,4204, + 4207,1,0,0,0,4205,4203,1,0,0,0,4205,4206,1,0,0,0,4206,347,1,0,0, + 0,4207,4205,1,0,0,0,4208,4209,5,65,0,0,4209,4214,3,342,171,0,4210, + 4211,5,6,0,0,4211,4213,3,342,171,0,4212,4210,1,0,0,0,4213,4216,1, + 0,0,0,4214,4212,1,0,0,0,4214,4215,1,0,0,0,4215,4217,1,0,0,0,4216, + 4214,1,0,0,0,4217,4218,5,94,0,0,4218,4222,3,816,408,0,4219,4220, + 5,105,0,0,4220,4221,5,134,0,0,4221,4223,5,279,0,0,4222,4219,1,0, + 0,0,4222,4223,1,0,0,0,4223,4227,1,0,0,0,4224,4225,5,214,0,0,4225, + 4226,5,147,0,0,4226,4228,3,814,407,0,4227,4224,1,0,0,0,4227,4228, + 1,0,0,0,4228,349,1,0,0,0,4229,4233,5,317,0,0,4230,4231,5,134,0,0, + 4231,4232,5,279,0,0,4232,4234,5,62,0,0,4233,4230,1,0,0,0,4233,4234, + 1,0,0,0,4234,4235,1,0,0,0,4235,4240,3,342,171,0,4236,4237,5,6,0, + 0,4237,4239,3,342,171,0,4238,4236,1,0,0,0,4239,4242,1,0,0,0,4240, + 4238,1,0,0,0,4240,4241,1,0,0,0,4241,4243,1,0,0,0,4242,4240,1,0,0, + 0,4243,4244,5,64,0,0,4244,4248,3,816,408,0,4245,4246,5,214,0,0,4246, + 4247,5,147,0,0,4247,4249,3,814,407,0,4248,4245,1,0,0,0,4248,4249, + 1,0,0,0,4249,4251,1,0,0,0,4250,4252,3,96,48,0,4251,4250,1,0,0,0, + 4251,4252,1,0,0,0,4252,351,1,0,0,0,4253,4254,5,138,0,0,4254,4255, + 5,53,0,0,4255,4264,5,294,0,0,4256,4257,5,68,0,0,4257,4258,5,323, + 0,0,4258,4263,3,764,382,0,4259,4260,5,62,0,0,4260,4261,7,2,0,0,4261, + 4263,3,816,408,0,4262,4256,1,0,0,0,4262,4259,1,0,0,0,4263,4266,1, + 0,0,0,4264,4262,1,0,0,0,4264,4265,1,0,0,0,4265,4267,1,0,0,0,4266, + 4264,1,0,0,0,4267,4268,3,354,177,0,4268,353,1,0,0,0,4269,4270,5, + 65,0,0,4270,4271,3,338,169,0,4271,4272,5,80,0,0,4272,4273,3,356, + 178,0,4273,4274,5,94,0,0,4274,4278,3,346,173,0,4275,4276,5,105,0, + 0,4276,4277,5,65,0,0,4277,4279,5,279,0,0,4278,4275,1,0,0,0,4278, + 4279,1,0,0,0,4279,4295,1,0,0,0,4280,4284,5,317,0,0,4281,4282,5,65, + 0,0,4282,4283,5,279,0,0,4283,4285,5,62,0,0,4284,4281,1,0,0,0,4284, + 4285,1,0,0,0,4285,4286,1,0,0,0,4286,4287,3,338,169,0,4287,4288,5, + 80,0,0,4288,4289,3,356,178,0,4289,4290,5,64,0,0,4290,4292,3,346, + 173,0,4291,4293,3,96,48,0,4292,4291,1,0,0,0,4292,4293,1,0,0,0,4293, + 4295,1,0,0,0,4294,4269,1,0,0,0,4294,4280,1,0,0,0,4295,355,1,0,0, + 0,4296,4297,7,54,0,0,4297,357,1,0,0,0,4298,4300,5,46,0,0,4299,4301, + 5,98,0,0,4300,4299,1,0,0,0,4300,4301,1,0,0,0,4301,4302,1,0,0,0,4302, + 4304,5,226,0,0,4303,4305,5,109,0,0,4304,4303,1,0,0,0,4304,4305,1, + 0,0,0,4305,4307,1,0,0,0,4306,4308,3,294,147,0,4307,4306,1,0,0,0, + 4307,4308,1,0,0,0,4308,4310,1,0,0,0,4309,4311,3,818,409,0,4310,4309, + 1,0,0,0,4310,4311,1,0,0,0,4311,4312,1,0,0,0,4312,4313,5,80,0,0,4313, + 4315,3,624,312,0,4314,4316,3,170,85,0,4315,4314,1,0,0,0,4315,4316, + 1,0,0,0,4316,4317,1,0,0,0,4317,4320,3,360,180,0,4318,4319,5,441, + 0,0,4319,4321,3,360,180,0,4320,4318,1,0,0,0,4320,4321,1,0,0,0,4321, + 4327,1,0,0,0,4322,4324,5,273,0,0,4323,4325,5,77,0,0,4324,4323,1, + 0,0,0,4324,4325,1,0,0,0,4325,4326,1,0,0,0,4326,4328,5,56,0,0,4327, + 4322,1,0,0,0,4327,4328,1,0,0,0,4328,4330,1,0,0,0,4329,4331,3,102, + 51,0,4330,4329,1,0,0,0,4330,4331,1,0,0,0,4331,4333,1,0,0,0,4332, + 4334,3,176,88,0,4333,4332,1,0,0,0,4333,4334,1,0,0,0,4334,4336,1, + 0,0,0,4335,4337,3,638,319,0,4336,4335,1,0,0,0,4336,4337,1,0,0,0, + 4337,359,1,0,0,0,4338,4339,5,2,0,0,4339,4344,3,362,181,0,4340,4341, + 5,6,0,0,4341,4343,3,362,181,0,4342,4340,1,0,0,0,4343,4346,1,0,0, + 0,4344,4342,1,0,0,0,4344,4345,1,0,0,0,4345,4347,1,0,0,0,4346,4344, + 1,0,0,0,4347,4348,5,3,0,0,4348,361,1,0,0,0,4349,4356,3,800,400,0, + 4350,4356,3,688,344,0,4351,4352,5,2,0,0,4352,4353,3,674,337,0,4353, + 4354,5,3,0,0,4354,4356,1,0,0,0,4355,4349,1,0,0,0,4355,4350,1,0,0, + 0,4355,4351,1,0,0,0,4356,4358,1,0,0,0,4357,4359,3,98,49,0,4358,4357, + 1,0,0,0,4358,4359,1,0,0,0,4359,4366,1,0,0,0,4360,4362,3,316,158, + 0,4361,4360,1,0,0,0,4361,4362,1,0,0,0,4362,4367,1,0,0,0,4363,4364, + 3,316,158,0,4364,4365,3,100,50,0,4365,4367,1,0,0,0,4366,4361,1,0, + 0,0,4366,4363,1,0,0,0,4367,4369,1,0,0,0,4368,4370,7,55,0,0,4369, + 4368,1,0,0,0,4369,4370,1,0,0,0,4370,4373,1,0,0,0,4371,4372,5,273, + 0,0,4372,4374,7,56,0,0,4373,4371,1,0,0,0,4373,4374,1,0,0,0,4374, + 363,1,0,0,0,4375,4377,5,46,0,0,4376,4378,3,366,183,0,4377,4376,1, + 0,0,0,4377,4378,1,0,0,0,4378,4383,1,0,0,0,4379,4380,5,211,0,0,4380, + 4384,3,804,402,0,4381,4382,5,296,0,0,4382,4384,3,798,399,0,4383, + 4379,1,0,0,0,4383,4381,1,0,0,0,4384,4385,1,0,0,0,4385,4394,5,2,0, + 0,4386,4391,3,390,195,0,4387,4388,5,6,0,0,4388,4390,3,390,195,0, + 4389,4387,1,0,0,0,4390,4393,1,0,0,0,4391,4389,1,0,0,0,4391,4392, + 1,0,0,0,4392,4395,1,0,0,0,4393,4391,1,0,0,0,4394,4386,1,0,0,0,4394, + 4395,1,0,0,0,4395,4396,1,0,0,0,4396,4397,5,3,0,0,4397,4414,1,0,0, + 0,4398,4412,5,316,0,0,4399,4413,3,388,194,0,4400,4401,5,92,0,0,4401, + 4402,5,2,0,0,4402,4407,3,402,201,0,4403,4404,5,6,0,0,4404,4406,3, + 402,201,0,4405,4403,1,0,0,0,4406,4409,1,0,0,0,4407,4405,1,0,0,0, + 4407,4408,1,0,0,0,4408,4410,1,0,0,0,4409,4407,1,0,0,0,4410,4411, + 5,3,0,0,4411,4413,1,0,0,0,4412,4399,1,0,0,0,4412,4400,1,0,0,0,4413, + 4415,1,0,0,0,4414,4398,1,0,0,0,4414,4415,1,0,0,0,4415,4417,1,0,0, + 0,4416,4418,3,398,199,0,4417,4416,1,0,0,0,4418,4419,1,0,0,0,4419, + 4417,1,0,0,0,4419,4420,1,0,0,0,4420,4426,1,0,0,0,4421,4422,5,105, + 0,0,4422,4423,5,2,0,0,4423,4424,3,784,392,0,4424,4425,5,3,0,0,4425, + 4427,1,0,0,0,4426,4421,1,0,0,0,4426,4427,1,0,0,0,4427,365,1,0,0, + 0,4428,4429,5,82,0,0,4429,4430,5,311,0,0,4430,367,1,0,0,0,4431,4433, + 5,2,0,0,4432,4434,3,370,185,0,4433,4432,1,0,0,0,4433,4434,1,0,0, + 0,4434,4435,1,0,0,0,4435,4436,5,3,0,0,4436,369,1,0,0,0,4437,4442, + 3,384,192,0,4438,4439,5,6,0,0,4439,4441,3,384,192,0,4440,4438,1, + 0,0,0,4441,4444,1,0,0,0,4442,4440,1,0,0,0,4442,4443,1,0,0,0,4443, + 371,1,0,0,0,4444,4442,1,0,0,0,4445,4450,3,374,187,0,4446,4447,5, + 6,0,0,4447,4449,3,374,187,0,4448,4446,1,0,0,0,4449,4452,1,0,0,0, + 4450,4448,1,0,0,0,4450,4451,1,0,0,0,4451,373,1,0,0,0,4452,4450,1, + 0,0,0,4453,4454,3,794,397,0,4454,4455,3,368,184,0,4455,4459,1,0, + 0,0,4456,4459,3,832,416,0,4457,4459,3,780,390,0,4458,4453,1,0,0, + 0,4458,4456,1,0,0,0,4458,4457,1,0,0,0,4459,375,1,0,0,0,4460,4465, + 3,378,189,0,4461,4462,5,6,0,0,4462,4464,3,378,189,0,4463,4461,1, + 0,0,0,4464,4467,1,0,0,0,4465,4463,1,0,0,0,4465,4466,1,0,0,0,4466, + 377,1,0,0,0,4467,4465,1,0,0,0,4468,4469,3,796,398,0,4469,4470,3, + 368,184,0,4470,4474,1,0,0,0,4471,4474,3,832,416,0,4472,4474,3,780, + 390,0,4473,4468,1,0,0,0,4473,4471,1,0,0,0,4473,4472,1,0,0,0,4474, + 379,1,0,0,0,4475,4480,3,382,191,0,4476,4477,5,6,0,0,4477,4479,3, + 382,191,0,4478,4476,1,0,0,0,4479,4482,1,0,0,0,4480,4478,1,0,0,0, + 4480,4481,1,0,0,0,4481,381,1,0,0,0,4482,4480,1,0,0,0,4483,4484,3, + 806,403,0,4484,4485,3,368,184,0,4485,4489,1,0,0,0,4486,4489,3,832, + 416,0,4487,4489,3,780,390,0,4488,4483,1,0,0,0,4488,4486,1,0,0,0, + 4488,4487,1,0,0,0,4489,383,1,0,0,0,4490,4492,3,386,193,0,4491,4493, + 3,820,410,0,4492,4491,1,0,0,0,4492,4493,1,0,0,0,4493,4499,1,0,0, + 0,4494,4496,3,820,410,0,4495,4497,3,386,193,0,4496,4495,1,0,0,0, + 4496,4497,1,0,0,0,4497,4499,1,0,0,0,4498,4490,1,0,0,0,4498,4494, + 1,0,0,0,4498,4499,1,0,0,0,4499,4500,1,0,0,0,4500,4501,3,388,194, + 0,4501,385,1,0,0,0,4502,4504,5,68,0,0,4503,4505,5,453,0,0,4504,4503, + 1,0,0,0,4504,4505,1,0,0,0,4505,4510,1,0,0,0,4506,4510,5,453,0,0, + 4507,4510,5,400,0,0,4508,4510,5,101,0,0,4509,4502,1,0,0,0,4509,4506, + 1,0,0,0,4509,4507,1,0,0,0,4509,4508,1,0,0,0,4510,387,1,0,0,0,4511, + 4521,3,652,326,0,4512,4514,5,415,0,0,4513,4512,1,0,0,0,4513,4514, + 1,0,0,0,4514,4515,1,0,0,0,4515,4516,3,820,410,0,4516,4517,3,318, + 159,0,4517,4518,5,27,0,0,4518,4519,5,360,0,0,4519,4521,1,0,0,0,4520, + 4511,1,0,0,0,4520,4513,1,0,0,0,4521,389,1,0,0,0,4522,4525,3,384, + 192,0,4523,4524,7,57,0,0,4524,4526,3,674,337,0,4525,4523,1,0,0,0, + 4525,4526,1,0,0,0,4526,391,1,0,0,0,4527,4537,5,2,0,0,4528,4538,5, + 9,0,0,4529,4531,3,370,185,0,4530,4529,1,0,0,0,4530,4531,1,0,0,0, + 4531,4535,1,0,0,0,4532,4533,5,83,0,0,4533,4534,5,147,0,0,4534,4536, + 3,370,185,0,4535,4532,1,0,0,0,4535,4536,1,0,0,0,4536,4538,1,0,0, + 0,4537,4528,1,0,0,0,4537,4530,1,0,0,0,4538,4539,1,0,0,0,4539,4540, + 5,3,0,0,4540,393,1,0,0,0,4541,4542,3,806,403,0,4542,4543,3,392,196, + 0,4543,395,1,0,0,0,4544,4545,5,316,0,0,4545,4548,5,78,0,0,4546,4548, + 5,149,0,0,4547,4544,1,0,0,0,4547,4546,1,0,0,0,4548,4549,1,0,0,0, + 4549,4550,5,80,0,0,4550,4551,5,78,0,0,4551,4574,5,458,0,0,4552,4574, + 5,346,0,0,4553,4574,5,222,0,0,4554,4574,5,338,0,0,4555,4574,5,377, + 0,0,4556,4558,5,205,0,0,4557,4556,1,0,0,0,4557,4558,1,0,0,0,4558, + 4559,1,0,0,0,4559,4560,5,327,0,0,4560,4574,7,58,0,0,4561,4574,5, + 250,0,0,4562,4563,5,77,0,0,4563,4574,5,250,0,0,4564,4565,7,59,0, + 0,4565,4574,3,202,101,0,4566,4567,5,459,0,0,4567,4574,3,316,158, + 0,4568,4569,5,333,0,0,4569,4574,3,42,21,0,4570,4574,3,60,30,0,4571, + 4572,5,460,0,0,4572,4574,3,818,409,0,4573,4547,1,0,0,0,4573,4552, + 1,0,0,0,4573,4553,1,0,0,0,4573,4554,1,0,0,0,4573,4555,1,0,0,0,4573, + 4557,1,0,0,0,4573,4561,1,0,0,0,4573,4562,1,0,0,0,4573,4564,1,0,0, + 0,4573,4566,1,0,0,0,4573,4568,1,0,0,0,4573,4570,1,0,0,0,4573,4571, + 1,0,0,0,4574,397,1,0,0,0,4575,4576,5,36,0,0,4576,4577,3,808,404, + 0,4577,4578,3,462,231,0,4578,4611,1,0,0,0,4579,4580,5,247,0,0,4580, + 4611,3,58,29,0,4581,4582,5,443,0,0,4582,4583,5,62,0,0,4583,4584, + 5,360,0,0,4584,4591,3,652,326,0,4585,4586,5,6,0,0,4586,4587,5,62, + 0,0,4587,4588,5,360,0,0,4588,4590,3,652,326,0,4589,4585,1,0,0,0, + 4590,4593,1,0,0,0,4591,4589,1,0,0,0,4591,4592,1,0,0,0,4592,4611, + 1,0,0,0,4593,4591,1,0,0,0,4594,4611,5,104,0,0,4595,4596,5,333,0, + 0,4596,4603,3,818,409,0,4597,4598,5,94,0,0,4598,4604,3,818,409,0, + 4599,4600,5,10,0,0,4600,4604,3,818,409,0,4601,4602,5,64,0,0,4602, + 4604,5,434,0,0,4603,4597,1,0,0,0,4603,4599,1,0,0,0,4603,4601,1,0, + 0,0,4604,4611,1,0,0,0,4605,4606,5,36,0,0,4606,4611,3,818,409,0,4607, + 4611,3,4,2,0,4608,4611,3,396,198,0,4609,4611,3,818,409,0,4610,4575, + 1,0,0,0,4610,4579,1,0,0,0,4610,4581,1,0,0,0,4610,4594,1,0,0,0,4610, + 4595,1,0,0,0,4610,4605,1,0,0,0,4610,4607,1,0,0,0,4610,4608,1,0,0, + 0,4610,4609,1,0,0,0,4611,399,1,0,0,0,4612,4613,5,105,0,0,4613,4614, + 3,284,142,0,4614,401,1,0,0,0,4615,4616,3,800,400,0,4616,4617,3,388, + 194,0,4617,403,1,0,0,0,4618,4625,5,138,0,0,4619,4620,5,211,0,0,4620, + 4626,3,382,191,0,4621,4622,5,296,0,0,4622,4626,3,378,189,0,4623, + 4624,5,442,0,0,4624,4626,3,374,187,0,4625,4619,1,0,0,0,4625,4621, + 1,0,0,0,4625,4623,1,0,0,0,4626,4628,1,0,0,0,4627,4629,3,396,198, + 0,4628,4627,1,0,0,0,4629,4630,1,0,0,0,4630,4628,1,0,0,0,4630,4631, + 1,0,0,0,4631,4633,1,0,0,0,4632,4634,5,315,0,0,4633,4632,1,0,0,0, + 4633,4634,1,0,0,0,4634,405,1,0,0,0,4635,4651,5,191,0,0,4636,4638, + 5,211,0,0,4637,4639,3,422,211,0,4638,4637,1,0,0,0,4638,4639,1,0, + 0,0,4639,4640,1,0,0,0,4640,4652,3,380,190,0,4641,4643,5,296,0,0, + 4642,4644,3,422,211,0,4643,4642,1,0,0,0,4643,4644,1,0,0,0,4644,4645, + 1,0,0,0,4645,4652,3,376,188,0,4646,4648,5,442,0,0,4647,4649,3,422, + 211,0,4648,4647,1,0,0,0,4648,4649,1,0,0,0,4649,4650,1,0,0,0,4650, + 4652,3,372,186,0,4651,4636,1,0,0,0,4651,4641,1,0,0,0,4651,4646,1, + 0,0,0,4652,4654,1,0,0,0,4653,4655,3,96,48,0,4654,4653,1,0,0,0,4654, + 4655,1,0,0,0,4655,407,1,0,0,0,4656,4657,5,191,0,0,4657,4659,5,136, + 0,0,4658,4660,3,422,211,0,4659,4658,1,0,0,0,4659,4660,1,0,0,0,4660, + 4661,1,0,0,0,4661,4666,3,394,197,0,4662,4663,5,6,0,0,4663,4665,3, + 394,197,0,4664,4662,1,0,0,0,4665,4668,1,0,0,0,4666,4664,1,0,0,0, + 4666,4667,1,0,0,0,4667,4670,1,0,0,0,4668,4666,1,0,0,0,4669,4671, + 3,96,48,0,4670,4669,1,0,0,0,4670,4671,1,0,0,0,4671,409,1,0,0,0,4672, + 4673,5,191,0,0,4673,4675,5,278,0,0,4674,4676,3,422,211,0,4675,4674, + 1,0,0,0,4675,4676,1,0,0,0,4676,4677,1,0,0,0,4677,4682,3,416,208, + 0,4678,4679,5,6,0,0,4679,4681,3,416,208,0,4680,4678,1,0,0,0,4681, + 4684,1,0,0,0,4682,4680,1,0,0,0,4682,4683,1,0,0,0,4683,4686,1,0,0, + 0,4684,4682,1,0,0,0,4685,4687,3,96,48,0,4686,4685,1,0,0,0,4686,4687, + 1,0,0,0,4687,411,1,0,0,0,4688,4701,5,2,0,0,4689,4692,3,652,326,0, + 4690,4691,5,6,0,0,4691,4693,3,652,326,0,4692,4690,1,0,0,0,4692,4693, + 1,0,0,0,4693,4702,1,0,0,0,4694,4695,5,407,0,0,4695,4696,5,6,0,0, + 4696,4702,3,652,326,0,4697,4698,3,652,326,0,4698,4699,5,6,0,0,4699, + 4700,5,407,0,0,4700,4702,1,0,0,0,4701,4689,1,0,0,0,4701,4694,1,0, + 0,0,4701,4697,1,0,0,0,4702,4703,1,0,0,0,4703,4704,5,3,0,0,4704,413, + 1,0,0,0,4705,4706,3,818,409,0,4706,4707,5,11,0,0,4707,4709,1,0,0, + 0,4708,4705,1,0,0,0,4709,4712,1,0,0,0,4710,4708,1,0,0,0,4710,4711, + 1,0,0,0,4711,4713,1,0,0,0,4712,4710,1,0,0,0,4713,4714,3,720,360, + 0,4714,415,1,0,0,0,4715,4716,3,414,207,0,4716,4717,3,412,206,0,4717, + 417,1,0,0,0,4718,4722,5,57,0,0,4719,4723,3,808,404,0,4720,4721,5, + 247,0,0,4721,4723,3,58,29,0,4722,4719,1,0,0,0,4722,4720,1,0,0,0, + 4723,4724,1,0,0,0,4724,4722,1,0,0,0,4724,4725,1,0,0,0,4725,419,1, + 0,0,0,4726,4727,5,46,0,0,4727,4728,5,41,0,0,4728,4729,5,2,0,0,4729, + 4730,3,652,326,0,4730,4731,5,36,0,0,4731,4732,3,652,326,0,4732,4749, + 5,3,0,0,4733,4734,5,379,0,0,4734,4737,5,211,0,0,4735,4736,5,36,0, + 0,4736,4738,7,60,0,0,4737,4735,1,0,0,0,4737,4738,1,0,0,0,4738,4750, + 1,0,0,0,4739,4743,5,105,0,0,4740,4741,5,211,0,0,4741,4744,3,382, + 191,0,4742,4744,5,400,0,0,4743,4740,1,0,0,0,4743,4742,1,0,0,0,4744, + 4747,1,0,0,0,4745,4746,5,36,0,0,4746,4748,7,60,0,0,4747,4745,1,0, + 0,0,4747,4748,1,0,0,0,4748,4750,1,0,0,0,4749,4733,1,0,0,0,4749,4739, + 1,0,0,0,4750,421,1,0,0,0,4751,4752,5,220,0,0,4752,4753,5,396,0,0, + 4753,423,1,0,0,0,4754,4756,5,46,0,0,4755,4757,3,366,183,0,4756,4755, + 1,0,0,0,4756,4757,1,0,0,0,4757,4758,1,0,0,0,4758,4759,5,443,0,0, + 4759,4760,5,62,0,0,4760,4761,3,652,326,0,4761,4762,5,247,0,0,4762, + 4763,3,818,409,0,4763,4778,5,2,0,0,4764,4765,5,64,0,0,4765,4769, + 3,426,213,0,4766,4767,5,6,0,0,4767,4768,5,94,0,0,4768,4770,3,426, + 213,0,4769,4766,1,0,0,0,4769,4770,1,0,0,0,4770,4779,1,0,0,0,4771, + 4772,5,94,0,0,4772,4776,3,426,213,0,4773,4774,5,6,0,0,4774,4775, + 5,64,0,0,4775,4777,3,426,213,0,4776,4773,1,0,0,0,4776,4777,1,0,0, + 0,4777,4779,1,0,0,0,4778,4764,1,0,0,0,4778,4771,1,0,0,0,4779,4780, + 1,0,0,0,4780,4781,5,3,0,0,4781,425,1,0,0,0,4782,4783,5,461,0,0,4783, + 4784,5,105,0,0,4784,4785,5,211,0,0,4785,4786,3,382,191,0,4786,427, + 1,0,0,0,4787,4798,5,306,0,0,4788,4789,5,2,0,0,4789,4794,5,128,0, + 0,4790,4791,5,6,0,0,4791,4793,5,128,0,0,4792,4790,1,0,0,0,4793,4796, + 1,0,0,0,4794,4792,1,0,0,0,4794,4795,1,0,0,0,4795,4797,1,0,0,0,4796, + 4794,1,0,0,0,4797,4799,5,3,0,0,4798,4788,1,0,0,0,4798,4799,1,0,0, + 0,4799,4825,1,0,0,0,4800,4802,5,226,0,0,4801,4803,5,109,0,0,4802, + 4801,1,0,0,0,4802,4803,1,0,0,0,4803,4804,1,0,0,0,4804,4826,3,780, + 390,0,4805,4807,5,92,0,0,4806,4808,5,109,0,0,4807,4806,1,0,0,0,4807, + 4808,1,0,0,0,4808,4809,1,0,0,0,4809,4826,3,774,387,0,4810,4812,5, + 323,0,0,4811,4813,5,109,0,0,4812,4811,1,0,0,0,4812,4813,1,0,0,0, + 4813,4814,1,0,0,0,4814,4826,3,790,395,0,4815,4817,5,349,0,0,4816, + 4818,5,109,0,0,4817,4816,1,0,0,0,4817,4818,1,0,0,0,4818,4819,1,0, + 0,0,4819,4826,3,818,409,0,4820,4822,5,175,0,0,4821,4823,5,109,0, + 0,4822,4821,1,0,0,0,4822,4823,1,0,0,0,4823,4824,1,0,0,0,4824,4826, + 3,788,394,0,4825,4800,1,0,0,0,4825,4805,1,0,0,0,4825,4810,1,0,0, + 0,4825,4815,1,0,0,0,4825,4820,1,0,0,0,4826,429,1,0,0,0,4827,4828, + 5,138,0,0,4828,4829,3,176,88,0,4829,4830,7,16,0,0,4830,4831,3,100, + 50,0,4831,431,1,0,0,0,4832,4837,5,138,0,0,4833,4834,5,136,0,0,4834, + 4838,3,394,197,0,4835,4836,5,442,0,0,4836,4838,3,374,187,0,4837, + 4833,1,0,0,0,4837,4835,1,0,0,0,4838,4839,1,0,0,0,4839,4840,5,309, + 0,0,4840,4841,5,94,0,0,4841,4842,3,818,409,0,4842,5040,1,0,0,0,4843, + 4844,5,138,0,0,4844,4845,5,175,0,0,4845,4846,3,788,394,0,4846,4847, + 5,309,0,0,4847,4848,5,94,0,0,4848,4849,3,786,393,0,4849,5040,1,0, + 0,0,4850,4851,5,138,0,0,4851,4852,7,61,0,0,4852,4853,3,316,158,0, + 4853,4854,5,309,0,0,4854,4855,5,94,0,0,4855,4856,3,818,409,0,4856, + 5040,1,0,0,0,4857,4858,5,138,0,0,4858,4859,5,211,0,0,4859,4860,3, + 382,191,0,4860,4861,5,309,0,0,4861,4862,5,94,0,0,4862,4863,3,804, + 402,0,4863,5040,1,0,0,0,4864,4865,5,138,0,0,4865,4866,5,278,0,0, + 4866,4867,7,31,0,0,4867,4868,3,316,158,0,4868,4869,3,170,85,0,4869, + 4870,5,309,0,0,4870,4871,5,94,0,0,4871,4872,3,818,409,0,4872,5040, + 1,0,0,0,4873,4874,5,138,0,0,4874,4875,5,296,0,0,4875,4876,3,378, + 189,0,4876,4877,5,309,0,0,4877,4878,5,94,0,0,4878,4879,3,798,399, + 0,4879,5040,1,0,0,0,4880,4881,5,138,0,0,4881,4882,5,323,0,0,4882, + 4883,3,790,395,0,4883,4884,5,309,0,0,4884,4885,5,94,0,0,4885,4886, + 3,32,16,0,4886,5040,1,0,0,0,4887,4888,5,138,0,0,4888,4890,7,62,0, + 0,4889,4891,3,422,211,0,4890,4889,1,0,0,0,4890,4891,1,0,0,0,4891, + 4892,1,0,0,0,4892,4893,3,780,390,0,4893,4894,5,309,0,0,4894,4895, + 5,94,0,0,4895,4896,3,818,409,0,4896,5040,1,0,0,0,4897,4899,5,138, + 0,0,4898,4900,5,259,0,0,4899,4898,1,0,0,0,4899,4900,1,0,0,0,4900, + 4901,1,0,0,0,4901,4903,5,376,0,0,4902,4904,3,422,211,0,4903,4902, + 1,0,0,0,4903,4904,1,0,0,0,4904,4905,1,0,0,0,4905,4906,3,778,389, + 0,4906,4907,5,309,0,0,4907,4908,5,94,0,0,4908,4909,3,776,388,0,4909, + 5040,1,0,0,0,4910,4912,5,138,0,0,4911,4913,5,63,0,0,4912,4911,1, + 0,0,0,4912,4913,1,0,0,0,4913,4914,1,0,0,0,4914,4916,5,92,0,0,4915, + 4917,3,422,211,0,4916,4915,1,0,0,0,4916,4917,1,0,0,0,4917,4918,1, + 0,0,0,4918,4919,3,624,312,0,4919,4920,5,309,0,0,4920,4921,5,94,0, + 0,4921,4922,3,772,386,0,4922,5040,1,0,0,0,4923,4948,5,138,0,0,4924, + 4926,5,63,0,0,4925,4924,1,0,0,0,4925,4926,1,0,0,0,4926,4927,1,0, + 0,0,4927,4929,5,92,0,0,4928,4930,3,422,211,0,4929,4928,1,0,0,0,4929, + 4930,1,0,0,0,4930,4931,1,0,0,0,4931,4932,3,624,312,0,4932,4934,5, + 309,0,0,4933,4935,5,44,0,0,4934,4933,1,0,0,0,4934,4935,1,0,0,0,4935, + 4949,1,0,0,0,4936,4938,5,259,0,0,4937,4936,1,0,0,0,4937,4938,1,0, + 0,0,4938,4939,1,0,0,0,4939,4941,5,376,0,0,4940,4942,3,422,211,0, + 4941,4940,1,0,0,0,4941,4942,1,0,0,0,4942,4943,1,0,0,0,4943,4944, + 3,778,389,0,4944,4946,5,309,0,0,4945,4947,5,44,0,0,4946,4945,1,0, + 0,0,4946,4947,1,0,0,0,4947,4949,1,0,0,0,4948,4925,1,0,0,0,4948,4937, + 1,0,0,0,4949,4950,1,0,0,0,4950,4951,3,800,400,0,4951,4952,5,94,0, + 0,4952,4953,3,802,401,0,4953,5040,1,0,0,0,4954,4962,5,138,0,0,4955, + 4957,5,92,0,0,4956,4958,3,422,211,0,4957,4956,1,0,0,0,4957,4958, + 1,0,0,0,4958,4959,1,0,0,0,4959,4963,3,624,312,0,4960,4961,5,189, + 0,0,4961,4963,3,316,158,0,4962,4955,1,0,0,0,4962,4960,1,0,0,0,4963, + 4964,1,0,0,0,4964,4965,5,309,0,0,4965,4966,5,45,0,0,4966,4967,3, + 818,409,0,4967,4968,5,94,0,0,4968,4969,3,818,409,0,4969,5040,1,0, + 0,0,4970,4977,5,138,0,0,4971,4973,5,445,0,0,4972,4974,3,422,211, + 0,4973,4972,1,0,0,0,4973,4974,1,0,0,0,4974,4978,1,0,0,0,4975,4978, + 5,321,0,0,4976,4978,5,357,0,0,4977,4971,1,0,0,0,4977,4975,1,0,0, + 0,4977,4976,1,0,0,0,4978,4979,1,0,0,0,4979,4980,3,818,409,0,4980, + 4981,5,80,0,0,4981,4982,3,780,390,0,4982,4983,5,309,0,0,4983,4984, + 5,94,0,0,4984,4985,3,818,409,0,4985,5040,1,0,0,0,4986,4999,5,138, + 0,0,4987,4988,5,63,0,0,4988,4989,5,174,0,0,4989,5000,5,381,0,0,4990, + 4992,5,295,0,0,4991,4990,1,0,0,0,4991,4992,1,0,0,0,4992,4993,1,0, + 0,0,4993,5000,5,247,0,0,4994,5000,5,452,0,0,4995,5000,5,331,0,0, + 4996,5000,5,451,0,0,4997,4998,5,198,0,0,4998,5000,5,357,0,0,4999, + 4987,1,0,0,0,4999,4991,1,0,0,0,4999,4994,1,0,0,0,4999,4995,1,0,0, + 0,4999,4996,1,0,0,0,4999,4997,1,0,0,0,5000,5001,1,0,0,0,5001,5002, + 3,818,409,0,5002,5003,5,309,0,0,5003,5004,5,94,0,0,5004,5005,3,818, + 409,0,5005,5040,1,0,0,0,5006,5007,5,138,0,0,5007,5008,7,45,0,0,5008, + 5009,3,814,407,0,5009,5010,5,309,0,0,5010,5011,5,94,0,0,5011,5012, + 3,814,407,0,5012,5040,1,0,0,0,5013,5014,5,138,0,0,5014,5015,3,176, + 88,0,5015,5016,5,309,0,0,5016,5017,5,94,0,0,5017,5018,3,768,384, + 0,5018,5040,1,0,0,0,5019,5020,5,138,0,0,5020,5021,5,355,0,0,5021, + 5022,5,325,0,0,5022,5023,7,41,0,0,5023,5024,3,316,158,0,5024,5025, + 5,309,0,0,5025,5026,5,94,0,0,5026,5027,3,818,409,0,5027,5040,1,0, + 0,0,5028,5029,5,138,0,0,5029,5030,5,360,0,0,5030,5031,3,316,158, + 0,5031,5032,5,309,0,0,5032,5033,5,143,0,0,5033,5034,3,818,409,0, + 5034,5035,5,94,0,0,5035,5037,3,818,409,0,5036,5038,3,96,48,0,5037, + 5036,1,0,0,0,5037,5038,1,0,0,0,5038,5040,1,0,0,0,5039,4832,1,0,0, + 0,5039,4843,1,0,0,0,5039,4850,1,0,0,0,5039,4857,1,0,0,0,5039,4864, + 1,0,0,0,5039,4873,1,0,0,0,5039,4880,1,0,0,0,5039,4887,1,0,0,0,5039, + 4897,1,0,0,0,5039,4910,1,0,0,0,5039,4923,1,0,0,0,5039,4954,1,0,0, + 0,5039,4970,1,0,0,0,5039,4986,1,0,0,0,5039,5006,1,0,0,0,5039,5013, + 1,0,0,0,5039,5019,1,0,0,0,5039,5028,1,0,0,0,5040,433,1,0,0,0,5041, + 5058,5,138,0,0,5042,5043,5,211,0,0,5043,5059,3,382,191,0,5044,5045, + 5,296,0,0,5045,5059,3,378,189,0,5046,5047,5,442,0,0,5047,5059,3, + 374,187,0,5048,5049,5,357,0,0,5049,5050,3,818,409,0,5050,5051,5, + 80,0,0,5051,5052,3,780,390,0,5052,5059,1,0,0,0,5053,5054,5,259,0, + 0,5054,5055,5,376,0,0,5055,5059,3,778,389,0,5056,5057,5,226,0,0, + 5057,5059,3,780,390,0,5058,5042,1,0,0,0,5058,5044,1,0,0,0,5058,5046, + 1,0,0,0,5058,5048,1,0,0,0,5058,5053,1,0,0,0,5058,5056,1,0,0,0,5059, + 5061,1,0,0,0,5060,5062,5,269,0,0,5061,5060,1,0,0,0,5061,5062,1,0, + 0,0,5062,5063,1,0,0,0,5063,5064,5,462,0,0,5064,5065,5,80,0,0,5065, + 5066,5,204,0,0,5066,5067,3,818,409,0,5067,435,1,0,0,0,5068,5107, + 5,138,0,0,5069,5070,5,136,0,0,5070,5108,3,394,197,0,5071,5072,5, + 204,0,0,5072,5108,3,818,409,0,5073,5074,5,211,0,0,5074,5108,3,382, + 191,0,5075,5076,5,278,0,0,5076,5108,3,416,208,0,5077,5078,5,278, + 0,0,5078,5079,7,31,0,0,5079,5080,3,316,158,0,5080,5081,3,170,85, + 0,5081,5108,1,0,0,0,5082,5083,5,296,0,0,5083,5108,3,378,189,0,5084, + 5085,5,442,0,0,5085,5108,3,374,187,0,5086,5088,5,328,0,0,5087,5089, + 3,422,211,0,5088,5087,1,0,0,0,5088,5089,1,0,0,0,5089,5090,1,0,0, + 0,5090,5108,3,780,390,0,5091,5093,5,259,0,0,5092,5091,1,0,0,0,5092, + 5093,1,0,0,0,5093,5094,1,0,0,0,5094,5096,5,376,0,0,5095,5097,3,422, + 211,0,5096,5095,1,0,0,0,5096,5097,1,0,0,0,5097,5098,1,0,0,0,5098, + 5108,3,778,389,0,5099,5101,5,63,0,0,5100,5099,1,0,0,0,5100,5101, + 1,0,0,0,5101,5102,1,0,0,0,5102,5104,5,92,0,0,5103,5105,3,422,211, + 0,5104,5103,1,0,0,0,5104,5105,1,0,0,0,5105,5106,1,0,0,0,5106,5108, + 3,624,312,0,5107,5069,1,0,0,0,5107,5071,1,0,0,0,5107,5073,1,0,0, + 0,5107,5075,1,0,0,0,5107,5077,1,0,0,0,5107,5082,1,0,0,0,5107,5084, + 1,0,0,0,5107,5086,1,0,0,0,5107,5092,1,0,0,0,5107,5100,1,0,0,0,5108, + 5109,1,0,0,0,5109,5110,5,333,0,0,5110,5111,5,323,0,0,5111,5112,3, + 790,395,0,5112,5130,1,0,0,0,5113,5122,5,138,0,0,5114,5115,5,355, + 0,0,5115,5116,5,325,0,0,5116,5123,7,41,0,0,5117,5123,5,108,0,0,5118, + 5123,5,168,0,0,5119,5123,5,189,0,0,5120,5123,5,342,0,0,5121,5123, + 5,360,0,0,5122,5114,1,0,0,0,5122,5117,1,0,0,0,5122,5118,1,0,0,0, + 5122,5119,1,0,0,0,5122,5120,1,0,0,0,5122,5121,1,0,0,0,5123,5124, + 1,0,0,0,5124,5125,3,316,158,0,5125,5126,5,333,0,0,5126,5127,5,323, + 0,0,5127,5128,3,790,395,0,5128,5130,1,0,0,0,5129,5068,1,0,0,0,5129, + 5113,1,0,0,0,5130,437,1,0,0,0,5131,5132,5,138,0,0,5132,5133,5,278, + 0,0,5133,5134,3,416,208,0,5134,5135,5,333,0,0,5135,5136,3,440,220, + 0,5136,439,1,0,0,0,5137,5138,5,2,0,0,5138,5143,3,442,221,0,5139, + 5140,5,6,0,0,5140,5142,3,442,221,0,5141,5139,1,0,0,0,5142,5145,1, + 0,0,0,5143,5141,1,0,0,0,5143,5144,1,0,0,0,5144,5146,1,0,0,0,5145, + 5143,1,0,0,0,5146,5147,5,3,0,0,5147,441,1,0,0,0,5148,5149,3,824, + 412,0,5149,5156,5,10,0,0,5150,5157,5,407,0,0,5151,5157,3,388,194, + 0,5152,5157,3,834,417,0,5153,5157,3,726,363,0,5154,5157,3,202,101, + 0,5155,5157,3,808,404,0,5156,5150,1,0,0,0,5156,5151,1,0,0,0,5156, + 5152,1,0,0,0,5156,5153,1,0,0,0,5156,5154,1,0,0,0,5156,5155,1,0,0, + 0,5157,443,1,0,0,0,5158,5159,5,138,0,0,5159,5160,5,360,0,0,5160, + 5161,3,316,158,0,5161,5162,5,333,0,0,5162,5163,3,440,220,0,5163, + 445,1,0,0,0,5164,5165,5,138,0,0,5165,5166,5,278,0,0,5166,5167,7, + 31,0,0,5167,5168,3,316,158,0,5168,5169,3,170,85,0,5169,5170,5,282, + 0,0,5170,5171,5,94,0,0,5171,5172,3,814,407,0,5172,5239,1,0,0,0,5173, + 5200,5,138,0,0,5174,5175,5,136,0,0,5175,5201,3,394,197,0,5176,5177, + 5,175,0,0,5177,5201,3,788,394,0,5178,5179,5,211,0,0,5179,5201,3, + 382,191,0,5180,5182,5,295,0,0,5181,5180,1,0,0,0,5181,5182,1,0,0, + 0,5182,5183,1,0,0,0,5183,5184,5,247,0,0,5184,5201,3,818,409,0,5185, + 5186,5,248,0,0,5186,5187,5,274,0,0,5187,5201,3,202,101,0,5188,5189, + 5,248,0,0,5189,5190,5,274,0,0,5190,5201,3,202,101,0,5191,5192,5, + 278,0,0,5192,5201,3,416,208,0,5193,5194,5,296,0,0,5194,5201,3,378, + 189,0,5195,5196,5,442,0,0,5196,5201,3,374,187,0,5197,5198,5,323, + 0,0,5198,5201,3,790,395,0,5199,5201,3,176,88,0,5200,5174,1,0,0,0, + 5200,5176,1,0,0,0,5200,5178,1,0,0,0,5200,5181,1,0,0,0,5200,5185, + 1,0,0,0,5200,5188,1,0,0,0,5200,5191,1,0,0,0,5200,5193,1,0,0,0,5200, + 5195,1,0,0,0,5200,5197,1,0,0,0,5200,5199,1,0,0,0,5201,5202,1,0,0, + 0,5202,5203,5,282,0,0,5203,5204,5,94,0,0,5204,5205,3,814,407,0,5205, + 5239,1,0,0,0,5206,5215,5,138,0,0,5207,5208,5,355,0,0,5208,5209,5, + 325,0,0,5209,5216,7,63,0,0,5210,5216,5,108,0,0,5211,5216,5,168,0, + 0,5212,5216,5,189,0,0,5213,5216,5,360,0,0,5214,5216,5,342,0,0,5215, + 5207,1,0,0,0,5215,5210,1,0,0,0,5215,5211,1,0,0,0,5215,5212,1,0,0, + 0,5215,5213,1,0,0,0,5215,5214,1,0,0,0,5216,5217,1,0,0,0,5217,5218, + 3,316,158,0,5218,5219,5,282,0,0,5219,5220,5,94,0,0,5220,5221,3,814, + 407,0,5221,5239,1,0,0,0,5222,5231,5,138,0,0,5223,5232,5,331,0,0, + 5224,5225,5,63,0,0,5225,5226,5,174,0,0,5226,5232,5,381,0,0,5227, + 5228,5,198,0,0,5228,5232,5,357,0,0,5229,5232,5,452,0,0,5230,5232, + 5,451,0,0,5231,5223,1,0,0,0,5231,5224,1,0,0,0,5231,5227,1,0,0,0, + 5231,5229,1,0,0,0,5231,5230,1,0,0,0,5232,5233,1,0,0,0,5233,5234, + 3,818,409,0,5234,5235,5,282,0,0,5235,5236,5,94,0,0,5236,5237,3,814, + 407,0,5237,5239,1,0,0,0,5238,5164,1,0,0,0,5238,5173,1,0,0,0,5238, + 5206,1,0,0,0,5238,5222,1,0,0,0,5239,447,1,0,0,0,5240,5241,5,46,0, + 0,5241,5242,5,452,0,0,5242,5249,3,818,409,0,5243,5244,5,62,0,0,5244, + 5245,5,92,0,0,5245,5250,3,628,314,0,5246,5247,5,62,0,0,5247,5248, + 5,30,0,0,5248,5250,5,350,0,0,5249,5243,1,0,0,0,5249,5246,1,0,0,0, + 5249,5250,1,0,0,0,5250,5252,1,0,0,0,5251,5253,3,400,200,0,5252,5251, + 1,0,0,0,5252,5253,1,0,0,0,5253,449,1,0,0,0,5254,5255,5,138,0,0,5255, + 5256,5,452,0,0,5256,5274,3,818,409,0,5257,5258,5,282,0,0,5258,5259, + 5,94,0,0,5259,5275,3,814,407,0,5260,5261,5,333,0,0,5261,5275,3,284, + 142,0,5262,5263,5,309,0,0,5263,5264,5,94,0,0,5264,5275,3,818,409, + 0,5265,5266,7,34,0,0,5266,5271,3,626,313,0,5267,5268,5,6,0,0,5268, + 5270,3,626,313,0,5269,5267,1,0,0,0,5270,5273,1,0,0,0,5271,5269,1, + 0,0,0,5271,5272,1,0,0,0,5272,5275,1,0,0,0,5273,5271,1,0,0,0,5274, + 5257,1,0,0,0,5274,5260,1,0,0,0,5274,5262,1,0,0,0,5274,5265,1,0,0, + 0,5275,451,1,0,0,0,5276,5277,5,46,0,0,5277,5278,5,451,0,0,5278,5279, + 3,818,409,0,5279,5280,5,164,0,0,5280,5281,3,808,404,0,5281,5282, + 5,452,0,0,5282,5287,3,824,412,0,5283,5284,5,6,0,0,5284,5286,3,824, + 412,0,5285,5283,1,0,0,0,5286,5289,1,0,0,0,5287,5285,1,0,0,0,5287, + 5288,1,0,0,0,5288,5291,1,0,0,0,5289,5287,1,0,0,0,5290,5292,3,400, + 200,0,5291,5290,1,0,0,0,5291,5292,1,0,0,0,5292,453,1,0,0,0,5293, + 5294,5,138,0,0,5294,5295,5,451,0,0,5295,5296,3,818,409,0,5296,5297, + 5,333,0,0,5297,5298,3,284,142,0,5298,5350,1,0,0,0,5299,5300,5,138, + 0,0,5300,5301,5,451,0,0,5301,5302,3,818,409,0,5302,5303,5,164,0, + 0,5303,5304,3,808,404,0,5304,5350,1,0,0,0,5305,5306,5,138,0,0,5306, + 5307,5,451,0,0,5307,5308,3,818,409,0,5308,5309,5,305,0,0,5309,5311, + 5,452,0,0,5310,5312,3,400,200,0,5311,5310,1,0,0,0,5311,5312,1,0, + 0,0,5312,5350,1,0,0,0,5313,5314,5,138,0,0,5314,5315,5,451,0,0,5315, + 5316,3,818,409,0,5316,5317,7,34,0,0,5317,5318,5,452,0,0,5318,5323, + 3,824,412,0,5319,5320,5,6,0,0,5320,5322,3,824,412,0,5321,5319,1, + 0,0,0,5322,5325,1,0,0,0,5323,5321,1,0,0,0,5323,5324,1,0,0,0,5324, + 5327,1,0,0,0,5325,5323,1,0,0,0,5326,5328,3,400,200,0,5327,5326,1, + 0,0,0,5327,5328,1,0,0,0,5328,5350,1,0,0,0,5329,5330,5,138,0,0,5330, + 5331,5,451,0,0,5331,5332,3,818,409,0,5332,5333,7,64,0,0,5333,5350, + 1,0,0,0,5334,5335,5,138,0,0,5335,5336,5,451,0,0,5336,5337,3,818, + 409,0,5337,5338,5,465,0,0,5338,5339,5,2,0,0,5339,5340,3,290,145, + 0,5340,5341,5,3,0,0,5341,5350,1,0,0,0,5342,5343,5,138,0,0,5343,5344, + 5,451,0,0,5344,5345,3,818,409,0,5345,5346,5,282,0,0,5346,5347,5, + 94,0,0,5347,5348,3,814,407,0,5348,5350,1,0,0,0,5349,5293,1,0,0,0, + 5349,5299,1,0,0,0,5349,5305,1,0,0,0,5349,5313,1,0,0,0,5349,5329, + 1,0,0,0,5349,5334,1,0,0,0,5349,5342,1,0,0,0,5350,455,1,0,0,0,5351, + 5353,5,46,0,0,5352,5354,3,366,183,0,5353,5352,1,0,0,0,5353,5354, + 1,0,0,0,5354,5355,1,0,0,0,5355,5356,5,321,0,0,5356,5357,3,818,409, + 0,5357,5358,5,36,0,0,5358,5359,5,80,0,0,5359,5360,7,65,0,0,5360, + 5361,5,94,0,0,5361,5363,3,780,390,0,5362,5364,3,638,319,0,5363,5362, + 1,0,0,0,5363,5364,1,0,0,0,5364,5365,1,0,0,0,5365,5367,5,57,0,0,5366, + 5368,7,66,0,0,5367,5366,1,0,0,0,5367,5368,1,0,0,0,5368,5385,1,0, + 0,0,5369,5386,5,270,0,0,5370,5386,3,458,229,0,5371,5373,5,2,0,0, + 5372,5374,3,458,229,0,5373,5372,1,0,0,0,5373,5374,1,0,0,0,5374,5381, + 1,0,0,0,5375,5377,5,7,0,0,5376,5378,3,458,229,0,5377,5376,1,0,0, + 0,5377,5378,1,0,0,0,5378,5380,1,0,0,0,5379,5375,1,0,0,0,5380,5383, + 1,0,0,0,5381,5379,1,0,0,0,5381,5382,1,0,0,0,5382,5384,1,0,0,0,5383, + 5381,1,0,0,0,5384,5386,5,3,0,0,5385,5369,1,0,0,0,5385,5370,1,0,0, + 0,5385,5371,1,0,0,0,5386,457,1,0,0,0,5387,5393,3,560,280,0,5388, + 5393,3,538,269,0,5389,5393,3,552,276,0,5390,5393,3,548,274,0,5391, + 5393,3,460,230,0,5392,5387,1,0,0,0,5392,5388,1,0,0,0,5392,5389,1, + 0,0,0,5392,5390,1,0,0,0,5392,5391,1,0,0,0,5393,459,1,0,0,0,5394, + 5395,5,271,0,0,5395,5397,3,818,409,0,5396,5398,3,462,231,0,5397, + 5396,1,0,0,0,5397,5398,1,0,0,0,5398,461,1,0,0,0,5399,5400,5,6,0, + 0,5400,5401,3,808,404,0,5401,463,1,0,0,0,5402,5403,5,252,0,0,5403, + 5404,3,818,409,0,5404,465,1,0,0,0,5405,5408,5,366,0,0,5406,5409, + 3,818,409,0,5407,5409,5,9,0,0,5408,5406,1,0,0,0,5408,5407,1,0,0, + 0,5409,467,1,0,0,0,5410,5412,5,146,0,0,5411,5413,3,470,235,0,5412, + 5411,1,0,0,0,5412,5413,1,0,0,0,5413,5415,1,0,0,0,5414,5416,3,474, + 237,0,5415,5414,1,0,0,0,5415,5416,1,0,0,0,5416,5456,1,0,0,0,5417, + 5418,5,340,0,0,5418,5420,5,356,0,0,5419,5421,3,474,237,0,5420,5419, + 1,0,0,0,5420,5421,1,0,0,0,5421,5456,1,0,0,0,5422,5423,5,322,0,0, + 5423,5456,3,818,409,0,5424,5426,5,308,0,0,5425,5427,5,322,0,0,5426, + 5425,1,0,0,0,5426,5427,1,0,0,0,5427,5428,1,0,0,0,5428,5456,3,818, + 409,0,5429,5430,5,290,0,0,5430,5431,5,356,0,0,5431,5456,3,808,404, + 0,5432,5433,7,67,0,0,5433,5434,5,291,0,0,5434,5456,3,808,404,0,5435, + 5437,7,68,0,0,5436,5438,3,470,235,0,5437,5436,1,0,0,0,5437,5438, + 1,0,0,0,5438,5444,1,0,0,0,5439,5441,5,33,0,0,5440,5442,5,269,0,0, + 5441,5440,1,0,0,0,5441,5442,1,0,0,0,5442,5443,1,0,0,0,5443,5445, + 5,153,0,0,5444,5439,1,0,0,0,5444,5445,1,0,0,0,5445,5456,1,0,0,0, + 5446,5448,5,319,0,0,5447,5449,3,470,235,0,5448,5447,1,0,0,0,5448, + 5449,1,0,0,0,5449,5450,1,0,0,0,5450,5452,5,94,0,0,5451,5453,5,322, + 0,0,5452,5451,1,0,0,0,5452,5453,1,0,0,0,5453,5454,1,0,0,0,5454,5456, + 3,818,409,0,5455,5410,1,0,0,0,5455,5417,1,0,0,0,5455,5422,1,0,0, + 0,5455,5424,1,0,0,0,5455,5429,1,0,0,0,5455,5432,1,0,0,0,5455,5435, + 1,0,0,0,5455,5446,1,0,0,0,5456,469,1,0,0,0,5457,5458,7,69,0,0,5458, + 471,1,0,0,0,5459,5460,5,244,0,0,5460,5461,5,251,0,0,5461,5469,3, + 50,25,0,5462,5463,5,300,0,0,5463,5469,7,70,0,0,5464,5466,5,77,0, + 0,5465,5464,1,0,0,0,5465,5466,1,0,0,0,5466,5467,1,0,0,0,5467,5469, + 5,54,0,0,5468,5459,1,0,0,0,5468,5462,1,0,0,0,5468,5465,1,0,0,0,5469, + 473,1,0,0,0,5470,5477,3,472,236,0,5471,5473,5,6,0,0,5472,5471,1, + 0,0,0,5472,5473,1,0,0,0,5473,5474,1,0,0,0,5474,5476,3,472,236,0, + 5475,5472,1,0,0,0,5476,5479,1,0,0,0,5477,5475,1,0,0,0,5477,5478, + 1,0,0,0,5478,475,1,0,0,0,5479,5477,1,0,0,0,5480,5483,5,46,0,0,5481, + 5482,5,82,0,0,5482,5484,5,311,0,0,5483,5481,1,0,0,0,5483,5484,1, + 0,0,0,5484,5486,1,0,0,0,5485,5487,3,122,61,0,5486,5485,1,0,0,0,5486, + 5487,1,0,0,0,5487,5503,1,0,0,0,5488,5489,5,376,0,0,5489,5491,3,776, + 388,0,5490,5492,3,146,73,0,5491,5490,1,0,0,0,5491,5492,1,0,0,0,5492, + 5494,1,0,0,0,5493,5495,3,102,51,0,5494,5493,1,0,0,0,5494,5495,1, + 0,0,0,5495,5504,1,0,0,0,5496,5497,5,303,0,0,5497,5498,5,376,0,0, + 5498,5499,3,776,388,0,5499,5501,3,144,72,0,5500,5502,3,102,51,0, + 5501,5500,1,0,0,0,5501,5502,1,0,0,0,5502,5504,1,0,0,0,5503,5488, + 1,0,0,0,5503,5496,1,0,0,0,5504,5505,1,0,0,0,5505,5506,5,36,0,0,5506, + 5513,3,560,280,0,5507,5509,5,105,0,0,5508,5510,7,71,0,0,5509,5508, + 1,0,0,0,5509,5510,1,0,0,0,5510,5511,1,0,0,0,5511,5512,5,42,0,0,5512, + 5514,5,279,0,0,5513,5507,1,0,0,0,5513,5514,1,0,0,0,5514,477,1,0, + 0,0,5515,5516,5,253,0,0,5516,5517,3,808,404,0,5517,479,1,0,0,0,5518, + 5519,5,46,0,0,5519,5520,5,175,0,0,5520,5522,3,786,393,0,5521,5523, + 5,105,0,0,5522,5521,1,0,0,0,5522,5523,1,0,0,0,5523,5529,1,0,0,0, + 5524,5526,3,482,241,0,5525,5524,1,0,0,0,5526,5527,1,0,0,0,5527,5525, + 1,0,0,0,5527,5528,1,0,0,0,5528,5530,1,0,0,0,5529,5525,1,0,0,0,5529, + 5530,1,0,0,0,5530,481,1,0,0,0,5531,5532,5,164,0,0,5532,5540,5,74, + 0,0,5533,5540,5,194,0,0,5534,5540,5,255,0,0,5535,5540,5,282,0,0, + 5536,5540,5,351,0,0,5537,5540,5,353,0,0,5538,5540,3,826,413,0,5539, + 5531,1,0,0,0,5539,5533,1,0,0,0,5539,5534,1,0,0,0,5539,5535,1,0,0, + 0,5539,5536,1,0,0,0,5539,5537,1,0,0,0,5539,5538,1,0,0,0,5540,5542, + 1,0,0,0,5541,5543,5,10,0,0,5542,5541,1,0,0,0,5542,5543,1,0,0,0,5543, + 5547,1,0,0,0,5544,5548,3,812,406,0,5545,5548,3,54,27,0,5546,5548, + 5,53,0,0,5547,5544,1,0,0,0,5547,5545,1,0,0,0,5547,5546,1,0,0,0,5548, + 483,1,0,0,0,5549,5550,5,138,0,0,5550,5551,5,175,0,0,5551,5567,3, + 788,394,0,5552,5553,5,333,0,0,5553,5554,5,351,0,0,5554,5556,3,768, + 384,0,5555,5552,1,0,0,0,5555,5556,1,0,0,0,5556,5568,1,0,0,0,5557, + 5559,5,105,0,0,5558,5557,1,0,0,0,5558,5559,1,0,0,0,5559,5561,1,0, + 0,0,5560,5562,3,482,241,0,5561,5560,1,0,0,0,5562,5563,1,0,0,0,5563, + 5561,1,0,0,0,5563,5564,1,0,0,0,5564,5566,1,0,0,0,5565,5558,1,0,0, + 0,5565,5566,1,0,0,0,5566,5568,1,0,0,0,5567,5555,1,0,0,0,5567,5565, + 1,0,0,0,5568,485,1,0,0,0,5569,5570,5,138,0,0,5570,5571,5,175,0,0, + 5571,5573,3,788,394,0,5572,5574,3,64,32,0,5573,5572,1,0,0,0,5573, + 5574,1,0,0,0,5574,487,1,0,0,0,5575,5576,5,138,0,0,5576,5577,5,108, + 0,0,5577,5578,3,316,158,0,5578,5579,5,305,0,0,5579,5580,5,375,0, + 0,5580,489,1,0,0,0,5581,5582,5,138,0,0,5582,5583,5,349,0,0,5583, + 5584,7,16,0,0,5584,5585,3,40,20,0,5585,491,1,0,0,0,5586,5587,5,46, + 0,0,5587,5588,5,189,0,0,5588,5590,3,316,158,0,5589,5591,5,36,0,0, + 5590,5589,1,0,0,0,5590,5591,1,0,0,0,5591,5592,1,0,0,0,5592,5596, + 3,652,326,0,5593,5595,3,134,67,0,5594,5593,1,0,0,0,5595,5598,1,0, + 0,0,5596,5594,1,0,0,0,5596,5597,1,0,0,0,5597,493,1,0,0,0,5598,5596, + 1,0,0,0,5599,5600,5,138,0,0,5600,5601,5,189,0,0,5601,5624,3,316, + 158,0,5602,5625,3,94,47,0,5603,5604,7,15,0,0,5604,5605,5,77,0,0, + 5605,5625,5,78,0,0,5606,5609,5,133,0,0,5607,5608,5,45,0,0,5608,5610, + 3,818,409,0,5609,5607,1,0,0,0,5609,5610,1,0,0,0,5610,5611,1,0,0, + 0,5611,5625,3,142,71,0,5612,5613,5,191,0,0,5613,5615,5,45,0,0,5614, + 5616,3,422,211,0,5615,5614,1,0,0,0,5615,5616,1,0,0,0,5616,5617,1, + 0,0,0,5617,5619,3,818,409,0,5618,5620,3,96,48,0,5619,5618,1,0,0, + 0,5619,5620,1,0,0,0,5620,5625,1,0,0,0,5621,5622,5,372,0,0,5622,5623, + 5,45,0,0,5623,5625,3,818,409,0,5624,5602,1,0,0,0,5624,5603,1,0,0, + 0,5624,5606,1,0,0,0,5624,5612,1,0,0,0,5624,5621,1,0,0,0,5625,495, + 1,0,0,0,5626,5627,5,138,0,0,5627,5628,5,355,0,0,5628,5629,5,325, + 0,0,5629,5630,5,185,0,0,5630,5631,3,316,158,0,5631,5632,3,284,142, + 0,5632,497,1,0,0,0,5633,5634,5,138,0,0,5634,5635,5,355,0,0,5635, + 5636,5,325,0,0,5636,5637,5,163,0,0,5637,5638,3,316,158,0,5638,5639, + 7,72,0,0,5639,5640,5,257,0,0,5640,5641,5,62,0,0,5641,5642,3,784, + 392,0,5642,5643,5,105,0,0,5643,5644,3,314,157,0,5644,5675,1,0,0, + 0,5645,5646,5,138,0,0,5646,5647,5,355,0,0,5647,5648,5,325,0,0,5648, + 5649,5,163,0,0,5649,5650,3,316,158,0,5650,5651,5,138,0,0,5651,5654, + 5,257,0,0,5652,5653,5,62,0,0,5653,5655,3,784,392,0,5654,5652,1,0, + 0,0,5654,5655,1,0,0,0,5655,5656,1,0,0,0,5656,5657,5,311,0,0,5657, + 5658,3,316,158,0,5658,5659,5,105,0,0,5659,5660,3,316,158,0,5660, + 5675,1,0,0,0,5661,5662,5,138,0,0,5662,5663,5,355,0,0,5663,5664,5, + 325,0,0,5664,5665,5,163,0,0,5665,5666,3,316,158,0,5666,5667,5,191, + 0,0,5667,5669,5,257,0,0,5668,5670,3,422,211,0,5669,5668,1,0,0,0, + 5669,5670,1,0,0,0,5670,5671,1,0,0,0,5671,5672,5,62,0,0,5672,5673, + 3,784,392,0,5673,5675,1,0,0,0,5674,5633,1,0,0,0,5674,5645,1,0,0, + 0,5674,5661,1,0,0,0,5675,499,1,0,0,0,5676,5678,5,46,0,0,5677,5679, + 5,53,0,0,5678,5677,1,0,0,0,5678,5679,1,0,0,0,5679,5680,1,0,0,0,5680, + 5681,5,168,0,0,5681,5682,3,316,158,0,5682,5683,5,62,0,0,5683,5684, + 3,808,404,0,5684,5685,5,94,0,0,5685,5686,3,808,404,0,5686,5687,5, + 64,0,0,5687,5688,3,316,158,0,5688,501,1,0,0,0,5689,5691,5,158,0, + 0,5690,5692,3,514,257,0,5691,5690,1,0,0,0,5691,5692,1,0,0,0,5692, + 5697,1,0,0,0,5693,5695,3,774,387,0,5694,5696,3,170,85,0,5695,5694, + 1,0,0,0,5695,5696,1,0,0,0,5696,5698,1,0,0,0,5697,5693,1,0,0,0,5697, + 5698,1,0,0,0,5698,5715,1,0,0,0,5699,5700,5,158,0,0,5700,5701,5,2, + 0,0,5701,5706,3,514,257,0,5702,5703,5,6,0,0,5703,5705,3,514,257, + 0,5704,5702,1,0,0,0,5705,5708,1,0,0,0,5706,5704,1,0,0,0,5706,5707, + 1,0,0,0,5707,5709,1,0,0,0,5708,5706,1,0,0,0,5709,5710,5,3,0,0,5710, + 5712,3,774,387,0,5711,5713,3,170,85,0,5712,5711,1,0,0,0,5712,5713, + 1,0,0,0,5713,5715,1,0,0,0,5714,5689,1,0,0,0,5714,5699,1,0,0,0,5715, + 503,1,0,0,0,5716,5732,5,370,0,0,5717,5719,5,113,0,0,5718,5717,1, + 0,0,0,5718,5719,1,0,0,0,5719,5721,1,0,0,0,5720,5722,5,112,0,0,5721, + 5720,1,0,0,0,5721,5722,1,0,0,0,5722,5724,1,0,0,0,5723,5725,3,514, + 257,0,5724,5723,1,0,0,0,5724,5725,1,0,0,0,5725,5727,1,0,0,0,5726, + 5728,3,508,254,0,5727,5726,1,0,0,0,5727,5728,1,0,0,0,5728,5733,1, + 0,0,0,5729,5731,3,524,262,0,5730,5729,1,0,0,0,5730,5731,1,0,0,0, + 5731,5733,1,0,0,0,5732,5718,1,0,0,0,5732,5730,1,0,0,0,5733,5735, + 1,0,0,0,5734,5736,3,518,259,0,5735,5734,1,0,0,0,5735,5736,1,0,0, + 0,5736,505,1,0,0,0,5737,5752,3,508,254,0,5738,5740,3,514,257,0,5739, + 5738,1,0,0,0,5739,5740,1,0,0,0,5740,5753,1,0,0,0,5741,5742,5,2,0, + 0,5742,5747,3,512,256,0,5743,5744,5,6,0,0,5744,5746,3,512,256,0, + 5745,5743,1,0,0,0,5746,5749,1,0,0,0,5747,5745,1,0,0,0,5747,5748, + 1,0,0,0,5748,5750,1,0,0,0,5749,5747,1,0,0,0,5750,5751,5,3,0,0,5751, + 5753,1,0,0,0,5752,5739,1,0,0,0,5752,5741,1,0,0,0,5753,5755,1,0,0, + 0,5754,5756,3,518,259,0,5755,5754,1,0,0,0,5755,5756,1,0,0,0,5756, + 507,1,0,0,0,5757,5758,7,73,0,0,5758,509,1,0,0,0,5759,5762,3,822, + 411,0,5760,5762,3,508,254,0,5761,5759,1,0,0,0,5761,5760,1,0,0,0, + 5762,5765,1,0,0,0,5763,5766,3,54,27,0,5764,5766,3,202,101,0,5765, + 5763,1,0,0,0,5765,5764,1,0,0,0,5765,5766,1,0,0,0,5766,511,1,0,0, + 0,5767,5769,7,74,0,0,5768,5770,7,75,0,0,5769,5768,1,0,0,0,5769,5770, + 1,0,0,0,5770,5777,1,0,0,0,5771,5774,5,548,0,0,5772,5775,3,202,101, + 0,5773,5775,3,808,404,0,5774,5772,1,0,0,0,5774,5773,1,0,0,0,5775, + 5777,1,0,0,0,5776,5767,1,0,0,0,5776,5771,1,0,0,0,5777,513,1,0,0, + 0,5778,5780,5,128,0,0,5779,5781,7,75,0,0,5780,5779,1,0,0,0,5780, + 5781,1,0,0,0,5781,515,1,0,0,0,5782,5784,3,774,387,0,5783,5785,3, + 144,72,0,5784,5783,1,0,0,0,5784,5785,1,0,0,0,5785,517,1,0,0,0,5786, + 5791,3,516,258,0,5787,5788,5,6,0,0,5788,5790,3,516,258,0,5789,5787, + 1,0,0,0,5790,5793,1,0,0,0,5791,5789,1,0,0,0,5791,5792,1,0,0,0,5792, + 519,1,0,0,0,5793,5791,1,0,0,0,5794,5805,5,203,0,0,5795,5806,3,524, + 262,0,5796,5798,5,128,0,0,5797,5796,1,0,0,0,5797,5798,1,0,0,0,5798, + 5806,1,0,0,0,5799,5801,3,508,254,0,5800,5802,3,514,257,0,5801,5800, + 1,0,0,0,5801,5802,1,0,0,0,5802,5804,1,0,0,0,5803,5799,1,0,0,0,5803, + 5804,1,0,0,0,5804,5806,1,0,0,0,5805,5795,1,0,0,0,5805,5797,1,0,0, + 0,5805,5803,1,0,0,0,5806,5807,1,0,0,0,5807,5808,3,522,261,0,5808, + 521,1,0,0,0,5809,5819,3,560,280,0,5810,5819,3,538,269,0,5811,5819, + 3,552,276,0,5812,5819,3,548,274,0,5813,5819,3,558,279,0,5814,5819, + 3,186,93,0,5815,5819,3,192,96,0,5816,5819,3,194,97,0,5817,5819,3, + 532,266,0,5818,5809,1,0,0,0,5818,5810,1,0,0,0,5818,5811,1,0,0,0, + 5818,5812,1,0,0,0,5818,5813,1,0,0,0,5818,5814,1,0,0,0,5818,5815, + 1,0,0,0,5818,5816,1,0,0,0,5818,5817,1,0,0,0,5819,523,1,0,0,0,5820, + 5821,5,2,0,0,5821,5826,3,510,255,0,5822,5823,5,6,0,0,5823,5825,3, + 510,255,0,5824,5822,1,0,0,0,5825,5828,1,0,0,0,5826,5824,1,0,0,0, + 5826,5827,1,0,0,0,5827,5829,1,0,0,0,5828,5826,1,0,0,0,5829,5830, + 5,3,0,0,5830,525,1,0,0,0,5831,5832,5,290,0,0,5832,5834,3,818,409, + 0,5833,5835,3,528,264,0,5834,5833,1,0,0,0,5834,5835,1,0,0,0,5835, + 5836,1,0,0,0,5836,5837,5,36,0,0,5837,5838,3,530,265,0,5838,527,1, + 0,0,0,5839,5840,5,2,0,0,5840,5845,3,652,326,0,5841,5842,5,6,0,0, + 5842,5844,3,652,326,0,5843,5841,1,0,0,0,5844,5847,1,0,0,0,5845,5843, + 1,0,0,0,5845,5846,1,0,0,0,5846,5848,1,0,0,0,5847,5845,1,0,0,0,5848, + 5849,5,3,0,0,5849,529,1,0,0,0,5850,5855,3,560,280,0,5851,5855,3, + 538,269,0,5852,5855,3,552,276,0,5853,5855,3,548,274,0,5854,5850, + 1,0,0,0,5854,5851,1,0,0,0,5854,5852,1,0,0,0,5854,5853,1,0,0,0,5855, + 531,1,0,0,0,5856,5857,5,202,0,0,5857,5859,3,818,409,0,5858,5860, + 3,534,267,0,5859,5858,1,0,0,0,5859,5860,1,0,0,0,5860,5880,1,0,0, + 0,5861,5863,5,46,0,0,5862,5864,3,122,61,0,5863,5862,1,0,0,0,5863, + 5864,1,0,0,0,5864,5865,1,0,0,0,5865,5867,5,92,0,0,5866,5868,3,294, + 147,0,5867,5866,1,0,0,0,5867,5868,1,0,0,0,5868,5869,1,0,0,0,5869, + 5870,3,188,94,0,5870,5871,5,36,0,0,5871,5872,5,202,0,0,5872,5874, + 3,818,409,0,5873,5875,3,534,267,0,5874,5873,1,0,0,0,5874,5875,1, + 0,0,0,5875,5877,1,0,0,0,5876,5878,3,190,95,0,5877,5876,1,0,0,0,5877, + 5878,1,0,0,0,5878,5880,1,0,0,0,5879,5856,1,0,0,0,5879,5861,1,0,0, + 0,5880,533,1,0,0,0,5881,5882,5,2,0,0,5882,5883,3,730,365,0,5883, + 5884,5,3,0,0,5884,535,1,0,0,0,5885,5887,5,177,0,0,5886,5888,5,290, + 0,0,5887,5886,1,0,0,0,5887,5888,1,0,0,0,5888,5891,1,0,0,0,5889,5892, + 3,818,409,0,5890,5892,5,30,0,0,5891,5889,1,0,0,0,5891,5890,1,0,0, + 0,5892,537,1,0,0,0,5893,5895,3,572,286,0,5894,5893,1,0,0,0,5894, + 5895,1,0,0,0,5895,5896,1,0,0,0,5896,5897,5,241,0,0,5897,5898,5,71, + 0,0,5898,5901,3,774,387,0,5899,5900,5,36,0,0,5900,5902,3,818,409, + 0,5901,5899,1,0,0,0,5901,5902,1,0,0,0,5902,5903,1,0,0,0,5903,5925, + 3,540,270,0,5904,5905,5,80,0,0,5905,5913,5,464,0,0,5906,5908,3,360, + 180,0,5907,5909,3,638,319,0,5908,5907,1,0,0,0,5908,5909,1,0,0,0, + 5909,5914,1,0,0,0,5910,5911,5,80,0,0,5911,5912,5,45,0,0,5912,5914, + 3,818,409,0,5913,5906,1,0,0,0,5913,5910,1,0,0,0,5913,5914,1,0,0, + 0,5914,5915,1,0,0,0,5915,5923,5,57,0,0,5916,5917,5,369,0,0,5917, + 5918,5,333,0,0,5918,5920,3,554,277,0,5919,5921,3,638,319,0,5920, + 5919,1,0,0,0,5920,5921,1,0,0,0,5921,5924,1,0,0,0,5922,5924,5,270, + 0,0,5923,5916,1,0,0,0,5923,5922,1,0,0,0,5924,5926,1,0,0,0,5925,5904, + 1,0,0,0,5925,5926,1,0,0,0,5926,5928,1,0,0,0,5927,5929,3,546,273, + 0,5928,5927,1,0,0,0,5928,5929,1,0,0,0,5929,539,1,0,0,0,5930,5931, + 5,2,0,0,5931,5932,3,542,271,0,5932,5933,5,3,0,0,5933,5935,1,0,0, + 0,5934,5930,1,0,0,0,5934,5935,1,0,0,0,5935,5939,1,0,0,0,5936,5937, + 5,463,0,0,5937,5938,7,76,0,0,5938,5940,5,450,0,0,5939,5936,1,0,0, + 0,5939,5940,1,0,0,0,5940,5943,1,0,0,0,5941,5944,3,910,455,0,5942, + 5944,3,560,280,0,5943,5941,1,0,0,0,5943,5942,1,0,0,0,5944,541,1, + 0,0,0,5945,5950,3,544,272,0,5946,5947,5,6,0,0,5947,5949,3,544,272, + 0,5948,5946,1,0,0,0,5949,5952,1,0,0,0,5950,5948,1,0,0,0,5950,5951, + 1,0,0,0,5951,543,1,0,0,0,5952,5950,1,0,0,0,5953,5954,3,800,400,0, + 5954,5955,3,754,377,0,5955,545,1,0,0,0,5956,5957,5,87,0,0,5957,5958, + 3,756,378,0,5958,547,1,0,0,0,5959,5961,3,572,286,0,5960,5959,1,0, + 0,0,5960,5961,1,0,0,0,5961,5962,1,0,0,0,5962,5963,5,182,0,0,5963, + 5964,5,64,0,0,5964,5967,3,630,315,0,5965,5966,5,100,0,0,5966,5968, + 3,612,306,0,5967,5965,1,0,0,0,5967,5968,1,0,0,0,5968,5970,1,0,0, + 0,5969,5971,3,640,320,0,5970,5969,1,0,0,0,5970,5971,1,0,0,0,5971, + 5973,1,0,0,0,5972,5974,3,546,273,0,5973,5972,1,0,0,0,5973,5974,1, + 0,0,0,5974,549,1,0,0,0,5975,5977,5,256,0,0,5976,5978,5,92,0,0,5977, + 5976,1,0,0,0,5977,5978,1,0,0,0,5978,5979,1,0,0,0,5979,5994,3,628, + 314,0,5980,5991,5,68,0,0,5981,5982,7,77,0,0,5982,5992,7,78,0,0,5983, + 5988,5,334,0,0,5984,5985,5,369,0,0,5985,5989,5,201,0,0,5986,5987, + 5,414,0,0,5987,5989,5,201,0,0,5988,5984,1,0,0,0,5988,5986,1,0,0, + 0,5988,5989,1,0,0,0,5989,5992,1,0,0,0,5990,5992,5,201,0,0,5991,5981, + 1,0,0,0,5991,5983,1,0,0,0,5991,5990,1,0,0,0,5992,5993,1,0,0,0,5993, + 5995,5,263,0,0,5994,5980,1,0,0,0,5994,5995,1,0,0,0,5995,5997,1,0, + 0,0,5996,5998,5,272,0,0,5997,5996,1,0,0,0,5997,5998,1,0,0,0,5998, + 551,1,0,0,0,5999,6001,3,572,286,0,6000,5999,1,0,0,0,6000,6001,1, + 0,0,0,6001,6002,1,0,0,0,6002,6003,5,369,0,0,6003,6004,3,630,315, + 0,6004,6005,5,333,0,0,6005,6007,3,554,277,0,6006,6008,3,610,305, + 0,6007,6006,1,0,0,0,6007,6008,1,0,0,0,6008,6010,1,0,0,0,6009,6011, + 3,640,320,0,6010,6009,1,0,0,0,6010,6011,1,0,0,0,6011,6013,1,0,0, + 0,6012,6014,3,546,273,0,6013,6012,1,0,0,0,6013,6014,1,0,0,0,6014, + 553,1,0,0,0,6015,6020,3,556,278,0,6016,6017,5,6,0,0,6017,6019,3, + 556,278,0,6018,6016,1,0,0,0,6019,6022,1,0,0,0,6020,6018,1,0,0,0, + 6020,6021,1,0,0,0,6021,555,1,0,0,0,6022,6020,1,0,0,0,6023,6024,3, + 544,272,0,6024,6025,5,10,0,0,6025,6026,3,674,337,0,6026,6042,1,0, + 0,0,6027,6028,5,2,0,0,6028,6029,3,542,271,0,6029,6030,5,3,0,0,6030, + 6039,5,10,0,0,6031,6033,5,414,0,0,6032,6031,1,0,0,0,6032,6033,1, + 0,0,0,6033,6034,1,0,0,0,6034,6040,3,674,337,0,6035,6036,5,2,0,0, + 6036,6037,3,566,283,0,6037,6038,5,3,0,0,6038,6040,1,0,0,0,6039,6032, + 1,0,0,0,6039,6035,1,0,0,0,6040,6042,1,0,0,0,6041,6023,1,0,0,0,6041, + 6027,1,0,0,0,6042,557,1,0,0,0,6043,6044,5,178,0,0,6044,6053,3,818, + 409,0,6045,6047,5,269,0,0,6046,6045,1,0,0,0,6046,6047,1,0,0,0,6047, + 6048,1,0,0,0,6048,6052,5,324,0,0,6049,6052,5,107,0,0,6050,6052,5, + 240,0,0,6051,6046,1,0,0,0,6051,6049,1,0,0,0,6051,6050,1,0,0,0,6052, + 6055,1,0,0,0,6053,6051,1,0,0,0,6053,6054,1,0,0,0,6054,6056,1,0,0, + 0,6055,6053,1,0,0,0,6056,6059,5,172,0,0,6057,6058,7,26,0,0,6058, + 6060,5,217,0,0,6059,6057,1,0,0,0,6059,6060,1,0,0,0,6060,6061,1,0, + 0,0,6061,6062,5,62,0,0,6062,6063,3,560,280,0,6063,559,1,0,0,0,6064, + 6067,3,564,282,0,6065,6067,3,562,281,0,6066,6064,1,0,0,0,6066,6065, + 1,0,0,0,6067,561,1,0,0,0,6068,6071,5,2,0,0,6069,6072,3,564,282,0, + 6070,6072,3,562,281,0,6071,6069,1,0,0,0,6071,6070,1,0,0,0,6072,6073, + 1,0,0,0,6073,6074,5,3,0,0,6074,563,1,0,0,0,6075,6077,3,572,286,0, + 6076,6075,1,0,0,0,6076,6077,1,0,0,0,6077,6078,1,0,0,0,6078,6080, + 3,566,283,0,6079,6081,3,586,293,0,6080,6079,1,0,0,0,6080,6081,1, + 0,0,0,6081,6090,1,0,0,0,6082,6084,3,606,303,0,6083,6085,3,590,295, + 0,6084,6083,1,0,0,0,6084,6085,1,0,0,0,6085,6091,1,0,0,0,6086,6088, + 3,590,295,0,6087,6089,3,606,303,0,6088,6087,1,0,0,0,6088,6089,1, + 0,0,0,6089,6091,1,0,0,0,6090,6082,1,0,0,0,6090,6086,1,0,0,0,6090, + 6091,1,0,0,0,6091,565,1,0,0,0,6092,6095,3,568,284,0,6093,6095,3, + 562,281,0,6094,6092,1,0,0,0,6094,6093,1,0,0,0,6095,567,1,0,0,0,6096, + 6106,5,88,0,0,6097,6099,5,30,0,0,6098,6097,1,0,0,0,6098,6099,1,0, + 0,0,6099,6101,1,0,0,0,6100,6102,3,580,290,0,6101,6100,1,0,0,0,6101, + 6102,1,0,0,0,6102,6107,1,0,0,0,6103,6105,3,584,292,0,6104,6103,1, + 0,0,0,6104,6105,1,0,0,0,6105,6107,1,0,0,0,6106,6098,1,0,0,0,6106, + 6104,1,0,0,0,6107,6108,1,0,0,0,6108,6119,3,932,466,0,6109,6119,3, + 608,304,0,6110,6111,5,92,0,0,6111,6119,3,624,312,0,6112,6113,3,562, + 281,0,6113,6116,3,570,285,0,6114,6117,3,568,284,0,6115,6117,3,562, + 281,0,6116,6114,1,0,0,0,6116,6115,1,0,0,0,6117,6119,1,0,0,0,6118, + 6096,1,0,0,0,6118,6109,1,0,0,0,6118,6110,1,0,0,0,6118,6112,1,0,0, + 0,6119,6127,1,0,0,0,6120,6123,3,570,285,0,6121,6124,3,568,284,0, + 6122,6124,3,562,281,0,6123,6121,1,0,0,0,6123,6122,1,0,0,0,6124,6126, + 1,0,0,0,6125,6120,1,0,0,0,6126,6129,1,0,0,0,6127,6125,1,0,0,0,6127, + 6128,1,0,0,0,6128,569,1,0,0,0,6129,6127,1,0,0,0,6130,6132,7,79,0, + 0,6131,6133,7,80,0,0,6132,6131,1,0,0,0,6132,6133,1,0,0,0,6133,571, + 1,0,0,0,6134,6136,5,105,0,0,6135,6137,5,303,0,0,6136,6135,1,0,0, + 0,6136,6137,1,0,0,0,6137,6138,1,0,0,0,6138,6143,3,574,287,0,6139, + 6140,5,6,0,0,6140,6142,3,574,287,0,6141,6139,1,0,0,0,6142,6145,1, + 0,0,0,6143,6141,1,0,0,0,6143,6144,1,0,0,0,6144,573,1,0,0,0,6145, + 6143,1,0,0,0,6146,6148,3,818,409,0,6147,6149,3,144,72,0,6148,6147, + 1,0,0,0,6148,6149,1,0,0,0,6149,6150,1,0,0,0,6150,6155,5,36,0,0,6151, + 6153,5,77,0,0,6152,6151,1,0,0,0,6152,6153,1,0,0,0,6153,6154,1,0, + 0,0,6154,6156,5,259,0,0,6155,6152,1,0,0,0,6155,6156,1,0,0,0,6156, + 6157,1,0,0,0,6157,6158,5,2,0,0,6158,6159,3,530,265,0,6159,6161,5, + 3,0,0,6160,6162,3,576,288,0,6161,6160,1,0,0,0,6161,6162,1,0,0,0, + 6162,6164,1,0,0,0,6163,6165,3,578,289,0,6164,6163,1,0,0,0,6164,6165, + 1,0,0,0,6165,575,1,0,0,0,6166,6167,5,325,0,0,6167,6168,7,81,0,0, + 6168,6169,5,207,0,0,6169,6170,5,147,0,0,6170,6171,3,148,74,0,6171, + 6172,5,333,0,0,6172,6173,3,800,400,0,6173,577,1,0,0,0,6174,6175, + 5,173,0,0,6175,6176,3,148,74,0,6176,6177,5,333,0,0,6177,6183,3,800, + 400,0,6178,6179,5,94,0,0,6179,6180,3,818,409,0,6180,6181,5,53,0, + 0,6181,6182,3,818,409,0,6182,6184,1,0,0,0,6183,6178,1,0,0,0,6183, + 6184,1,0,0,0,6184,6185,1,0,0,0,6185,6186,5,100,0,0,6186,6187,3,800, + 400,0,6187,579,1,0,0,0,6188,6194,5,71,0,0,6189,6191,5,346,0,0,6190, + 6189,1,0,0,0,6190,6191,1,0,0,0,6191,6192,1,0,0,0,6192,6195,3,582, + 291,0,6193,6195,3,730,365,0,6194,6190,1,0,0,0,6194,6193,1,0,0,0, + 6195,581,1,0,0,0,6196,6198,7,20,0,0,6197,6196,1,0,0,0,6197,6198, + 1,0,0,0,6198,6199,1,0,0,0,6199,6201,7,21,0,0,6200,6202,5,92,0,0, + 6201,6200,1,0,0,0,6201,6202,1,0,0,0,6202,6203,1,0,0,0,6203,6212, + 3,772,386,0,6204,6206,5,367,0,0,6205,6204,1,0,0,0,6205,6206,1,0, + 0,0,6206,6208,1,0,0,0,6207,6209,5,92,0,0,6208,6207,1,0,0,0,6208, + 6209,1,0,0,0,6209,6210,1,0,0,0,6210,6212,3,772,386,0,6211,6197,1, + 0,0,0,6211,6205,1,0,0,0,6212,583,1,0,0,0,6213,6216,5,56,0,0,6214, + 6215,5,80,0,0,6215,6217,3,534,267,0,6216,6214,1,0,0,0,6216,6217, + 1,0,0,0,6217,585,1,0,0,0,6218,6219,5,83,0,0,6219,6220,5,147,0,0, + 6220,6225,3,588,294,0,6221,6222,5,6,0,0,6222,6224,3,588,294,0,6223, + 6221,1,0,0,0,6224,6227,1,0,0,0,6225,6223,1,0,0,0,6225,6226,1,0,0, + 0,6226,587,1,0,0,0,6227,6225,1,0,0,0,6228,6232,3,734,367,0,6229, + 6230,5,100,0,0,6230,6233,3,726,363,0,6231,6233,7,55,0,0,6232,6229, + 1,0,0,0,6232,6231,1,0,0,0,6232,6233,1,0,0,0,6233,6236,1,0,0,0,6234, + 6235,5,273,0,0,6235,6237,7,56,0,0,6236,6234,1,0,0,0,6236,6237,1, + 0,0,0,6237,589,1,0,0,0,6238,6240,3,596,298,0,6239,6241,3,594,297, + 0,6240,6239,1,0,0,0,6240,6241,1,0,0,0,6241,6250,1,0,0,0,6242,6245, + 3,592,296,0,6243,6245,3,594,297,0,6244,6242,1,0,0,0,6244,6243,1, + 0,0,0,6245,6247,1,0,0,0,6246,6248,3,596,298,0,6247,6246,1,0,0,0, + 6247,6248,1,0,0,0,6248,6250,1,0,0,0,6249,6238,1,0,0,0,6249,6244, + 1,0,0,0,6250,591,1,0,0,0,6251,6254,5,74,0,0,6252,6255,3,674,337, + 0,6253,6255,5,30,0,0,6254,6252,1,0,0,0,6254,6253,1,0,0,0,6255,6258, + 1,0,0,0,6256,6257,5,6,0,0,6257,6259,3,674,337,0,6258,6256,1,0,0, + 0,6258,6259,1,0,0,0,6259,593,1,0,0,0,6260,6261,5,61,0,0,6261,6263, + 7,82,0,0,6262,6264,3,598,299,0,6263,6262,1,0,0,0,6263,6264,1,0,0, + 0,6264,6265,1,0,0,0,6265,6269,7,83,0,0,6266,6270,5,81,0,0,6267,6268, + 5,105,0,0,6268,6270,5,467,0,0,6269,6266,1,0,0,0,6269,6267,1,0,0, + 0,6270,595,1,0,0,0,6271,6276,5,79,0,0,6272,6273,3,598,299,0,6273, + 6274,7,83,0,0,6274,6277,1,0,0,0,6275,6277,3,674,337,0,6276,6272, + 1,0,0,0,6276,6275,1,0,0,0,6277,597,1,0,0,0,6278,6279,7,29,0,0,6279, + 6282,7,84,0,0,6280,6282,3,682,341,0,6281,6278,1,0,0,0,6281,6280, + 1,0,0,0,6282,599,1,0,0,0,6283,6284,5,66,0,0,6284,6286,5,147,0,0, + 6285,6287,7,80,0,0,6286,6285,1,0,0,0,6286,6287,1,0,0,0,6287,6288, + 1,0,0,0,6288,6289,3,602,301,0,6289,601,1,0,0,0,6290,6295,3,604,302, + 0,6291,6292,5,6,0,0,6292,6294,3,604,302,0,6293,6291,1,0,0,0,6294, + 6297,1,0,0,0,6295,6293,1,0,0,0,6295,6296,1,0,0,0,6296,603,1,0,0, + 0,6297,6295,1,0,0,0,6298,6322,3,734,367,0,6299,6300,5,2,0,0,6300, + 6322,5,3,0,0,6301,6303,7,85,0,0,6302,6301,1,0,0,0,6302,6303,1,0, + 0,0,6303,6304,1,0,0,0,6304,6305,5,2,0,0,6305,6310,3,734,367,0,6306, + 6307,5,6,0,0,6307,6309,3,734,367,0,6308,6306,1,0,0,0,6309,6312,1, + 0,0,0,6310,6308,1,0,0,0,6310,6311,1,0,0,0,6311,6313,1,0,0,0,6312, + 6310,1,0,0,0,6313,6314,5,3,0,0,6314,6322,1,0,0,0,6315,6316,5,470, + 0,0,6316,6317,5,471,0,0,6317,6318,5,2,0,0,6318,6319,3,602,301,0, + 6319,6320,5,3,0,0,6320,6322,1,0,0,0,6321,6298,1,0,0,0,6321,6299, + 1,0,0,0,6321,6302,1,0,0,0,6321,6315,1,0,0,0,6322,605,1,0,0,0,6323, + 6333,5,62,0,0,6324,6325,5,269,0,0,6325,6327,5,245,0,0,6326,6324, + 1,0,0,0,6326,6327,1,0,0,0,6327,6328,1,0,0,0,6328,6334,5,369,0,0, + 6329,6331,5,245,0,0,6330,6329,1,0,0,0,6330,6331,1,0,0,0,6331,6332, + 1,0,0,0,6332,6334,5,334,0,0,6333,6326,1,0,0,0,6333,6330,1,0,0,0, + 6334,6337,1,0,0,0,6335,6336,5,275,0,0,6336,6338,3,760,380,0,6337, + 6335,1,0,0,0,6337,6338,1,0,0,0,6338,6342,1,0,0,0,6339,6343,5,272, + 0,0,6340,6341,5,465,0,0,6341,6343,5,466,0,0,6342,6339,1,0,0,0,6342, + 6340,1,0,0,0,6342,6343,1,0,0,0,6343,6345,1,0,0,0,6344,6323,1,0,0, + 0,6345,6346,1,0,0,0,6346,6344,1,0,0,0,6346,6347,1,0,0,0,6347,6352, + 1,0,0,0,6348,6349,5,62,0,0,6349,6350,5,300,0,0,6350,6352,5,81,0, + 0,6351,6344,1,0,0,0,6351,6348,1,0,0,0,6352,607,1,0,0,0,6353,6354, + 5,422,0,0,6354,6359,3,534,267,0,6355,6356,5,6,0,0,6356,6358,3,534, + 267,0,6357,6355,1,0,0,0,6358,6361,1,0,0,0,6359,6357,1,0,0,0,6359, + 6360,1,0,0,0,6360,609,1,0,0,0,6361,6359,1,0,0,0,6362,6363,5,64,0, + 0,6363,6364,3,612,306,0,6364,611,1,0,0,0,6365,6370,3,614,307,0,6366, + 6367,5,6,0,0,6367,6369,3,614,307,0,6368,6366,1,0,0,0,6369,6372,1, + 0,0,0,6370,6368,1,0,0,0,6370,6371,1,0,0,0,6371,613,1,0,0,0,6372, + 6370,1,0,0,0,6373,6388,3,624,312,0,6374,6376,5,81,0,0,6375,6374, + 1,0,0,0,6375,6376,1,0,0,0,6376,6377,1,0,0,0,6377,6379,3,778,389, + 0,6378,6380,5,9,0,0,6379,6378,1,0,0,0,6379,6380,1,0,0,0,6380,6382, + 1,0,0,0,6381,6383,3,148,74,0,6382,6381,1,0,0,0,6382,6383,1,0,0,0, + 6383,6385,1,0,0,0,6384,6386,3,638,319,0,6385,6384,1,0,0,0,6385,6386, + 1,0,0,0,6386,6388,1,0,0,0,6387,6373,1,0,0,0,6387,6375,1,0,0,0,6388, + 6390,1,0,0,0,6389,6391,3,616,308,0,6390,6389,1,0,0,0,6390,6391,1, + 0,0,0,6391,6393,1,0,0,0,6392,6394,3,632,316,0,6393,6392,1,0,0,0, + 6393,6394,1,0,0,0,6394,6437,1,0,0,0,6395,6397,5,72,0,0,6396,6395, + 1,0,0,0,6396,6397,1,0,0,0,6397,6410,1,0,0,0,6398,6400,3,646,323, + 0,6399,6401,3,616,308,0,6400,6399,1,0,0,0,6400,6401,1,0,0,0,6401, + 6411,1,0,0,0,6402,6404,3,634,317,0,6403,6405,3,618,309,0,6404,6403, + 1,0,0,0,6404,6405,1,0,0,0,6405,6411,1,0,0,0,6406,6408,3,562,281, + 0,6407,6409,3,616,308,0,6408,6407,1,0,0,0,6408,6409,1,0,0,0,6409, + 6411,1,0,0,0,6410,6398,1,0,0,0,6410,6402,1,0,0,0,6410,6406,1,0,0, + 0,6411,6437,1,0,0,0,6412,6413,5,2,0,0,6413,6430,3,614,307,0,6414, + 6415,5,110,0,0,6415,6416,5,118,0,0,6416,6431,3,614,307,0,6417,6419, + 5,121,0,0,6418,6420,3,620,310,0,6419,6418,1,0,0,0,6419,6420,1,0, + 0,0,6420,6421,1,0,0,0,6421,6422,5,118,0,0,6422,6431,3,614,307,0, + 6423,6425,3,620,310,0,6424,6423,1,0,0,0,6424,6425,1,0,0,0,6425,6426, + 1,0,0,0,6426,6427,5,118,0,0,6427,6428,3,614,307,0,6428,6429,3,622, + 311,0,6429,6431,1,0,0,0,6430,6414,1,0,0,0,6430,6417,1,0,0,0,6430, + 6424,1,0,0,0,6430,6431,1,0,0,0,6431,6432,1,0,0,0,6432,6434,5,3,0, + 0,6433,6435,3,616,308,0,6434,6433,1,0,0,0,6434,6435,1,0,0,0,6435, + 6437,1,0,0,0,6436,6387,1,0,0,0,6436,6396,1,0,0,0,6436,6412,1,0,0, + 0,6437,6456,1,0,0,0,6438,6439,5,110,0,0,6439,6440,5,118,0,0,6440, + 6455,3,614,307,0,6441,6443,5,121,0,0,6442,6444,3,620,310,0,6443, + 6442,1,0,0,0,6443,6444,1,0,0,0,6444,6445,1,0,0,0,6445,6446,5,118, + 0,0,6446,6455,3,614,307,0,6447,6449,3,620,310,0,6448,6447,1,0,0, + 0,6448,6449,1,0,0,0,6449,6450,1,0,0,0,6450,6451,5,118,0,0,6451,6452, + 3,614,307,0,6452,6453,3,622,311,0,6453,6455,1,0,0,0,6454,6438,1, + 0,0,0,6454,6441,1,0,0,0,6454,6448,1,0,0,0,6455,6458,1,0,0,0,6456, + 6454,1,0,0,0,6456,6457,1,0,0,0,6457,615,1,0,0,0,6458,6456,1,0,0, + 0,6459,6461,5,36,0,0,6460,6459,1,0,0,0,6460,6461,1,0,0,0,6461,6462, + 1,0,0,0,6462,6467,3,818,409,0,6463,6464,5,2,0,0,6464,6465,3,784, + 392,0,6465,6466,5,3,0,0,6466,6468,1,0,0,0,6467,6463,1,0,0,0,6467, + 6468,1,0,0,0,6468,617,1,0,0,0,6469,6482,3,616,308,0,6470,6472,5, + 36,0,0,6471,6473,3,818,409,0,6472,6471,1,0,0,0,6472,6473,1,0,0,0, + 6473,6476,1,0,0,0,6474,6476,3,818,409,0,6475,6470,1,0,0,0,6475,6474, + 1,0,0,0,6476,6477,1,0,0,0,6477,6478,5,2,0,0,6478,6479,3,642,321, + 0,6479,6480,5,3,0,0,6480,6482,1,0,0,0,6481,6469,1,0,0,0,6481,6475, + 1,0,0,0,6482,619,1,0,0,0,6483,6485,7,86,0,0,6484,6486,5,123,0,0, + 6485,6484,1,0,0,0,6485,6486,1,0,0,0,6486,621,1,0,0,0,6487,6488,5, + 100,0,0,6488,6492,3,144,72,0,6489,6490,5,80,0,0,6490,6492,3,674, + 337,0,6491,6487,1,0,0,0,6491,6489,1,0,0,0,6492,623,1,0,0,0,6493, + 6509,3,322,161,0,6494,6500,5,81,0,0,6495,6501,3,774,387,0,6496,6497, + 5,2,0,0,6497,6498,3,774,387,0,6498,6499,5,3,0,0,6499,6501,1,0,0, + 0,6500,6495,1,0,0,0,6500,6496,1,0,0,0,6501,6509,1,0,0,0,6502,6503, + 5,68,0,0,6503,6506,5,323,0,0,6504,6507,3,790,395,0,6505,6507,5,111, + 0,0,6506,6504,1,0,0,0,6506,6505,1,0,0,0,6507,6509,1,0,0,0,6508,6493, + 1,0,0,0,6508,6494,1,0,0,0,6508,6502,1,0,0,0,6509,625,1,0,0,0,6510, + 6511,5,92,0,0,6511,6513,3,322,161,0,6512,6514,3,144,72,0,6513,6512, + 1,0,0,0,6513,6514,1,0,0,0,6514,6516,1,0,0,0,6515,6517,3,638,319, + 0,6516,6515,1,0,0,0,6516,6517,1,0,0,0,6517,6535,1,0,0,0,6518,6519, + 5,92,0,0,6519,6525,5,81,0,0,6520,6526,3,774,387,0,6521,6522,5,2, + 0,0,6522,6523,3,774,387,0,6523,6524,5,3,0,0,6524,6526,1,0,0,0,6525, + 6520,1,0,0,0,6525,6521,1,0,0,0,6526,6535,1,0,0,0,6527,6528,5,350, + 0,0,6528,6529,5,68,0,0,6529,6532,5,323,0,0,6530,6533,3,790,395,0, + 6531,6533,5,111,0,0,6532,6530,1,0,0,0,6532,6531,1,0,0,0,6533,6535, + 1,0,0,0,6534,6510,1,0,0,0,6534,6518,1,0,0,0,6534,6527,1,0,0,0,6535, + 627,1,0,0,0,6536,6541,3,624,312,0,6537,6538,5,6,0,0,6538,6540,3, + 624,312,0,6539,6537,1,0,0,0,6540,6543,1,0,0,0,6541,6539,1,0,0,0, + 6541,6542,1,0,0,0,6542,629,1,0,0,0,6543,6541,1,0,0,0,6544,6549,3, + 624,312,0,6545,6547,5,36,0,0,6546,6545,1,0,0,0,6546,6547,1,0,0,0, + 6547,6548,1,0,0,0,6548,6550,3,818,409,0,6549,6546,1,0,0,0,6549,6550, + 1,0,0,0,6550,631,1,0,0,0,6551,6552,5,472,0,0,6552,6553,3,806,403, + 0,6553,6559,3,534,267,0,6554,6555,5,310,0,0,6555,6556,5,2,0,0,6556, + 6557,3,674,337,0,6557,6558,5,3,0,0,6558,6560,1,0,0,0,6559,6554,1, + 0,0,0,6559,6560,1,0,0,0,6560,633,1,0,0,0,6561,6576,3,688,344,0,6562, + 6563,5,320,0,0,6563,6564,5,64,0,0,6564,6565,5,2,0,0,6565,6570,3, + 636,318,0,6566,6567,5,6,0,0,6567,6569,3,636,318,0,6568,6566,1,0, + 0,0,6569,6572,1,0,0,0,6570,6568,1,0,0,0,6570,6571,1,0,0,0,6571,6573, + 1,0,0,0,6572,6570,1,0,0,0,6573,6574,5,3,0,0,6574,6576,1,0,0,0,6575, + 6561,1,0,0,0,6575,6562,1,0,0,0,6576,6579,1,0,0,0,6577,6578,5,105, + 0,0,6578,6580,5,473,0,0,6579,6577,1,0,0,0,6579,6580,1,0,0,0,6580, + 635,1,0,0,0,6581,6587,3,688,344,0,6582,6583,5,36,0,0,6583,6584,5, + 2,0,0,6584,6585,3,642,321,0,6585,6586,5,3,0,0,6586,6588,1,0,0,0, + 6587,6582,1,0,0,0,6587,6588,1,0,0,0,6588,637,1,0,0,0,6589,6590,5, + 103,0,0,6590,6591,3,734,367,0,6591,639,1,0,0,0,6592,6597,5,103,0, + 0,6593,6594,5,434,0,0,6594,6595,5,275,0,0,6595,6598,3,818,409,0, + 6596,6598,3,674,337,0,6597,6593,1,0,0,0,6597,6596,1,0,0,0,6598,641, + 1,0,0,0,6599,6604,3,644,322,0,6600,6601,5,6,0,0,6601,6603,3,644, + 322,0,6602,6600,1,0,0,0,6603,6606,1,0,0,0,6604,6602,1,0,0,0,6604, + 6605,1,0,0,0,6605,643,1,0,0,0,6606,6604,1,0,0,0,6607,6608,3,818, + 409,0,6608,6610,3,652,326,0,6609,6611,3,98,49,0,6610,6609,1,0,0, + 0,6610,6611,1,0,0,0,6611,645,1,0,0,0,6612,6613,5,474,0,0,6613,6627, + 5,2,0,0,6614,6615,5,476,0,0,6615,6616,5,2,0,0,6616,6621,3,650,325, + 0,6617,6618,5,6,0,0,6618,6620,3,650,325,0,6619,6617,1,0,0,0,6620, + 6623,1,0,0,0,6621,6619,1,0,0,0,6621,6622,1,0,0,0,6622,6624,1,0,0, + 0,6623,6621,1,0,0,0,6624,6625,5,3,0,0,6625,6626,5,6,0,0,6626,6628, + 1,0,0,0,6627,6614,1,0,0,0,6627,6628,1,0,0,0,6628,6629,1,0,0,0,6629, + 6630,3,682,341,0,6630,6631,3,698,349,0,6631,6632,5,475,0,0,6632, + 6637,3,648,324,0,6633,6634,5,6,0,0,6634,6636,3,648,324,0,6635,6633, + 1,0,0,0,6636,6639,1,0,0,0,6637,6635,1,0,0,0,6637,6638,1,0,0,0,6638, + 6640,1,0,0,0,6639,6637,1,0,0,0,6640,6641,5,3,0,0,6641,647,1,0,0, + 0,6642,6661,3,818,409,0,6643,6657,3,652,326,0,6644,6647,5,53,0,0, + 6645,6647,3,826,413,0,6646,6644,1,0,0,0,6646,6645,1,0,0,0,6647,6648, + 1,0,0,0,6648,6654,3,674,337,0,6649,6651,5,77,0,0,6650,6649,1,0,0, + 0,6650,6651,1,0,0,0,6651,6652,1,0,0,0,6652,6654,5,78,0,0,6653,6646, + 1,0,0,0,6653,6650,1,0,0,0,6654,6655,1,0,0,0,6655,6653,1,0,0,0,6655, + 6656,1,0,0,0,6656,6658,1,0,0,0,6657,6653,1,0,0,0,6657,6658,1,0,0, + 0,6658,6662,1,0,0,0,6659,6660,5,62,0,0,6660,6662,5,473,0,0,6661, + 6643,1,0,0,0,6661,6659,1,0,0,0,6662,649,1,0,0,0,6663,6664,3,682, + 341,0,6664,6665,5,36,0,0,6665,6666,3,824,412,0,6666,6670,1,0,0,0, + 6667,6668,5,53,0,0,6668,6670,3,682,341,0,6669,6663,1,0,0,0,6669, + 6667,1,0,0,0,6670,651,1,0,0,0,6671,6673,5,415,0,0,6672,6671,1,0, + 0,0,6672,6673,1,0,0,0,6673,6674,1,0,0,0,6674,6691,3,654,327,0,6675, + 6677,5,4,0,0,6676,6678,5,571,0,0,6677,6676,1,0,0,0,6677,6678,1,0, + 0,0,6678,6679,1,0,0,0,6679,6681,5,5,0,0,6680,6675,1,0,0,0,6681,6684, + 1,0,0,0,6682,6680,1,0,0,0,6682,6683,1,0,0,0,6683,6692,1,0,0,0,6684, + 6682,1,0,0,0,6685,6689,5,35,0,0,6686,6687,5,4,0,0,6687,6688,5,571, + 0,0,6688,6690,5,5,0,0,6689,6686,1,0,0,0,6689,6690,1,0,0,0,6690,6692, + 1,0,0,0,6691,6682,1,0,0,0,6691,6685,1,0,0,0,6692,6698,1,0,0,0,6693, + 6694,3,780,390,0,6694,6695,5,27,0,0,6695,6696,7,87,0,0,6696,6698, + 1,0,0,0,6697,6672,1,0,0,0,6697,6693,1,0,0,0,6698,653,1,0,0,0,6699, + 6701,3,820,410,0,6700,6702,3,318,159,0,6701,6700,1,0,0,0,6701,6702, + 1,0,0,0,6702,6704,1,0,0,0,6703,6705,3,534,267,0,6704,6703,1,0,0, + 0,6704,6705,1,0,0,0,6705,6715,1,0,0,0,6706,6715,3,656,328,0,6707, + 6712,5,403,0,0,6708,6710,3,668,334,0,6709,6708,1,0,0,0,6709,6710, + 1,0,0,0,6710,6713,1,0,0,0,6711,6713,3,660,330,0,6712,6709,1,0,0, + 0,6712,6711,1,0,0,0,6713,6715,1,0,0,0,6714,6699,1,0,0,0,6714,6706, + 1,0,0,0,6714,6707,1,0,0,0,6715,655,1,0,0,0,6716,6721,3,658,329,0, + 6717,6721,3,662,331,0,6718,6721,3,664,332,0,6719,6721,3,666,333, + 0,6720,6716,1,0,0,0,6720,6717,1,0,0,0,6720,6718,1,0,0,0,6720,6719, + 1,0,0,0,6721,657,1,0,0,0,6722,6739,5,401,0,0,6723,6739,5,402,0,0, + 6724,6739,5,416,0,0,6725,6739,5,388,0,0,6726,6739,5,413,0,0,6727, + 6729,5,398,0,0,6728,6730,3,660,330,0,6729,6728,1,0,0,0,6729,6730, + 1,0,0,0,6730,6739,1,0,0,0,6731,6732,5,190,0,0,6732,6739,5,412,0, + 0,6733,6735,7,88,0,0,6734,6736,3,534,267,0,6735,6734,1,0,0,0,6735, + 6736,1,0,0,0,6736,6739,1,0,0,0,6737,6739,5,390,0,0,6738,6722,1,0, + 0,0,6738,6723,1,0,0,0,6738,6724,1,0,0,0,6738,6725,1,0,0,0,6738,6726, + 1,0,0,0,6738,6727,1,0,0,0,6738,6731,1,0,0,0,6738,6733,1,0,0,0,6738, + 6737,1,0,0,0,6739,659,1,0,0,0,6740,6741,5,2,0,0,6741,6742,5,571, + 0,0,6742,6743,5,3,0,0,6743,661,1,0,0,0,6744,6746,5,389,0,0,6745, + 6747,5,374,0,0,6746,6745,1,0,0,0,6746,6747,1,0,0,0,6747,6749,1,0, + 0,0,6748,6750,3,534,267,0,6749,6748,1,0,0,0,6749,6750,1,0,0,0,6750, + 663,1,0,0,0,6751,6753,7,89,0,0,6752,6754,5,374,0,0,6753,6752,1,0, + 0,0,6753,6754,1,0,0,0,6754,6762,1,0,0,0,6755,6762,5,423,0,0,6756, + 6757,5,405,0,0,6757,6759,7,90,0,0,6758,6760,5,374,0,0,6759,6758, + 1,0,0,0,6759,6760,1,0,0,0,6760,6762,1,0,0,0,6761,6751,1,0,0,0,6761, + 6755,1,0,0,0,6761,6756,1,0,0,0,6762,6764,1,0,0,0,6763,6765,3,660, + 330,0,6764,6763,1,0,0,0,6764,6765,1,0,0,0,6765,665,1,0,0,0,6766, + 6768,7,91,0,0,6767,6769,3,660,330,0,6768,6767,1,0,0,0,6768,6769, + 1,0,0,0,6769,6773,1,0,0,0,6770,6771,7,26,0,0,6771,6772,5,418,0,0, + 6772,6774,5,386,0,0,6773,6770,1,0,0,0,6773,6774,1,0,0,0,6774,667, + 1,0,0,0,6775,6805,5,264,0,0,6776,6805,3,670,335,0,6777,6780,5,384, + 0,0,6778,6779,5,94,0,0,6779,6781,5,264,0,0,6780,6778,1,0,0,0,6780, + 6781,1,0,0,0,6781,6805,1,0,0,0,6782,6789,5,176,0,0,6783,6787,5,94, + 0,0,6784,6788,5,218,0,0,6785,6788,5,261,0,0,6786,6788,3,670,335, + 0,6787,6784,1,0,0,0,6787,6785,1,0,0,0,6787,6786,1,0,0,0,6788,6790, + 1,0,0,0,6789,6783,1,0,0,0,6789,6790,1,0,0,0,6790,6805,1,0,0,0,6791, + 6797,5,218,0,0,6792,6795,5,94,0,0,6793,6796,5,261,0,0,6794,6796, + 3,670,335,0,6795,6793,1,0,0,0,6795,6794,1,0,0,0,6796,6798,1,0,0, + 0,6797,6792,1,0,0,0,6797,6798,1,0,0,0,6798,6805,1,0,0,0,6799,6802, + 5,261,0,0,6800,6801,5,94,0,0,6801,6803,3,670,335,0,6802,6800,1,0, + 0,0,6802,6803,1,0,0,0,6803,6805,1,0,0,0,6804,6775,1,0,0,0,6804,6776, + 1,0,0,0,6804,6777,1,0,0,0,6804,6782,1,0,0,0,6804,6791,1,0,0,0,6804, + 6799,1,0,0,0,6805,669,1,0,0,0,6806,6808,5,326,0,0,6807,6809,3,660, + 330,0,6808,6807,1,0,0,0,6808,6809,1,0,0,0,6809,671,1,0,0,0,6810, + 6811,7,92,0,0,6811,673,1,0,0,0,6812,6813,3,676,338,0,6813,675,1, + 0,0,0,6814,6815,6,338,-1,0,6815,6817,3,680,340,0,6816,6818,3,678, + 339,0,6817,6816,1,0,0,0,6817,6818,1,0,0,0,6818,6822,1,0,0,0,6819, + 6820,5,77,0,0,6820,6822,3,676,338,3,6821,6814,1,0,0,0,6821,6819, + 1,0,0,0,6822,6831,1,0,0,0,6823,6824,10,2,0,0,6824,6825,5,33,0,0, + 6825,6830,3,676,338,3,6826,6827,10,1,0,0,6827,6828,5,82,0,0,6828, + 6830,3,676,338,2,6829,6823,1,0,0,0,6829,6826,1,0,0,0,6830,6833,1, + 0,0,0,6831,6829,1,0,0,0,6831,6832,1,0,0,0,6832,677,1,0,0,0,6833, + 6831,1,0,0,0,6834,6835,3,672,336,0,6835,6836,3,680,340,0,6836,6906, + 1,0,0,0,6837,6838,3,672,336,0,6838,6839,3,728,364,0,6839,6845,3, + 718,359,0,6840,6846,3,562,281,0,6841,6842,5,2,0,0,6842,6843,3,674, + 337,0,6843,6844,5,3,0,0,6844,6846,1,0,0,0,6845,6840,1,0,0,0,6845, + 6841,1,0,0,0,6846,6906,1,0,0,0,6847,6849,5,77,0,0,6848,6847,1,0, + 0,0,6848,6849,1,0,0,0,6849,6850,1,0,0,0,6850,6851,5,387,0,0,6851, + 6852,3,680,340,0,6852,6853,5,33,0,0,6853,6854,3,680,340,0,6854,6906, + 1,0,0,0,6855,6857,5,77,0,0,6856,6855,1,0,0,0,6856,6857,1,0,0,0,6857, + 6858,1,0,0,0,6858,6859,5,68,0,0,6859,6860,5,2,0,0,6860,6865,3,674, + 337,0,6861,6862,5,6,0,0,6862,6864,3,674,337,0,6863,6861,1,0,0,0, + 6864,6867,1,0,0,0,6865,6863,1,0,0,0,6865,6866,1,0,0,0,6866,6868, + 1,0,0,0,6867,6865,1,0,0,0,6868,6869,5,3,0,0,6869,6906,1,0,0,0,6870, + 6872,5,77,0,0,6871,6870,1,0,0,0,6871,6872,1,0,0,0,6872,6873,1,0, + 0,0,6873,6874,5,68,0,0,6874,6906,3,562,281,0,6875,6877,5,77,0,0, + 6876,6875,1,0,0,0,6876,6877,1,0,0,0,6877,6886,1,0,0,0,6878,6887, + 5,120,0,0,6879,6887,5,114,0,0,6880,6881,5,127,0,0,6881,6887,5,94, + 0,0,6882,6884,5,387,0,0,6883,6885,5,91,0,0,6884,6883,1,0,0,0,6884, + 6885,1,0,0,0,6885,6887,1,0,0,0,6886,6878,1,0,0,0,6886,6879,1,0,0, + 0,6886,6880,1,0,0,0,6886,6882,1,0,0,0,6887,6888,1,0,0,0,6888,6891, + 3,680,340,0,6889,6890,5,197,0,0,6890,6892,3,680,340,0,6891,6889, + 1,0,0,0,6891,6892,1,0,0,0,6892,6906,1,0,0,0,6893,6895,5,116,0,0, + 6894,6896,5,77,0,0,6895,6894,1,0,0,0,6895,6896,1,0,0,0,6896,6897, + 1,0,0,0,6897,6906,5,78,0,0,6898,6900,5,116,0,0,6899,6901,5,77,0, + 0,6900,6899,1,0,0,0,6900,6901,1,0,0,0,6901,6902,1,0,0,0,6902,6903, + 5,56,0,0,6903,6904,5,64,0,0,6904,6906,3,680,340,0,6905,6834,1,0, + 0,0,6905,6837,1,0,0,0,6905,6848,1,0,0,0,6905,6856,1,0,0,0,6905,6871, + 1,0,0,0,6905,6876,1,0,0,0,6905,6893,1,0,0,0,6905,6898,1,0,0,0,6906, + 679,1,0,0,0,6907,6908,6,340,-1,0,6908,6912,3,682,341,0,6909,6910, + 7,29,0,0,6910,6912,3,680,340,4,6911,6907,1,0,0,0,6911,6909,1,0,0, + 0,6912,6929,1,0,0,0,6913,6914,10,3,0,0,6914,6915,7,93,0,0,6915,6928, + 3,680,340,4,6916,6917,10,2,0,0,6917,6918,7,29,0,0,6918,6928,3,680, + 340,3,6919,6920,10,1,0,0,6920,6921,5,15,0,0,6921,6928,3,680,340, + 2,6922,6923,10,5,0,0,6923,6924,5,142,0,0,6924,6925,5,418,0,0,6925, + 6926,5,386,0,0,6926,6928,3,674,337,0,6927,6913,1,0,0,0,6927,6916, + 1,0,0,0,6927,6919,1,0,0,0,6927,6922,1,0,0,0,6928,6931,1,0,0,0,6929, + 6927,1,0,0,0,6929,6930,1,0,0,0,6930,681,1,0,0,0,6931,6929,1,0,0, + 0,6932,6933,6,341,-1,0,6933,6934,7,94,0,0,6934,7021,3,562,281,0, + 6935,6938,5,35,0,0,6936,6939,3,562,281,0,6937,6939,3,740,370,0,6938, + 6936,1,0,0,0,6938,6937,1,0,0,0,6939,7021,1,0,0,0,6940,6941,5,28, + 0,0,6941,7021,3,754,377,0,6942,6943,5,470,0,0,6943,7021,3,534,267, + 0,6944,7021,5,571,0,0,6945,7021,5,573,0,0,6946,7021,5,563,0,0,6947, + 7021,5,567,0,0,6948,6958,3,806,403,0,6949,6959,3,808,404,0,6950, + 6951,5,2,0,0,6951,6953,3,736,368,0,6952,6954,3,586,293,0,6953,6952, + 1,0,0,0,6953,6954,1,0,0,0,6954,6955,1,0,0,0,6955,6956,5,3,0,0,6956, + 6957,3,808,404,0,6957,6959,1,0,0,0,6958,6949,1,0,0,0,6958,6950,1, + 0,0,0,6959,7021,1,0,0,0,6960,6962,3,656,328,0,6961,6960,1,0,0,0, + 6961,6962,1,0,0,0,6962,6963,1,0,0,0,6963,7021,3,808,404,0,6964,6972, + 5,403,0,0,6965,6967,3,808,404,0,6966,6968,3,668,334,0,6967,6966, + 1,0,0,0,6967,6968,1,0,0,0,6968,6973,1,0,0,0,6969,6970,3,660,330, + 0,6970,6971,3,808,404,0,6971,6973,1,0,0,0,6972,6965,1,0,0,0,6972, + 6969,1,0,0,0,6973,7021,1,0,0,0,6974,7021,5,96,0,0,6975,7021,5,60, + 0,0,6976,7021,5,78,0,0,6977,7021,5,574,0,0,6978,6979,5,2,0,0,6979, + 6980,3,674,337,0,6980,6981,5,3,0,0,6981,6982,3,754,377,0,6982,7021, + 1,0,0,0,6983,6985,5,40,0,0,6984,6986,3,674,337,0,6985,6984,1,0,0, + 0,6985,6986,1,0,0,0,6986,6988,1,0,0,0,6987,6989,3,748,374,0,6988, + 6987,1,0,0,0,6989,6990,1,0,0,0,6990,6988,1,0,0,0,6990,6991,1,0,0, + 0,6991,6994,1,0,0,0,6992,6993,5,58,0,0,6993,6995,3,674,337,0,6994, + 6992,1,0,0,0,6994,6995,1,0,0,0,6995,6996,1,0,0,0,6996,6997,5,454, + 0,0,6997,7021,1,0,0,0,6998,7021,3,686,343,0,6999,7001,3,562,281, + 0,7000,7002,3,752,376,0,7001,7000,1,0,0,0,7001,7002,1,0,0,0,7002, + 7021,1,0,0,0,7003,7021,3,716,358,0,7004,7005,5,2,0,0,7005,7006,3, + 674,337,0,7006,7007,5,6,0,0,7007,7008,3,730,365,0,7008,7009,5,3, + 0,0,7009,7021,1,0,0,0,7010,7011,3,714,357,0,7011,7012,5,125,0,0, + 7012,7013,3,714,357,0,7013,7021,1,0,0,0,7014,7021,3,780,390,0,7015, + 7016,7,29,0,0,7016,7021,3,682,341,5,7017,7018,3,724,362,0,7018,7019, + 3,682,341,2,7019,7021,1,0,0,0,7020,6932,1,0,0,0,7020,6935,1,0,0, + 0,7020,6940,1,0,0,0,7020,6942,1,0,0,0,7020,6944,1,0,0,0,7020,6945, + 1,0,0,0,7020,6946,1,0,0,0,7020,6947,1,0,0,0,7020,6948,1,0,0,0,7020, + 6961,1,0,0,0,7020,6964,1,0,0,0,7020,6974,1,0,0,0,7020,6975,1,0,0, + 0,7020,6976,1,0,0,0,7020,6977,1,0,0,0,7020,6978,1,0,0,0,7020,6983, + 1,0,0,0,7020,6998,1,0,0,0,7020,6999,1,0,0,0,7020,7003,1,0,0,0,7020, + 7004,1,0,0,0,7020,7010,1,0,0,0,7020,7014,1,0,0,0,7020,7015,1,0,0, + 0,7020,7017,1,0,0,0,7021,7049,1,0,0,0,7022,7023,10,3,0,0,7023,7024, + 3,722,361,0,7024,7025,3,682,341,4,7025,7048,1,0,0,0,7026,7027,10, + 6,0,0,7027,7028,5,26,0,0,7028,7048,3,652,326,0,7029,7030,10,4,0, + 0,7030,7032,3,724,362,0,7031,7033,3,682,341,0,7032,7031,1,0,0,0, + 7032,7033,1,0,0,0,7033,7048,1,0,0,0,7034,7035,10,1,0,0,7035,7037, + 5,116,0,0,7036,7038,5,77,0,0,7037,7036,1,0,0,0,7037,7038,1,0,0,0, + 7038,7045,1,0,0,0,7039,7040,5,56,0,0,7040,7041,5,64,0,0,7041,7046, + 3,682,341,0,7042,7043,5,275,0,0,7043,7046,3,528,264,0,7044,7046, + 5,188,0,0,7045,7039,1,0,0,0,7045,7042,1,0,0,0,7045,7044,1,0,0,0, + 7046,7048,1,0,0,0,7047,7022,1,0,0,0,7047,7026,1,0,0,0,7047,7029, + 1,0,0,0,7047,7034,1,0,0,0,7048,7051,1,0,0,0,7049,7047,1,0,0,0,7049, + 7050,1,0,0,0,7050,683,1,0,0,0,7051,7049,1,0,0,0,7052,7078,3,806, + 403,0,7053,7075,5,2,0,0,7054,7058,3,736,368,0,7055,7056,5,6,0,0, + 7056,7057,5,101,0,0,7057,7059,3,738,369,0,7058,7055,1,0,0,0,7058, + 7059,1,0,0,0,7059,7061,1,0,0,0,7060,7062,3,586,293,0,7061,7060,1, + 0,0,0,7061,7062,1,0,0,0,7062,7076,1,0,0,0,7063,7064,5,101,0,0,7064, + 7066,3,738,369,0,7065,7067,3,586,293,0,7066,7065,1,0,0,0,7066,7067, + 1,0,0,0,7067,7076,1,0,0,0,7068,7069,7,80,0,0,7069,7071,3,736,368, + 0,7070,7072,3,586,293,0,7071,7070,1,0,0,0,7071,7072,1,0,0,0,7072, + 7076,1,0,0,0,7073,7076,5,9,0,0,7074,7076,1,0,0,0,7075,7054,1,0,0, + 0,7075,7063,1,0,0,0,7075,7068,1,0,0,0,7075,7073,1,0,0,0,7075,7074, + 1,0,0,0,7076,7077,1,0,0,0,7077,7079,5,3,0,0,7078,7053,1,0,0,0,7078, + 7079,1,0,0,0,7079,685,1,0,0,0,7080,7087,3,684,342,0,7081,7082,5, + 479,0,0,7082,7083,5,66,0,0,7083,7084,5,2,0,0,7084,7085,3,586,293, + 0,7085,7086,5,3,0,0,7086,7088,1,0,0,0,7087,7081,1,0,0,0,7087,7088, + 1,0,0,0,7088,7095,1,0,0,0,7089,7090,5,480,0,0,7090,7091,5,2,0,0, + 7091,7092,5,103,0,0,7092,7093,3,674,337,0,7093,7094,5,3,0,0,7094, + 7096,1,0,0,0,7095,7089,1,0,0,0,7095,7096,1,0,0,0,7096,7102,1,0,0, + 0,7097,7100,5,124,0,0,7098,7101,3,708,354,0,7099,7101,3,818,409, + 0,7100,7098,1,0,0,0,7100,7099,1,0,0,0,7101,7103,1,0,0,0,7102,7097, + 1,0,0,0,7102,7103,1,0,0,0,7103,7106,1,0,0,0,7104,7106,3,690,345, + 0,7105,7080,1,0,0,0,7105,7104,1,0,0,0,7106,687,1,0,0,0,7107,7110, + 3,684,342,0,7108,7110,3,690,345,0,7109,7107,1,0,0,0,7109,7108,1, + 0,0,0,7110,689,1,0,0,0,7111,7112,5,108,0,0,7112,7113,5,62,0,0,7113, + 7114,5,2,0,0,7114,7115,3,674,337,0,7115,7116,5,3,0,0,7116,7286,1, + 0,0,0,7117,7286,5,48,0,0,7118,7120,7,95,0,0,7119,7121,3,660,330, + 0,7120,7119,1,0,0,0,7120,7121,1,0,0,0,7121,7286,1,0,0,0,7122,7286, + 5,49,0,0,7123,7286,5,52,0,0,7124,7286,5,89,0,0,7125,7286,5,99,0, + 0,7126,7286,5,47,0,0,7127,7286,5,111,0,0,7128,7129,7,96,0,0,7129, + 7130,5,2,0,0,7130,7131,3,674,337,0,7131,7132,5,36,0,0,7132,7133, + 3,652,326,0,7133,7134,5,3,0,0,7134,7286,1,0,0,0,7135,7136,5,397, + 0,0,7136,7141,5,2,0,0,7137,7138,3,742,371,0,7138,7139,5,64,0,0,7139, + 7140,3,674,337,0,7140,7142,1,0,0,0,7141,7137,1,0,0,0,7141,7142,1, + 0,0,0,7142,7143,1,0,0,0,7143,7286,5,3,0,0,7144,7145,5,489,0,0,7145, + 7146,5,2,0,0,7146,7149,3,674,337,0,7147,7148,5,6,0,0,7148,7150,3, + 744,372,0,7149,7147,1,0,0,0,7149,7150,1,0,0,0,7150,7151,1,0,0,0, + 7151,7152,5,3,0,0,7152,7286,1,0,0,0,7153,7154,5,410,0,0,7154,7155, + 5,2,0,0,7155,7156,3,674,337,0,7156,7157,5,84,0,0,7157,7158,3,674, + 337,0,7158,7159,5,64,0,0,7159,7162,3,674,337,0,7160,7161,5,62,0, + 0,7161,7163,3,674,337,0,7162,7160,1,0,0,0,7162,7163,1,0,0,0,7163, + 7164,1,0,0,0,7164,7165,5,3,0,0,7165,7286,1,0,0,0,7166,7167,5,411, + 0,0,7167,7172,5,2,0,0,7168,7169,3,682,341,0,7169,7170,5,68,0,0,7170, + 7171,3,682,341,0,7171,7173,1,0,0,0,7172,7168,1,0,0,0,7172,7173,1, + 0,0,0,7173,7174,1,0,0,0,7174,7286,5,3,0,0,7175,7176,5,417,0,0,7176, + 7178,5,2,0,0,7177,7179,3,746,373,0,7178,7177,1,0,0,0,7178,7179,1, + 0,0,0,7179,7180,1,0,0,0,7180,7286,5,3,0,0,7181,7182,5,421,0,0,7182, + 7184,5,2,0,0,7183,7185,7,97,0,0,7184,7183,1,0,0,0,7184,7185,1,0, + 0,0,7185,7190,1,0,0,0,7186,7188,3,674,337,0,7187,7186,1,0,0,0,7187, + 7188,1,0,0,0,7188,7189,1,0,0,0,7189,7191,5,64,0,0,7190,7187,1,0, + 0,0,7190,7191,1,0,0,0,7191,7192,1,0,0,0,7192,7193,3,730,365,0,7193, + 7194,1,0,0,0,7194,7195,5,3,0,0,7195,7286,1,0,0,0,7196,7197,5,408, + 0,0,7197,7198,5,2,0,0,7198,7199,3,674,337,0,7199,7200,5,6,0,0,7200, + 7201,3,674,337,0,7201,7202,5,3,0,0,7202,7286,1,0,0,0,7203,7204,7, + 98,0,0,7204,7286,3,534,267,0,7205,7206,5,426,0,0,7206,7207,5,2,0, + 0,7207,7208,5,266,0,0,7208,7218,3,824,412,0,7209,7216,5,6,0,0,7210, + 7211,5,424,0,0,7211,7212,5,2,0,0,7212,7213,3,692,346,0,7213,7214, + 5,3,0,0,7214,7217,1,0,0,0,7215,7217,3,730,365,0,7216,7210,1,0,0, + 0,7216,7215,1,0,0,0,7217,7219,1,0,0,0,7218,7209,1,0,0,0,7218,7219, + 1,0,0,0,7219,7220,1,0,0,0,7220,7221,5,3,0,0,7221,7286,1,0,0,0,7222, + 7223,5,427,0,0,7223,7224,5,2,0,0,7224,7225,3,682,341,0,7225,7226, + 3,698,349,0,7226,7227,5,3,0,0,7227,7286,1,0,0,0,7228,7229,5,428, + 0,0,7229,7230,5,2,0,0,7230,7231,3,692,346,0,7231,7232,5,3,0,0,7232, + 7286,1,0,0,0,7233,7234,5,429,0,0,7234,7235,5,2,0,0,7235,7236,3,696, + 348,0,7236,7239,3,674,337,0,7237,7238,7,99,0,0,7238,7240,5,378,0, + 0,7239,7237,1,0,0,0,7239,7240,1,0,0,0,7240,7241,1,0,0,0,7241,7242, + 5,3,0,0,7242,7286,1,0,0,0,7243,7244,5,430,0,0,7244,7245,5,2,0,0, + 7245,7246,5,266,0,0,7246,7249,3,824,412,0,7247,7248,5,6,0,0,7248, + 7250,3,674,337,0,7249,7247,1,0,0,0,7249,7250,1,0,0,0,7250,7251,1, + 0,0,0,7251,7252,5,3,0,0,7252,7286,1,0,0,0,7253,7254,5,431,0,0,7254, + 7255,5,2,0,0,7255,7256,5,383,0,0,7256,7257,3,674,337,0,7257,7258, + 5,6,0,0,7258,7262,5,375,0,0,7259,7260,5,269,0,0,7260,7263,5,450, + 0,0,7261,7263,3,674,337,0,7262,7259,1,0,0,0,7262,7261,1,0,0,0,7263, + 7273,1,0,0,0,7264,7265,5,6,0,0,7265,7271,5,339,0,0,7266,7268,5,269, + 0,0,7267,7266,1,0,0,0,7267,7268,1,0,0,0,7268,7269,1,0,0,0,7269,7272, + 5,450,0,0,7270,7272,5,385,0,0,7271,7267,1,0,0,0,7271,7270,1,0,0, + 0,7272,7274,1,0,0,0,7273,7264,1,0,0,0,7273,7274,1,0,0,0,7274,7275, + 1,0,0,0,7275,7276,5,3,0,0,7276,7286,1,0,0,0,7277,7278,5,432,0,0, + 7278,7279,5,2,0,0,7279,7280,3,696,348,0,7280,7281,3,674,337,0,7281, + 7282,5,36,0,0,7282,7283,3,654,327,0,7283,7284,5,3,0,0,7284,7286, + 1,0,0,0,7285,7111,1,0,0,0,7285,7117,1,0,0,0,7285,7118,1,0,0,0,7285, + 7122,1,0,0,0,7285,7123,1,0,0,0,7285,7124,1,0,0,0,7285,7125,1,0,0, + 0,7285,7126,1,0,0,0,7285,7127,1,0,0,0,7285,7128,1,0,0,0,7285,7135, + 1,0,0,0,7285,7144,1,0,0,0,7285,7153,1,0,0,0,7285,7166,1,0,0,0,7285, + 7175,1,0,0,0,7285,7181,1,0,0,0,7285,7196,1,0,0,0,7285,7203,1,0,0, + 0,7285,7205,1,0,0,0,7285,7222,1,0,0,0,7285,7228,1,0,0,0,7285,7233, + 1,0,0,0,7285,7243,1,0,0,0,7285,7253,1,0,0,0,7285,7277,1,0,0,0,7286, + 691,1,0,0,0,7287,7292,3,694,347,0,7288,7289,5,6,0,0,7289,7291,3, + 694,347,0,7290,7288,1,0,0,0,7291,7294,1,0,0,0,7292,7290,1,0,0,0, + 7292,7293,1,0,0,0,7293,693,1,0,0,0,7294,7292,1,0,0,0,7295,7298,3, + 674,337,0,7296,7297,5,36,0,0,7297,7299,3,824,412,0,7298,7296,1,0, + 0,0,7298,7299,1,0,0,0,7299,695,1,0,0,0,7300,7301,7,100,0,0,7301, + 697,1,0,0,0,7302,7304,5,286,0,0,7303,7305,3,700,350,0,7304,7303, + 1,0,0,0,7304,7305,1,0,0,0,7305,7306,1,0,0,0,7306,7308,3,682,341, + 0,7307,7309,3,700,350,0,7308,7307,1,0,0,0,7308,7309,1,0,0,0,7309, + 699,1,0,0,0,7310,7311,5,147,0,0,7311,7312,7,101,0,0,7312,701,1,0, + 0,0,7313,7314,5,104,0,0,7314,7319,3,704,352,0,7315,7316,5,6,0,0, + 7316,7318,3,704,352,0,7317,7315,1,0,0,0,7318,7321,1,0,0,0,7319,7317, + 1,0,0,0,7319,7320,1,0,0,0,7320,703,1,0,0,0,7321,7319,1,0,0,0,7322, + 7323,3,818,409,0,7323,7324,5,36,0,0,7324,7325,3,708,354,0,7325,705, + 1,0,0,0,7326,7329,5,124,0,0,7327,7330,3,708,354,0,7328,7330,3,818, + 409,0,7329,7327,1,0,0,0,7329,7328,1,0,0,0,7330,707,1,0,0,0,7331, + 7333,5,2,0,0,7332,7334,3,818,409,0,7333,7332,1,0,0,0,7333,7334,1, + 0,0,0,7334,7338,1,0,0,0,7335,7336,5,285,0,0,7336,7337,5,147,0,0, + 7337,7339,3,730,365,0,7338,7335,1,0,0,0,7338,7339,1,0,0,0,7339,7341, + 1,0,0,0,7340,7342,3,586,293,0,7341,7340,1,0,0,0,7341,7342,1,0,0, + 0,7342,7344,1,0,0,0,7343,7345,3,710,355,0,7344,7343,1,0,0,0,7344, + 7345,1,0,0,0,7345,7346,1,0,0,0,7346,7347,5,3,0,0,7347,709,1,0,0, + 0,7348,7353,7,102,0,0,7349,7350,5,387,0,0,7350,7351,3,712,356,0, + 7351,7352,5,33,0,0,7352,7354,1,0,0,0,7353,7349,1,0,0,0,7353,7354, + 1,0,0,0,7354,7355,1,0,0,0,7355,7356,3,712,356,0,7356,7366,1,0,0, + 0,7357,7364,5,199,0,0,7358,7359,5,434,0,0,7359,7365,5,414,0,0,7360, + 7365,5,66,0,0,7361,7365,5,467,0,0,7362,7363,5,269,0,0,7363,7365, + 5,482,0,0,7364,7358,1,0,0,0,7364,7360,1,0,0,0,7364,7361,1,0,0,0, + 7364,7362,1,0,0,0,7365,7367,1,0,0,0,7366,7357,1,0,0,0,7366,7367, + 1,0,0,0,7367,711,1,0,0,0,7368,7371,5,362,0,0,7369,7371,3,674,337, + 0,7370,7368,1,0,0,0,7370,7369,1,0,0,0,7371,7372,1,0,0,0,7372,7376, + 7,103,0,0,7373,7374,5,434,0,0,7374,7376,5,414,0,0,7375,7370,1,0, + 0,0,7375,7373,1,0,0,0,7376,713,1,0,0,0,7377,7385,3,716,358,0,7378, + 7379,5,2,0,0,7379,7380,3,730,365,0,7380,7381,5,6,0,0,7381,7382,3, + 674,337,0,7382,7383,5,3,0,0,7383,7385,1,0,0,0,7384,7377,1,0,0,0, + 7384,7378,1,0,0,0,7385,715,1,0,0,0,7386,7387,5,414,0,0,7387,7389, + 5,2,0,0,7388,7390,3,730,365,0,7389,7388,1,0,0,0,7389,7390,1,0,0, + 0,7390,7391,1,0,0,0,7391,7392,5,3,0,0,7392,717,1,0,0,0,7393,7394, + 7,104,0,0,7394,719,1,0,0,0,7395,7398,5,29,0,0,7396,7398,3,722,361, + 0,7397,7395,1,0,0,0,7397,7396,1,0,0,0,7398,721,1,0,0,0,7399,7400, + 7,105,0,0,7400,723,1,0,0,0,7401,7408,5,29,0,0,7402,7403,5,278,0, + 0,7403,7404,5,2,0,0,7404,7405,3,414,207,0,7405,7406,5,3,0,0,7406, + 7408,1,0,0,0,7407,7401,1,0,0,0,7407,7402,1,0,0,0,7408,725,1,0,0, + 0,7409,7416,3,720,360,0,7410,7411,5,278,0,0,7411,7412,5,2,0,0,7412, + 7413,3,414,207,0,7413,7414,5,3,0,0,7414,7416,1,0,0,0,7415,7409,1, + 0,0,0,7415,7410,1,0,0,0,7416,727,1,0,0,0,7417,7423,3,726,363,0,7418, + 7420,5,77,0,0,7419,7418,1,0,0,0,7419,7420,1,0,0,0,7420,7421,1,0, + 0,0,7421,7423,7,106,0,0,7422,7417,1,0,0,0,7422,7419,1,0,0,0,7423, + 729,1,0,0,0,7424,7429,3,674,337,0,7425,7426,5,6,0,0,7426,7428,3, + 674,337,0,7427,7425,1,0,0,0,7428,7431,1,0,0,0,7429,7427,1,0,0,0, + 7429,7430,1,0,0,0,7430,731,1,0,0,0,7431,7429,1,0,0,0,7432,7433,5, + 2,0,0,7433,7434,3,674,337,0,7434,7435,5,3,0,0,7435,7438,1,0,0,0, + 7436,7438,3,800,400,0,7437,7432,1,0,0,0,7437,7436,1,0,0,0,7438,733, + 1,0,0,0,7439,7442,3,674,337,0,7440,7442,3,800,400,0,7441,7439,1, + 0,0,0,7441,7440,1,0,0,0,7442,735,1,0,0,0,7443,7448,3,738,369,0,7444, + 7445,5,6,0,0,7445,7447,3,738,369,0,7446,7444,1,0,0,0,7447,7450,1, + 0,0,0,7448,7446,1,0,0,0,7448,7449,1,0,0,0,7449,737,1,0,0,0,7450, + 7448,1,0,0,0,7451,7457,3,674,337,0,7452,7453,3,820,410,0,7453,7454, + 7,107,0,0,7454,7455,3,674,337,0,7455,7457,1,0,0,0,7456,7451,1,0, + 0,0,7456,7452,1,0,0,0,7457,739,1,0,0,0,7458,7468,5,4,0,0,7459,7469, + 3,730,365,0,7460,7465,3,740,370,0,7461,7462,5,6,0,0,7462,7464,3, + 740,370,0,7463,7461,1,0,0,0,7464,7467,1,0,0,0,7465,7463,1,0,0,0, + 7465,7466,1,0,0,0,7466,7469,1,0,0,0,7467,7465,1,0,0,0,7468,7459, + 1,0,0,0,7468,7460,1,0,0,0,7468,7469,1,0,0,0,7469,7470,1,0,0,0,7470, + 7471,5,5,0,0,7471,741,1,0,0,0,7472,7481,3,826,413,0,7473,7481,5, + 384,0,0,7474,7481,5,264,0,0,7475,7481,5,176,0,0,7476,7481,5,218, + 0,0,7477,7481,5,261,0,0,7478,7481,5,326,0,0,7479,7481,3,808,404, + 0,7480,7472,1,0,0,0,7480,7473,1,0,0,0,7480,7474,1,0,0,0,7480,7475, + 1,0,0,0,7480,7476,1,0,0,0,7480,7477,1,0,0,0,7480,7478,1,0,0,0,7480, + 7479,1,0,0,0,7481,743,1,0,0,0,7482,7483,7,108,0,0,7483,745,1,0,0, + 0,7484,7485,3,674,337,0,7485,7486,5,64,0,0,7486,7489,3,674,337,0, + 7487,7488,5,62,0,0,7488,7490,3,674,337,0,7489,7487,1,0,0,0,7489, + 7490,1,0,0,0,7490,7506,1,0,0,0,7491,7492,3,674,337,0,7492,7493,5, + 62,0,0,7493,7496,3,674,337,0,7494,7495,5,64,0,0,7495,7497,3,674, + 337,0,7496,7494,1,0,0,0,7496,7497,1,0,0,0,7497,7506,1,0,0,0,7498, + 7499,3,674,337,0,7499,7500,5,127,0,0,7500,7501,3,674,337,0,7501, + 7502,5,197,0,0,7502,7503,3,674,337,0,7503,7506,1,0,0,0,7504,7506, + 3,730,365,0,7505,7484,1,0,0,0,7505,7491,1,0,0,0,7505,7498,1,0,0, + 0,7505,7504,1,0,0,0,7506,747,1,0,0,0,7507,7508,5,102,0,0,7508,7509, + 3,674,337,0,7509,7510,5,93,0,0,7510,7511,3,674,337,0,7511,749,1, + 0,0,0,7512,7515,5,11,0,0,7513,7516,3,824,412,0,7514,7516,5,9,0,0, + 7515,7513,1,0,0,0,7515,7514,1,0,0,0,7516,7530,1,0,0,0,7517,7526, + 5,4,0,0,7518,7527,3,674,337,0,7519,7521,3,674,337,0,7520,7519,1, + 0,0,0,7520,7521,1,0,0,0,7521,7522,1,0,0,0,7522,7524,5,8,0,0,7523, + 7525,3,674,337,0,7524,7523,1,0,0,0,7524,7525,1,0,0,0,7525,7527,1, + 0,0,0,7526,7518,1,0,0,0,7526,7520,1,0,0,0,7527,7528,1,0,0,0,7528, + 7530,5,5,0,0,7529,7512,1,0,0,0,7529,7517,1,0,0,0,7530,751,1,0,0, + 0,7531,7533,3,750,375,0,7532,7531,1,0,0,0,7533,7534,1,0,0,0,7534, + 7532,1,0,0,0,7534,7535,1,0,0,0,7535,753,1,0,0,0,7536,7538,3,750, + 375,0,7537,7536,1,0,0,0,7538,7541,1,0,0,0,7539,7537,1,0,0,0,7539, + 7540,1,0,0,0,7540,755,1,0,0,0,7541,7539,1,0,0,0,7542,7547,3,758, + 379,0,7543,7544,5,6,0,0,7544,7546,3,758,379,0,7545,7543,1,0,0,0, + 7546,7549,1,0,0,0,7547,7545,1,0,0,0,7547,7548,1,0,0,0,7548,757,1, + 0,0,0,7549,7547,1,0,0,0,7550,7555,3,734,367,0,7551,7552,5,36,0,0, + 7552,7556,3,824,412,0,7553,7556,3,826,413,0,7554,7556,1,0,0,0,7555, + 7551,1,0,0,0,7555,7553,1,0,0,0,7555,7554,1,0,0,0,7556,7559,1,0,0, + 0,7557,7559,5,9,0,0,7558,7550,1,0,0,0,7558,7557,1,0,0,0,7559,759, + 1,0,0,0,7560,7565,3,780,390,0,7561,7562,5,6,0,0,7562,7564,3,780, + 390,0,7563,7561,1,0,0,0,7564,7567,1,0,0,0,7565,7563,1,0,0,0,7565, + 7566,1,0,0,0,7566,761,1,0,0,0,7567,7565,1,0,0,0,7568,7573,3,774, + 387,0,7569,7570,5,6,0,0,7570,7572,3,774,387,0,7571,7569,1,0,0,0, + 7572,7575,1,0,0,0,7573,7571,1,0,0,0,7573,7574,1,0,0,0,7574,763,1, + 0,0,0,7575,7573,1,0,0,0,7576,7581,3,790,395,0,7577,7578,5,6,0,0, + 7578,7580,3,790,395,0,7579,7577,1,0,0,0,7580,7583,1,0,0,0,7581,7579, + 1,0,0,0,7581,7582,1,0,0,0,7582,765,1,0,0,0,7583,7581,1,0,0,0,7584, + 7589,3,788,394,0,7585,7586,5,6,0,0,7586,7588,3,788,394,0,7587,7585, + 1,0,0,0,7588,7591,1,0,0,0,7589,7587,1,0,0,0,7589,7590,1,0,0,0,7590, + 767,1,0,0,0,7591,7589,1,0,0,0,7592,7593,3,780,390,0,7593,769,1,0, + 0,0,7594,7595,3,780,390,0,7595,771,1,0,0,0,7596,7597,3,780,390,0, + 7597,773,1,0,0,0,7598,7599,3,780,390,0,7599,775,1,0,0,0,7600,7601, + 3,780,390,0,7601,777,1,0,0,0,7602,7603,3,316,158,0,7603,779,1,0, + 0,0,7604,7606,3,818,409,0,7605,7607,3,752,376,0,7606,7605,1,0,0, + 0,7606,7607,1,0,0,0,7607,781,1,0,0,0,7608,7613,3,770,385,0,7609, + 7610,5,6,0,0,7610,7612,3,770,385,0,7611,7609,1,0,0,0,7612,7615,1, + 0,0,0,7613,7611,1,0,0,0,7613,7614,1,0,0,0,7614,783,1,0,0,0,7615, + 7613,1,0,0,0,7616,7621,3,818,409,0,7617,7618,5,6,0,0,7618,7620,3, + 818,409,0,7619,7617,1,0,0,0,7620,7623,1,0,0,0,7621,7619,1,0,0,0, + 7621,7622,1,0,0,0,7622,785,1,0,0,0,7623,7621,1,0,0,0,7624,7625,3, + 316,158,0,7625,787,1,0,0,0,7626,7627,3,316,158,0,7627,789,1,0,0, + 0,7628,7629,3,316,158,0,7629,791,1,0,0,0,7630,7631,3,818,409,0,7631, + 793,1,0,0,0,7632,7633,3,818,409,0,7633,795,1,0,0,0,7634,7639,3,820, + 410,0,7635,7636,3,818,409,0,7636,7637,3,752,376,0,7637,7639,1,0, + 0,0,7638,7634,1,0,0,0,7638,7635,1,0,0,0,7639,797,1,0,0,0,7640,7645, + 3,820,410,0,7641,7642,3,818,409,0,7642,7643,3,752,376,0,7643,7645, + 1,0,0,0,7644,7640,1,0,0,0,7644,7641,1,0,0,0,7645,799,1,0,0,0,7646, + 7647,3,818,409,0,7647,7648,3,754,377,0,7648,7651,1,0,0,0,7649,7651, + 4,400,10,0,7650,7646,1,0,0,0,7650,7649,1,0,0,0,7651,801,1,0,0,0, + 7652,7653,3,818,409,0,7653,803,1,0,0,0,7654,7659,3,820,410,0,7655, + 7656,3,818,409,0,7656,7657,3,752,376,0,7657,7659,1,0,0,0,7658,7654, + 1,0,0,0,7658,7655,1,0,0,0,7659,805,1,0,0,0,7660,7665,3,820,410,0, + 7661,7662,3,818,409,0,7662,7663,3,752,376,0,7663,7665,1,0,0,0,7664, + 7660,1,0,0,0,7664,7661,1,0,0,0,7665,807,1,0,0,0,7666,7669,3,810, + 405,0,7667,7668,5,487,0,0,7668,7670,3,810,405,0,7669,7667,1,0,0, + 0,7669,7670,1,0,0,0,7670,809,1,0,0,0,7671,7683,5,558,0,0,7672,7683, + 5,560,0,0,7673,7677,5,562,0,0,7674,7676,5,588,0,0,7675,7674,1,0, + 0,0,7676,7679,1,0,0,0,7677,7675,1,0,0,0,7677,7678,1,0,0,0,7678,7680, + 1,0,0,0,7679,7677,1,0,0,0,7680,7683,5,589,0,0,7681,7683,5,584,0, + 0,7682,7671,1,0,0,0,7682,7672,1,0,0,0,7682,7673,1,0,0,0,7682,7681, + 1,0,0,0,7683,811,1,0,0,0,7684,7686,7,29,0,0,7685,7684,1,0,0,0,7685, + 7686,1,0,0,0,7686,7687,1,0,0,0,7687,7688,5,571,0,0,7688,813,1,0, + 0,0,7689,7695,3,822,411,0,7690,7695,5,52,0,0,7691,7695,5,49,0,0, + 7692,7695,5,89,0,0,7693,7695,5,524,0,0,7694,7689,1,0,0,0,7694,7690, + 1,0,0,0,7694,7691,1,0,0,0,7694,7692,1,0,0,0,7694,7693,1,0,0,0,7695, + 815,1,0,0,0,7696,7701,3,814,407,0,7697,7698,5,6,0,0,7698,7700,3, + 814,407,0,7699,7697,1,0,0,0,7700,7703,1,0,0,0,7701,7699,1,0,0,0, + 7701,7702,1,0,0,0,7702,817,1,0,0,0,7703,7701,1,0,0,0,7704,7709,3, + 826,413,0,7705,7709,3,828,414,0,7706,7709,3,830,415,0,7707,7709, + 3,930,465,0,7708,7704,1,0,0,0,7708,7705,1,0,0,0,7708,7706,1,0,0, + 0,7708,7707,1,0,0,0,7709,819,1,0,0,0,7710,7715,3,826,413,0,7711, + 7715,3,828,414,0,7712,7715,3,930,465,0,7713,7715,3,832,416,0,7714, + 7710,1,0,0,0,7714,7711,1,0,0,0,7714,7712,1,0,0,0,7714,7713,1,0,0, + 0,7715,821,1,0,0,0,7716,7721,3,826,413,0,7717,7721,3,828,414,0,7718, + 7721,3,830,415,0,7719,7721,3,832,416,0,7720,7716,1,0,0,0,7720,7717, + 1,0,0,0,7720,7718,1,0,0,0,7720,7719,1,0,0,0,7721,823,1,0,0,0,7722, + 7726,3,822,411,0,7723,7726,3,930,465,0,7724,7726,3,834,417,0,7725, + 7722,1,0,0,0,7725,7723,1,0,0,0,7725,7724,1,0,0,0,7726,825,1,0,0, + 0,7727,7730,5,549,0,0,7728,7729,5,487,0,0,7729,7731,3,810,405,0, + 7730,7728,1,0,0,0,7730,7731,1,0,0,0,7731,7739,1,0,0,0,7732,7739, + 3,808,404,0,7733,7739,5,550,0,0,7734,7739,5,554,0,0,7735,7739,5, + 574,0,0,7736,7739,5,575,0,0,7737,7739,3,930,465,0,7738,7727,1,0, + 0,0,7738,7732,1,0,0,0,7738,7733,1,0,0,0,7738,7734,1,0,0,0,7738,7735, + 1,0,0,0,7738,7736,1,0,0,0,7738,7737,1,0,0,0,7739,827,1,0,0,0,7740, + 7741,7,109,0,0,7741,829,1,0,0,0,7742,7794,5,387,0,0,7743,7794,5, + 388,0,0,7744,7794,3,662,331,0,7745,7794,5,390,0,0,7746,7794,5,391, + 0,0,7747,7794,3,664,332,0,7748,7794,5,393,0,0,7749,7794,5,394,0, + 0,7750,7794,5,395,0,0,7751,7794,5,396,0,0,7752,7794,5,397,0,0,7753, + 7794,5,398,0,0,7754,7794,5,399,0,0,7755,7794,5,470,0,0,7756,7794, + 5,400,0,0,7757,7794,5,401,0,0,7758,7794,5,402,0,0,7759,7794,5,403, + 0,0,7760,7794,5,404,0,0,7761,7794,5,405,0,0,7762,7794,5,406,0,0, + 7763,7794,5,407,0,0,7764,7794,5,489,0,0,7765,7794,5,408,0,0,7766, + 7794,3,658,329,0,7767,7794,5,453,0,0,7768,7794,5,410,0,0,7769,7794, + 5,411,0,0,7770,7794,5,412,0,0,7771,7794,5,413,0,0,7772,7794,5,414, + 0,0,7773,7794,5,415,0,0,7774,7794,5,416,0,0,7775,7794,5,417,0,0, + 7776,7794,5,418,0,0,7777,7794,5,419,0,0,7778,7794,5,420,0,0,7779, + 7794,5,421,0,0,7780,7794,5,422,0,0,7781,7794,5,423,0,0,7782,7794, + 5,424,0,0,7783,7794,5,425,0,0,7784,7794,5,426,0,0,7785,7794,5,427, + 0,0,7786,7794,5,428,0,0,7787,7794,5,476,0,0,7788,7794,5,429,0,0, + 7789,7794,5,430,0,0,7790,7794,5,431,0,0,7791,7794,5,432,0,0,7792, + 7794,5,474,0,0,7793,7742,1,0,0,0,7793,7743,1,0,0,0,7793,7744,1,0, + 0,0,7793,7745,1,0,0,0,7793,7746,1,0,0,0,7793,7747,1,0,0,0,7793,7748, + 1,0,0,0,7793,7749,1,0,0,0,7793,7750,1,0,0,0,7793,7751,1,0,0,0,7793, + 7752,1,0,0,0,7793,7753,1,0,0,0,7793,7754,1,0,0,0,7793,7755,1,0,0, + 0,7793,7756,1,0,0,0,7793,7757,1,0,0,0,7793,7758,1,0,0,0,7793,7759, + 1,0,0,0,7793,7760,1,0,0,0,7793,7761,1,0,0,0,7793,7762,1,0,0,0,7793, + 7763,1,0,0,0,7793,7764,1,0,0,0,7793,7765,1,0,0,0,7793,7766,1,0,0, + 0,7793,7767,1,0,0,0,7793,7768,1,0,0,0,7793,7769,1,0,0,0,7793,7770, + 1,0,0,0,7793,7771,1,0,0,0,7793,7772,1,0,0,0,7793,7773,1,0,0,0,7793, + 7774,1,0,0,0,7793,7775,1,0,0,0,7793,7776,1,0,0,0,7793,7777,1,0,0, + 0,7793,7778,1,0,0,0,7793,7779,1,0,0,0,7793,7780,1,0,0,0,7793,7781, + 1,0,0,0,7793,7782,1,0,0,0,7793,7783,1,0,0,0,7793,7784,1,0,0,0,7793, + 7785,1,0,0,0,7793,7786,1,0,0,0,7793,7787,1,0,0,0,7793,7788,1,0,0, + 0,7793,7789,1,0,0,0,7793,7790,1,0,0,0,7793,7791,1,0,0,0,7793,7792, + 1,0,0,0,7794,831,1,0,0,0,7795,7796,7,110,0,0,7796,833,1,0,0,0,7797, + 7798,7,111,0,0,7798,835,1,0,0,0,7799,7801,3,838,419,0,7800,7799, + 1,0,0,0,7800,7801,1,0,0,0,7801,7812,1,0,0,0,7802,7810,5,178,0,0, + 7803,7807,3,840,420,0,7804,7807,5,178,0,0,7805,7807,3,838,419,0, + 7806,7803,1,0,0,0,7806,7804,1,0,0,0,7806,7805,1,0,0,0,7807,7808, + 1,0,0,0,7808,7806,1,0,0,0,7808,7809,1,0,0,0,7809,7811,1,0,0,0,7810, + 7806,1,0,0,0,7810,7811,1,0,0,0,7811,7813,1,0,0,0,7812,7802,1,0,0, + 0,7812,7813,1,0,0,0,7813,7814,1,0,0,0,7814,7818,5,146,0,0,7815,7817, + 3,846,423,0,7816,7815,1,0,0,0,7817,7820,1,0,0,0,7818,7816,1,0,0, + 0,7818,7819,1,0,0,0,7819,7822,1,0,0,0,7820,7818,1,0,0,0,7821,7823, + 3,924,462,0,7822,7821,1,0,0,0,7822,7823,1,0,0,0,7823,7824,1,0,0, + 0,7824,7826,5,454,0,0,7825,7827,3,928,464,0,7826,7825,1,0,0,0,7826, + 7827,1,0,0,0,7827,837,1,0,0,0,7828,7829,5,18,0,0,7829,7830,3,928, + 464,0,7830,7831,5,19,0,0,7831,839,1,0,0,0,7832,7879,3,928,464,0, + 7833,7834,5,496,0,0,7834,7837,5,62,0,0,7835,7838,5,28,0,0,7836,7838, + 3,818,409,0,7837,7835,1,0,0,0,7837,7836,1,0,0,0,7838,7880,1,0,0, + 0,7839,7841,5,497,0,0,7840,7839,1,0,0,0,7840,7841,1,0,0,0,7841,7842, + 1,0,0,0,7842,7844,3,652,326,0,7843,7845,3,98,49,0,7844,7843,1,0, + 0,0,7844,7845,1,0,0,0,7845,7848,1,0,0,0,7846,7847,5,77,0,0,7847, + 7849,5,78,0,0,7848,7846,1,0,0,0,7848,7849,1,0,0,0,7849,7855,1,0, + 0,0,7850,7853,3,844,422,0,7851,7853,5,53,0,0,7852,7850,1,0,0,0,7852, + 7851,1,0,0,0,7853,7854,1,0,0,0,7854,7856,3,932,466,0,7855,7852,1, + 0,0,0,7855,7856,1,0,0,0,7856,7880,1,0,0,0,7857,7859,5,269,0,0,7858, + 7857,1,0,0,0,7858,7859,1,0,0,0,7859,7860,1,0,0,0,7860,7862,5,324, + 0,0,7861,7858,1,0,0,0,7861,7862,1,0,0,0,7862,7863,1,0,0,0,7863,7875, + 5,172,0,0,7864,7865,5,2,0,0,7865,7870,3,842,421,0,7866,7867,5,6, + 0,0,7867,7869,3,842,421,0,7868,7866,1,0,0,0,7869,7872,1,0,0,0,7870, + 7868,1,0,0,0,7870,7871,1,0,0,0,7871,7873,1,0,0,0,7872,7870,1,0,0, + 0,7873,7874,5,3,0,0,7874,7876,1,0,0,0,7875,7864,1,0,0,0,7875,7876, + 1,0,0,0,7876,7877,1,0,0,0,7877,7878,7,112,0,0,7878,7880,3,560,280, + 0,7879,7833,1,0,0,0,7879,7840,1,0,0,0,7879,7861,1,0,0,0,7880,7881, + 1,0,0,0,7881,7882,5,7,0,0,7882,841,1,0,0,0,7883,7884,3,928,464,0, + 7884,7885,3,652,326,0,7885,843,1,0,0,0,7886,7887,7,113,0,0,7887, + 845,1,0,0,0,7888,7889,3,836,418,0,7889,7890,5,7,0,0,7890,7913,1, + 0,0,0,7891,7913,3,874,437,0,7892,7913,3,876,438,0,7893,7913,3,852, + 426,0,7894,7913,3,860,430,0,7895,7913,3,864,432,0,7896,7913,3,866, + 433,0,7897,7913,3,870,435,0,7898,7913,3,872,436,0,7899,7913,3,880, + 440,0,7900,7913,3,884,442,0,7901,7913,3,886,443,0,7902,7913,3,848, + 424,0,7903,7913,3,850,425,0,7904,7913,3,854,427,0,7905,7913,3,890, + 445,0,7906,7913,3,894,447,0,7907,7913,3,898,449,0,7908,7913,3,914, + 457,0,7909,7913,3,916,458,0,7910,7913,3,918,459,0,7911,7913,3,920, + 460,0,7912,7888,1,0,0,0,7912,7891,1,0,0,0,7912,7892,1,0,0,0,7912, + 7893,1,0,0,0,7912,7894,1,0,0,0,7912,7895,1,0,0,0,7912,7896,1,0,0, + 0,7912,7897,1,0,0,0,7912,7898,1,0,0,0,7912,7899,1,0,0,0,7912,7900, + 1,0,0,0,7912,7901,1,0,0,0,7912,7902,1,0,0,0,7912,7903,1,0,0,0,7912, + 7904,1,0,0,0,7912,7905,1,0,0,0,7912,7906,1,0,0,0,7912,7907,1,0,0, + 0,7912,7908,1,0,0,0,7912,7909,1,0,0,0,7912,7910,1,0,0,0,7912,7911, + 1,0,0,0,7913,847,1,0,0,0,7914,7915,5,498,0,0,7915,7916,3,932,466, + 0,7916,7917,5,7,0,0,7917,849,1,0,0,0,7918,7919,5,433,0,0,7919,7926, + 3,928,464,0,7920,7922,5,2,0,0,7921,7923,3,730,365,0,7922,7921,1, + 0,0,0,7922,7923,1,0,0,0,7923,7924,1,0,0,0,7924,7925,5,3,0,0,7925, + 7927,5,7,0,0,7926,7920,1,0,0,0,7926,7927,1,0,0,0,7927,7938,1,0,0, + 0,7928,7929,5,57,0,0,7929,7930,3,928,464,0,7930,7932,5,2,0,0,7931, + 7933,3,730,365,0,7932,7931,1,0,0,0,7932,7933,1,0,0,0,7933,7934,1, + 0,0,0,7934,7935,5,3,0,0,7935,7936,5,7,0,0,7936,7938,1,0,0,0,7937, + 7918,1,0,0,0,7937,7928,1,0,0,0,7938,851,1,0,0,0,7939,7940,3,858, + 429,0,7940,7941,3,844,422,0,7941,7942,3,932,466,0,7942,7943,5,7, + 0,0,7943,853,1,0,0,0,7944,7946,5,499,0,0,7945,7947,7,114,0,0,7946, + 7945,1,0,0,0,7946,7947,1,0,0,0,7947,7948,1,0,0,0,7948,7949,5,500, + 0,0,7949,7954,3,856,428,0,7950,7951,5,6,0,0,7951,7953,3,856,428, + 0,7952,7950,1,0,0,0,7953,7956,1,0,0,0,7954,7952,1,0,0,0,7954,7955, + 1,0,0,0,7955,7957,1,0,0,0,7956,7954,1,0,0,0,7957,7958,5,7,0,0,7958, + 855,1,0,0,0,7959,7960,3,858,429,0,7960,7961,3,844,422,0,7961,7962, + 3,818,409,0,7962,857,1,0,0,0,7963,7966,3,316,158,0,7964,7966,5,28, + 0,0,7965,7963,1,0,0,0,7965,7964,1,0,0,0,7966,7973,1,0,0,0,7967,7968, + 5,4,0,0,7968,7969,3,674,337,0,7969,7970,5,5,0,0,7970,7972,1,0,0, + 0,7971,7967,1,0,0,0,7972,7975,1,0,0,0,7973,7971,1,0,0,0,7973,7974, + 1,0,0,0,7974,859,1,0,0,0,7975,7973,1,0,0,0,7976,7977,5,220,0,0,7977, + 7978,3,932,466,0,7978,7982,5,93,0,0,7979,7981,3,846,423,0,7980,7979, + 1,0,0,0,7981,7984,1,0,0,0,7982,7980,1,0,0,0,7982,7983,1,0,0,0,7983, + 7996,1,0,0,0,7984,7982,1,0,0,0,7985,7986,5,502,0,0,7986,7987,3,674, + 337,0,7987,7991,5,93,0,0,7988,7990,3,846,423,0,7989,7988,1,0,0,0, + 7990,7993,1,0,0,0,7991,7989,1,0,0,0,7991,7992,1,0,0,0,7992,7995, + 1,0,0,0,7993,7991,1,0,0,0,7994,7985,1,0,0,0,7995,7998,1,0,0,0,7996, + 7994,1,0,0,0,7996,7997,1,0,0,0,7997,8000,1,0,0,0,7998,7996,1,0,0, + 0,7999,8001,3,862,431,0,8000,7999,1,0,0,0,8000,8001,1,0,0,0,8001, + 8002,1,0,0,0,8002,8003,5,454,0,0,8003,8004,5,220,0,0,8004,8005,5, + 7,0,0,8005,861,1,0,0,0,8006,8010,5,58,0,0,8007,8009,3,846,423,0, + 8008,8007,1,0,0,0,8009,8012,1,0,0,0,8010,8008,1,0,0,0,8010,8011, + 1,0,0,0,8011,863,1,0,0,0,8012,8010,1,0,0,0,8013,8015,5,40,0,0,8014, + 8016,3,932,466,0,8015,8014,1,0,0,0,8015,8016,1,0,0,0,8016,8026,1, + 0,0,0,8017,8018,5,102,0,0,8018,8019,3,730,365,0,8019,8023,5,93,0, + 0,8020,8022,3,846,423,0,8021,8020,1,0,0,0,8022,8025,1,0,0,0,8023, + 8021,1,0,0,0,8023,8024,1,0,0,0,8024,8027,1,0,0,0,8025,8023,1,0,0, + 0,8026,8017,1,0,0,0,8027,8028,1,0,0,0,8028,8026,1,0,0,0,8028,8029, + 1,0,0,0,8029,8031,1,0,0,0,8030,8032,3,862,431,0,8031,8030,1,0,0, + 0,8031,8032,1,0,0,0,8032,8033,1,0,0,0,8033,8034,5,454,0,0,8034,8035, + 5,40,0,0,8035,8036,5,7,0,0,8036,865,1,0,0,0,8037,8039,3,838,419, + 0,8038,8037,1,0,0,0,8038,8039,1,0,0,0,8039,8044,1,0,0,0,8040,8041, + 5,503,0,0,8041,8045,3,674,337,0,8042,8043,5,62,0,0,8043,8045,3,868, + 434,0,8044,8040,1,0,0,0,8044,8042,1,0,0,0,8044,8045,1,0,0,0,8045, + 8046,1,0,0,0,8046,8047,3,882,441,0,8047,867,1,0,0,0,8048,8049,3, + 314,157,0,8049,8072,5,68,0,0,8050,8052,3,818,409,0,8051,8053,3,534, + 267,0,8052,8051,1,0,0,0,8052,8053,1,0,0,0,8053,8073,1,0,0,0,8054, + 8073,3,560,280,0,8055,8073,3,520,260,0,8056,8057,5,202,0,0,8057, + 8060,3,674,337,0,8058,8059,5,100,0,0,8059,8061,3,730,365,0,8060, + 8058,1,0,0,0,8060,8061,1,0,0,0,8061,8073,1,0,0,0,8062,8064,5,504, + 0,0,8063,8062,1,0,0,0,8063,8064,1,0,0,0,8064,8065,1,0,0,0,8065,8066, + 3,674,337,0,8066,8067,5,24,0,0,8067,8070,3,674,337,0,8068,8069,5, + 147,0,0,8069,8071,3,674,337,0,8070,8068,1,0,0,0,8070,8071,1,0,0, + 0,8071,8073,1,0,0,0,8072,8050,1,0,0,0,8072,8054,1,0,0,0,8072,8055, + 1,0,0,0,8072,8056,1,0,0,0,8072,8063,1,0,0,0,8073,869,1,0,0,0,8074, + 8076,3,838,419,0,8075,8074,1,0,0,0,8075,8076,1,0,0,0,8076,8077,1, + 0,0,0,8077,8078,5,505,0,0,8078,8081,3,314,157,0,8079,8080,5,506, + 0,0,8080,8082,5,571,0,0,8081,8079,1,0,0,0,8081,8082,1,0,0,0,8082, + 8083,1,0,0,0,8083,8084,5,68,0,0,8084,8085,5,35,0,0,8085,8086,3,674, + 337,0,8086,8087,3,882,441,0,8087,871,1,0,0,0,8088,8090,7,115,0,0, + 8089,8091,3,928,464,0,8090,8089,1,0,0,0,8090,8091,1,0,0,0,8091,8094, + 1,0,0,0,8092,8093,5,102,0,0,8093,8095,3,932,466,0,8094,8092,1,0, + 0,0,8094,8095,1,0,0,0,8095,8096,1,0,0,0,8096,8097,5,7,0,0,8097,873, + 1,0,0,0,8098,8113,5,508,0,0,8099,8100,5,268,0,0,8100,8114,3,932, + 466,0,8101,8108,5,509,0,0,8102,8103,5,202,0,0,8103,8104,3,674,337, + 0,8104,8105,5,100,0,0,8105,8106,3,730,365,0,8106,8109,1,0,0,0,8107, + 8109,3,560,280,0,8108,8102,1,0,0,0,8108,8107,1,0,0,0,8109,8114,1, + 0,0,0,8110,8112,3,932,466,0,8111,8110,1,0,0,0,8111,8112,1,0,0,0, + 8112,8114,1,0,0,0,8113,8099,1,0,0,0,8113,8101,1,0,0,0,8113,8111, + 1,0,0,0,8114,8115,1,0,0,0,8115,8116,5,7,0,0,8116,875,1,0,0,0,8117, + 8147,5,510,0,0,8118,8120,7,116,0,0,8119,8118,1,0,0,0,8119,8120,1, + 0,0,0,8120,8133,1,0,0,0,8121,8134,3,826,413,0,8122,8123,5,511,0, + 0,8123,8134,3,808,404,0,8124,8131,3,808,404,0,8125,8126,5,6,0,0, + 8126,8128,3,674,337,0,8127,8125,1,0,0,0,8128,8129,1,0,0,0,8129,8127, + 1,0,0,0,8129,8130,1,0,0,0,8130,8132,1,0,0,0,8131,8127,1,0,0,0,8131, + 8132,1,0,0,0,8132,8134,1,0,0,0,8133,8121,1,0,0,0,8133,8122,1,0,0, + 0,8133,8124,1,0,0,0,8133,8134,1,0,0,0,8134,8144,1,0,0,0,8135,8136, + 5,100,0,0,8136,8141,3,878,439,0,8137,8138,5,6,0,0,8138,8140,3,878, + 439,0,8139,8137,1,0,0,0,8140,8143,1,0,0,0,8141,8139,1,0,0,0,8141, + 8142,1,0,0,0,8142,8145,1,0,0,0,8143,8141,1,0,0,0,8144,8135,1,0,0, + 0,8144,8145,1,0,0,0,8145,8146,1,0,0,0,8146,8148,5,7,0,0,8147,8119, + 1,0,0,0,8147,8148,1,0,0,0,8148,877,1,0,0,0,8149,8150,3,826,413,0, + 8150,8151,5,10,0,0,8151,8152,3,674,337,0,8152,879,1,0,0,0,8153,8154, + 5,518,0,0,8154,8157,3,932,466,0,8155,8156,5,6,0,0,8156,8158,3,932, + 466,0,8157,8155,1,0,0,0,8157,8158,1,0,0,0,8158,8159,1,0,0,0,8159, + 8160,5,7,0,0,8160,881,1,0,0,0,8161,8165,5,519,0,0,8162,8164,3,846, + 423,0,8163,8162,1,0,0,0,8164,8167,1,0,0,0,8165,8163,1,0,0,0,8165, + 8166,1,0,0,0,8166,8168,1,0,0,0,8167,8165,1,0,0,0,8168,8169,5,454, + 0,0,8169,8171,5,519,0,0,8170,8172,3,928,464,0,8171,8170,1,0,0,0, + 8171,8172,1,0,0,0,8172,8173,1,0,0,0,8173,8174,5,7,0,0,8174,883,1, + 0,0,0,8175,8177,3,4,2,0,8176,8178,3,888,444,0,8177,8176,1,0,0,0, + 8177,8178,1,0,0,0,8178,8179,1,0,0,0,8179,8180,5,7,0,0,8180,885,1, + 0,0,0,8181,8182,5,202,0,0,8182,8198,3,674,337,0,8183,8185,3,888, + 444,0,8184,8183,1,0,0,0,8184,8185,1,0,0,0,8185,8188,1,0,0,0,8186, + 8187,5,100,0,0,8187,8189,3,730,365,0,8188,8186,1,0,0,0,8188,8189, + 1,0,0,0,8189,8199,1,0,0,0,8190,8191,5,100,0,0,8191,8193,3,730,365, + 0,8192,8190,1,0,0,0,8192,8193,1,0,0,0,8193,8195,1,0,0,0,8194,8196, + 3,888,444,0,8195,8194,1,0,0,0,8195,8196,1,0,0,0,8196,8199,1,0,0, + 0,8197,8199,1,0,0,0,8198,8184,1,0,0,0,8198,8192,1,0,0,0,8198,8197, + 1,0,0,0,8199,8200,1,0,0,0,8200,8201,5,7,0,0,8201,887,1,0,0,0,8202, + 8204,5,71,0,0,8203,8205,5,346,0,0,8204,8203,1,0,0,0,8204,8205,1, + 0,0,0,8205,8206,1,0,0,0,8206,8207,3,730,365,0,8207,889,1,0,0,0,8208, + 8240,5,520,0,0,8209,8214,3,922,461,0,8210,8212,5,269,0,0,8211,8210, + 1,0,0,0,8211,8212,1,0,0,0,8212,8213,1,0,0,0,8213,8215,5,324,0,0, + 8214,8211,1,0,0,0,8214,8215,1,0,0,0,8215,8216,1,0,0,0,8216,8224, + 5,62,0,0,8217,8225,3,560,280,0,8218,8219,5,202,0,0,8219,8222,3,932, + 466,0,8220,8221,5,100,0,0,8221,8223,3,730,365,0,8222,8220,1,0,0, + 0,8222,8223,1,0,0,0,8223,8225,1,0,0,0,8224,8217,1,0,0,0,8224,8218, + 1,0,0,0,8225,8241,1,0,0,0,8226,8238,3,818,409,0,8227,8228,5,2,0, + 0,8228,8233,3,892,446,0,8229,8230,5,6,0,0,8230,8232,3,892,446,0, + 8231,8229,1,0,0,0,8232,8235,1,0,0,0,8233,8231,1,0,0,0,8233,8234, + 1,0,0,0,8234,8236,1,0,0,0,8235,8233,1,0,0,0,8236,8237,5,3,0,0,8237, + 8239,1,0,0,0,8238,8227,1,0,0,0,8238,8239,1,0,0,0,8239,8241,1,0,0, + 0,8240,8209,1,0,0,0,8240,8226,1,0,0,0,8241,8242,1,0,0,0,8242,8243, + 5,7,0,0,8243,891,1,0,0,0,8244,8245,3,818,409,0,8245,8246,5,20,0, + 0,8246,8248,1,0,0,0,8247,8244,1,0,0,0,8247,8248,1,0,0,0,8248,8249, + 1,0,0,0,8249,8250,3,674,337,0,8250,893,1,0,0,0,8251,8253,5,61,0, + 0,8252,8254,3,896,448,0,8253,8252,1,0,0,0,8253,8254,1,0,0,0,8254, + 8256,1,0,0,0,8255,8257,3,332,166,0,8256,8255,1,0,0,0,8256,8257,1, + 0,0,0,8257,8258,1,0,0,0,8258,8259,3,922,461,0,8259,8260,5,71,0,0, + 8260,8261,3,730,365,0,8261,8262,5,7,0,0,8262,895,1,0,0,0,8263,8278, + 5,268,0,0,8264,8278,5,293,0,0,8265,8278,5,207,0,0,8266,8278,5,249, + 0,0,8267,8269,7,50,0,0,8268,8267,1,0,0,0,8268,8269,1,0,0,0,8269, + 8270,1,0,0,0,8270,8278,3,674,337,0,8271,8278,5,30,0,0,8272,8275, + 7,117,0,0,8273,8276,3,674,337,0,8274,8276,5,30,0,0,8275,8273,1,0, + 0,0,8275,8274,1,0,0,0,8275,8276,1,0,0,0,8276,8278,1,0,0,0,8277,8263, + 1,0,0,0,8277,8264,1,0,0,0,8277,8265,1,0,0,0,8277,8266,1,0,0,0,8277, + 8268,1,0,0,0,8277,8271,1,0,0,0,8277,8272,1,0,0,0,8278,897,1,0,0, + 0,8279,8281,5,265,0,0,8280,8282,3,896,448,0,8281,8280,1,0,0,0,8281, + 8282,1,0,0,0,8282,8283,1,0,0,0,8283,8284,3,922,461,0,8284,8285,5, + 7,0,0,8285,899,1,0,0,0,8286,8288,3,572,286,0,8287,8286,1,0,0,0,8287, + 8288,1,0,0,0,8288,8289,1,0,0,0,8289,8290,5,525,0,0,8290,8292,5,71, + 0,0,8291,8293,5,81,0,0,8292,8291,1,0,0,0,8292,8293,1,0,0,0,8293, + 8294,1,0,0,0,8294,8296,3,774,387,0,8295,8297,5,9,0,0,8296,8295,1, + 0,0,0,8296,8297,1,0,0,0,8297,8302,1,0,0,0,8298,8300,5,36,0,0,8299, + 8298,1,0,0,0,8299,8300,1,0,0,0,8300,8301,1,0,0,0,8301,8303,3,818, + 409,0,8302,8299,1,0,0,0,8302,8303,1,0,0,0,8303,8304,1,0,0,0,8304, + 8305,5,100,0,0,8305,8306,3,902,451,0,8306,8307,5,80,0,0,8307,8309, + 3,674,337,0,8308,8310,3,904,452,0,8309,8308,1,0,0,0,8310,8311,1, + 0,0,0,8311,8309,1,0,0,0,8311,8312,1,0,0,0,8312,901,1,0,0,0,8313, + 8315,5,81,0,0,8314,8313,1,0,0,0,8314,8315,1,0,0,0,8315,8316,1,0, + 0,0,8316,8318,3,774,387,0,8317,8319,5,9,0,0,8318,8317,1,0,0,0,8318, + 8319,1,0,0,0,8319,8325,1,0,0,0,8320,8323,3,564,282,0,8321,8323,3, + 608,304,0,8322,8320,1,0,0,0,8322,8321,1,0,0,0,8323,8325,1,0,0,0, + 8324,8314,1,0,0,0,8324,8322,1,0,0,0,8325,8330,1,0,0,0,8326,8328, + 5,36,0,0,8327,8326,1,0,0,0,8327,8328,1,0,0,0,8328,8329,1,0,0,0,8329, + 8331,3,818,409,0,8330,8327,1,0,0,0,8330,8331,1,0,0,0,8331,903,1, + 0,0,0,8332,8333,5,102,0,0,8333,8336,5,526,0,0,8334,8335,5,33,0,0, + 8335,8337,3,674,337,0,8336,8334,1,0,0,0,8336,8337,1,0,0,0,8337,8338, + 1,0,0,0,8338,8343,5,93,0,0,8339,8344,3,908,454,0,8340,8344,5,182, + 0,0,8341,8342,5,57,0,0,8342,8344,5,270,0,0,8343,8339,1,0,0,0,8343, + 8340,1,0,0,0,8343,8341,1,0,0,0,8344,8359,1,0,0,0,8345,8346,5,102, + 0,0,8346,8347,5,77,0,0,8347,8350,5,526,0,0,8348,8349,5,33,0,0,8349, + 8351,3,674,337,0,8350,8348,1,0,0,0,8350,8351,1,0,0,0,8351,8352,1, + 0,0,0,8352,8356,5,93,0,0,8353,8357,3,906,453,0,8354,8355,5,57,0, + 0,8355,8357,5,270,0,0,8356,8353,1,0,0,0,8356,8354,1,0,0,0,8357,8359, + 1,0,0,0,8358,8332,1,0,0,0,8358,8345,1,0,0,0,8359,905,1,0,0,0,8360, + 8362,5,241,0,0,8361,8363,3,144,72,0,8362,8361,1,0,0,0,8362,8363, + 1,0,0,0,8363,8367,1,0,0,0,8364,8365,5,463,0,0,8365,8366,7,76,0,0, + 8366,8368,5,450,0,0,8367,8364,1,0,0,0,8367,8368,1,0,0,0,8368,8369, + 1,0,0,0,8369,8370,3,910,455,0,8370,907,1,0,0,0,8371,8372,5,369,0, + 0,8372,8390,5,333,0,0,8373,8374,3,800,400,0,8374,8375,5,10,0,0,8375, + 8376,3,912,456,0,8376,8391,1,0,0,0,8377,8378,3,144,72,0,8378,8379, + 5,10,0,0,8379,8380,5,2,0,0,8380,8385,3,912,456,0,8381,8382,5,6,0, + 0,8382,8384,3,912,456,0,8383,8381,1,0,0,0,8384,8387,1,0,0,0,8385, + 8383,1,0,0,0,8385,8386,1,0,0,0,8386,8388,1,0,0,0,8387,8385,1,0,0, + 0,8388,8389,5,3,0,0,8389,8391,1,0,0,0,8390,8373,1,0,0,0,8390,8377, + 1,0,0,0,8391,8392,1,0,0,0,8392,8390,1,0,0,0,8392,8393,1,0,0,0,8393, + 909,1,0,0,0,8394,8395,5,422,0,0,8395,8396,5,2,0,0,8396,8401,3,912, + 456,0,8397,8398,5,6,0,0,8398,8400,3,912,456,0,8399,8397,1,0,0,0, + 8400,8403,1,0,0,0,8401,8399,1,0,0,0,8401,8402,1,0,0,0,8402,8404, + 1,0,0,0,8403,8401,1,0,0,0,8404,8405,5,3,0,0,8405,8409,1,0,0,0,8406, + 8407,5,53,0,0,8407,8409,5,422,0,0,8408,8394,1,0,0,0,8408,8406,1, + 0,0,0,8409,911,1,0,0,0,8410,8413,3,588,294,0,8411,8413,5,53,0,0, + 8412,8410,1,0,0,0,8412,8411,1,0,0,0,8413,913,1,0,0,0,8414,8415,5, + 157,0,0,8415,8416,3,922,461,0,8416,8417,5,7,0,0,8417,915,1,0,0,0, + 8418,8419,5,78,0,0,8419,8420,5,7,0,0,8420,917,1,0,0,0,8421,8427, + 7,67,0,0,8422,8424,5,33,0,0,8423,8425,5,269,0,0,8424,8423,1,0,0, + 0,8424,8425,1,0,0,0,8425,8426,1,0,0,0,8426,8428,5,153,0,0,8427,8422, + 1,0,0,0,8427,8428,1,0,0,0,8428,8429,1,0,0,0,8429,8430,5,7,0,0,8430, + 919,1,0,0,0,8431,8432,5,333,0,0,8432,8433,3,316,158,0,8433,8434, + 5,94,0,0,8434,8435,5,53,0,0,8435,8436,5,7,0,0,8436,8444,1,0,0,0, + 8437,8440,5,313,0,0,8438,8441,3,316,158,0,8439,8441,5,30,0,0,8440, + 8438,1,0,0,0,8440,8439,1,0,0,0,8441,8442,1,0,0,0,8442,8444,5,7,0, + 0,8443,8431,1,0,0,0,8443,8437,1,0,0,0,8444,921,1,0,0,0,8445,8448, + 3,818,409,0,8446,8448,5,28,0,0,8447,8445,1,0,0,0,8447,8446,1,0,0, + 0,8448,923,1,0,0,0,8449,8466,5,517,0,0,8450,8451,5,102,0,0,8451, + 8456,3,926,463,0,8452,8453,5,82,0,0,8453,8455,3,926,463,0,8454,8452, + 1,0,0,0,8455,8458,1,0,0,0,8456,8454,1,0,0,0,8456,8457,1,0,0,0,8457, + 8459,1,0,0,0,8458,8456,1,0,0,0,8459,8463,5,93,0,0,8460,8462,3,846, + 423,0,8461,8460,1,0,0,0,8462,8465,1,0,0,0,8463,8461,1,0,0,0,8463, + 8464,1,0,0,0,8464,8467,1,0,0,0,8465,8463,1,0,0,0,8466,8450,1,0,0, + 0,8467,8468,1,0,0,0,8468,8466,1,0,0,0,8468,8469,1,0,0,0,8469,925, + 1,0,0,0,8470,8474,3,928,464,0,8471,8472,5,511,0,0,8472,8474,3,808, + 404,0,8473,8470,1,0,0,0,8473,8471,1,0,0,0,8474,927,1,0,0,0,8475, + 8478,3,818,409,0,8476,8478,3,930,465,0,8477,8475,1,0,0,0,8477,8476, + 1,0,0,0,8478,929,1,0,0,0,8479,8480,7,118,0,0,8480,931,1,0,0,0,8481, + 8483,3,756,378,0,8482,8481,1,0,0,0,8482,8483,1,0,0,0,8483,8485,1, + 0,0,0,8484,8486,3,580,290,0,8485,8484,1,0,0,0,8485,8486,1,0,0,0, + 8486,8488,1,0,0,0,8487,8489,3,610,305,0,8488,8487,1,0,0,0,8488,8489, + 1,0,0,0,8489,8491,1,0,0,0,8490,8492,3,638,319,0,8491,8490,1,0,0, + 0,8491,8492,1,0,0,0,8492,8494,1,0,0,0,8493,8495,3,600,300,0,8494, + 8493,1,0,0,0,8494,8495,1,0,0,0,8495,8498,1,0,0,0,8496,8497,5,67, + 0,0,8497,8499,3,674,337,0,8498,8496,1,0,0,0,8498,8499,1,0,0,0,8499, + 8501,1,0,0,0,8500,8502,3,702,351,0,8501,8500,1,0,0,0,8501,8502,1, + 0,0,0,8502,933,1,0,0,0,1188,937,944,1064,1066,1075,1080,1086,1121, + 1131,1137,1142,1149,1154,1161,1172,1180,1184,1196,1202,1208,1212, + 1217,1221,1234,1244,1246,1252,1257,1270,1273,1278,1283,1294,1298, + 1310,1314,1317,1321,1333,1351,1358,1366,1371,1378,1386,1392,1400, + 1408,1412,1426,1431,1436,1448,1454,1466,1471,1481,1487,1492,1500, + 1505,1512,1517,1522,1532,1537,1542,1549,1553,1567,1573,1579,1584, + 1591,1603,1611,1619,1635,1644,1653,1662,1666,1678,1686,1696,1716, + 1721,1724,1731,1734,1738,1742,1745,1750,1755,1759,1768,1774,1778, + 1787,1790,1796,1805,1817,1821,1825,1830,1833,1839,1841,1843,1847, + 1853,1857,1862,1867,1871,1874,1881,1894,1907,1921,1938,1948,1955, + 1960,1964,1971,1976,1979,1981,1986,1990,1994,1998,2003,2006,2010, + 2013,2017,2025,2030,2033,2037,2043,2052,2056,2062,2064,2073,2078, + 2090,2095,2099,2103,2108,2112,2115,2118,2121,2124,2127,2132,2135, + 2138,2141,2144,2147,2153,2157,2160,2163,2166,2169,2171,2178,2186, + 2196,2206,2211,2214,2219,2224,2229,2232,2237,2246,2248,2252,2255, + 2259,2264,2269,2273,2276,2280,2283,2288,2291,2296,2299,2303,2306, + 2309,2314,2317,2325,2337,2341,2348,2353,2356,2359,2362,2367,2378, + 2384,2388,2391,2394,2399,2406,2409,2413,2421,2426,2429,2432,2439, + 2444,2453,2456,2459,2464,2467,2479,2489,2506,2510,2514,2516,2533, + 2535,2551,2562,2565,2568,2577,2586,2602,2605,2608,2616,2620,2627, + 2636,2640,2646,2650,2653,2656,2659,2662,2668,2672,2677,2681,2684, + 2687,2690,2695,2701,2705,2709,2713,2719,2721,2726,2732,2738,2742, + 2757,2762,2765,2767,2770,2774,2778,2781,2784,2792,2798,2800,2806, + 2811,2816,2820,2827,2829,2840,2879,2889,2891,2894,2898,2902,2912, + 2914,2920,2922,2931,2943,2957,2962,2965,2972,2977,2985,2987,2993, + 2998,3002,3007,3013,3020,3026,3028,3037,3043,3051,3057,3062,3067, + 3075,3090,3092,3096,3100,3103,3106,3115,3118,3121,3127,3133,3137, + 3149,3155,3158,3163,3167,3174,3184,3186,3210,3222,3227,3229,3233, + 3236,3239,3249,3252,3262,3267,3272,3275,3278,3286,3292,3299,3307, + 3310,3321,3325,3331,3338,3341,3350,3364,3367,3381,3392,3395,3407, + 3412,3425,3430,3443,3452,3455,3458,3465,3468,3480,3486,3488,3496, + 3504,3512,3524,3529,3540,3551,3559,3567,3574,3581,3583,3586,3591, + 3596,3615,3624,3627,3654,3663,3666,3670,3674,3678,3685,3689,3693, + 3697,3701,3706,3710,3715,3721,3726,3733,3737,3743,3747,3752,3760, + 3766,3771,3778,3783,3787,3792,3798,3805,3810,3817,3822,3829,3833, + 3841,3845,3847,3850,3855,3865,3880,3883,3891,3898,3903,3909,3913, + 3920,3925,3928,3931,3935,3944,3962,3965,3997,4002,4008,4028,4033, + 4039,4042,4046,4050,4056,4059,4063,4067,4072,4075,4078,4081,4094, + 4100,4108,4115,4120,4123,4130,4133,4141,4144,4149,4156,4159,4179, + 4191,4194,4200,4205,4214,4222,4227,4233,4240,4248,4251,4262,4264, + 4278,4284,4292,4294,4300,4304,4307,4310,4315,4320,4324,4327,4330, + 4333,4336,4344,4355,4358,4361,4366,4369,4373,4377,4383,4391,4394, + 4407,4412,4414,4419,4426,4433,4442,4450,4458,4465,4473,4480,4488, + 4492,4496,4498,4504,4509,4513,4520,4525,4530,4535,4537,4547,4557, + 4573,4591,4603,4610,4625,4630,4633,4638,4643,4648,4651,4654,4659, + 4666,4670,4675,4682,4686,4692,4701,4710,4722,4724,4737,4743,4747, + 4749,4756,4769,4776,4778,4794,4798,4802,4807,4812,4817,4822,4825, + 4837,4890,4899,4903,4912,4916,4925,4929,4934,4937,4941,4946,4948, + 4957,4962,4973,4977,4991,4999,5037,5039,5058,5061,5088,5092,5096, + 5100,5104,5107,5122,5129,5143,5156,5181,5200,5215,5231,5238,5249, + 5252,5271,5274,5287,5291,5311,5323,5327,5349,5353,5363,5367,5373, + 5377,5381,5385,5392,5397,5408,5412,5415,5420,5426,5437,5441,5444, + 5448,5452,5455,5465,5468,5472,5477,5483,5486,5491,5494,5501,5503, + 5509,5513,5522,5527,5529,5539,5542,5547,5555,5558,5563,5565,5567, + 5573,5590,5596,5609,5615,5619,5624,5654,5669,5674,5678,5691,5695, + 5697,5706,5712,5714,5718,5721,5724,5727,5730,5732,5735,5739,5747, + 5752,5755,5761,5765,5769,5774,5776,5780,5784,5791,5797,5801,5803, + 5805,5818,5826,5834,5845,5854,5859,5863,5867,5874,5877,5879,5887, + 5891,5894,5901,5908,5913,5920,5923,5925,5928,5934,5939,5943,5950, + 5960,5967,5970,5973,5977,5988,5991,5994,5997,6000,6007,6010,6013, + 6020,6032,6039,6041,6046,6051,6053,6059,6066,6071,6076,6080,6084, + 6088,6090,6094,6098,6101,6104,6106,6116,6118,6123,6127,6132,6136, + 6143,6148,6152,6155,6161,6164,6183,6190,6194,6197,6201,6205,6208, + 6211,6216,6225,6232,6236,6240,6244,6247,6249,6254,6258,6263,6269, + 6276,6281,6286,6295,6302,6310,6321,6326,6330,6333,6337,6342,6346, + 6351,6359,6370,6375,6379,6382,6385,6387,6390,6393,6396,6400,6404, + 6408,6410,6419,6424,6430,6434,6436,6443,6448,6454,6456,6460,6467, + 6472,6475,6481,6485,6491,6500,6506,6508,6513,6516,6525,6532,6534, + 6541,6546,6549,6559,6570,6575,6579,6587,6597,6604,6610,6621,6627, + 6637,6646,6650,6653,6655,6657,6661,6669,6672,6677,6682,6689,6691, + 6697,6701,6704,6709,6712,6714,6720,6729,6735,6738,6746,6749,6753, + 6759,6761,6764,6768,6773,6780,6787,6789,6795,6797,6802,6804,6808, + 6817,6821,6829,6831,6845,6848,6856,6865,6871,6876,6884,6886,6891, + 6895,6900,6905,6911,6927,6929,6938,6953,6958,6961,6967,6972,6985, + 6990,6994,7001,7020,7032,7037,7045,7047,7049,7058,7061,7066,7071, + 7075,7078,7087,7095,7100,7102,7105,7109,7120,7141,7149,7162,7172, + 7178,7184,7187,7190,7216,7218,7239,7249,7262,7267,7271,7273,7285, + 7292,7298,7304,7308,7319,7329,7333,7338,7341,7344,7353,7364,7366, + 7370,7375,7384,7389,7397,7407,7415,7419,7422,7429,7437,7441,7448, + 7456,7465,7468,7480,7489,7496,7505,7515,7520,7524,7526,7529,7534, + 7539,7547,7555,7558,7565,7573,7581,7589,7606,7613,7621,7638,7644, + 7650,7658,7664,7669,7677,7682,7685,7694,7701,7708,7714,7720,7725, + 7730,7738,7793,7800,7806,7808,7810,7812,7818,7822,7826,7837,7840, + 7844,7848,7852,7855,7858,7861,7870,7875,7879,7912,7922,7926,7932, + 7937,7946,7954,7965,7973,7982,7991,7996,8000,8010,8015,8023,8028, + 8031,8038,8044,8052,8060,8063,8070,8072,8075,8081,8090,8094,8108, + 8111,8113,8119,8129,8131,8133,8141,8144,8147,8157,8165,8171,8177, + 8184,8188,8192,8195,8198,8204,8211,8214,8222,8224,8233,8238,8240, + 8247,8253,8256,8268,8275,8277,8281,8287,8292,8296,8299,8302,8311, + 8314,8318,8322,8324,8327,8330,8336,8343,8350,8356,8358,8362,8367, + 8385,8390,8392,8401,8408,8412,8424,8427,8440,8443,8447,8456,8463, + 8468,8473,8477,8482,8485,8488,8491,8494,8498,8501 + ]; -export class RowsecurityoptionalwithcheckContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; - } - public KW_CHECK(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CHECK, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_rowsecurityoptionalwithcheck; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRowsecurityoptionalwithcheck) { - listener.enterRowsecurityoptionalwithcheck(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRowsecurityoptionalwithcheck) { - listener.exitRowsecurityoptionalwithcheck(this); + private static __ATN: antlr.ATN; + public static get _ATN(): antlr.ATN { + if (!PostgreSqlParser.__ATN) { + PostgreSqlParser.__ATN = new antlr.ATNDeserializer().deserialize(PostgreSqlParser._serializedATN); } + + return PostgreSqlParser.__ATN; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRowsecurityoptionalwithcheck) { - return visitor.visitRowsecurityoptionalwithcheck(this); - } else { - return visitor.visitChildren(this); - } + + + private static readonly vocabulary = new antlr.Vocabulary(PostgreSqlParser.literalNames, PostgreSqlParser.symbolicNames, []); + + public override get vocabulary(): antlr.Vocabulary { + return PostgreSqlParser.vocabulary; } -} + private static readonly decisionsToDFA = PostgreSqlParser._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) ); +} -export class RowsecuritydefaulttoroleContext extends antlr.ParserRuleContext { +export class ProgramContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_TO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TO, 0)!; + public EOF(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.EOF, 0)!; } - public role_list(): Role_listContext { - return this.getRuleContext(0, Role_listContext)!; + public singleStmt(): SingleStmtContext[]; + public singleStmt(i: number): SingleStmtContext | null; + public singleStmt(i?: number): SingleStmtContext[] | SingleStmtContext | null { + if (i === undefined) { + return this.getRuleContexts(SingleStmtContext); + } + + return this.getRuleContext(i, SingleStmtContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_rowsecuritydefaulttorole; + return PostgreSqlParser.RULE_program; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRowsecuritydefaulttorole) { - listener.enterRowsecuritydefaulttorole(this); + if(listener.enterProgram) { + listener.enterProgram(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRowsecuritydefaulttorole) { - listener.exitRowsecuritydefaulttorole(this); + if(listener.exitProgram) { + listener.exitProgram(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRowsecuritydefaulttorole) { - return visitor.visitRowsecuritydefaulttorole(this); + if (visitor.visitProgram) { + return visitor.visitProgram(this); } else { return visitor.visitChildren(this); } @@ -84186,32 +58694,32 @@ export class RowsecuritydefaulttoroleContext extends antlr.ParserRuleContext { } -export class RowsecurityoptionaltoroleContext extends antlr.ParserRuleContext { +export class SingleStmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_TO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TO, 0)!; + public stmt(): StmtContext { + return this.getRuleContext(0, StmtContext)!; } - public role_list(): Role_listContext { - return this.getRuleContext(0, Role_listContext)!; + public SEMI(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.SEMI, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_rowsecurityoptionaltorole; + return PostgreSqlParser.RULE_singleStmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRowsecurityoptionaltorole) { - listener.enterRowsecurityoptionaltorole(this); + if(listener.enterSingleStmt) { + listener.enterSingleStmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRowsecurityoptionaltorole) { - listener.exitRowsecurityoptionaltorole(this); + if(listener.exitSingleStmt) { + listener.exitSingleStmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRowsecurityoptionaltorole) { - return visitor.visitRowsecurityoptionaltorole(this); + if (visitor.visitSingleStmt) { + return visitor.visitSingleStmt(this); } else { return visitor.visitChildren(this); } @@ -84219,359 +58727,380 @@ export class RowsecurityoptionaltoroleContext extends antlr.ParserRuleContext { } -export class RowsecuritydefaultpermissiveContext extends antlr.ParserRuleContext { +export class StmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; + public altereventtrigstmt(): AltereventtrigstmtContext | null { + return this.getRuleContext(0, AltereventtrigstmtContext); } - public KW_PERMISSIVE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PERMISSIVE, 0); + public altercollationstmt(): AltercollationstmtContext | null { + return this.getRuleContext(0, AltercollationstmtContext); } - public KW_RESTRICTIVE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESTRICTIVE, 0); + public alterdatabasestmt(): AlterdatabasestmtContext | null { + return this.getRuleContext(0, AlterdatabasestmtContext); } - public identifier(): IdentifierContext | null { - return this.getRuleContext(0, IdentifierContext); + public alterdatabasesetstmt(): AlterdatabasesetstmtContext | null { + return this.getRuleContext(0, AlterdatabasesetstmtContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_rowsecuritydefaultpermissive; + public alterdefaultprivilegesstmt(): AlterdefaultprivilegesstmtContext | null { + return this.getRuleContext(0, AlterdefaultprivilegesstmtContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRowsecuritydefaultpermissive) { - listener.enterRowsecuritydefaultpermissive(this); - } + public alterdomainstmt(): AlterdomainstmtContext | null { + return this.getRuleContext(0, AlterdomainstmtContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRowsecuritydefaultpermissive) { - listener.exitRowsecuritydefaultpermissive(this); - } + public alterenumstmt(): AlterenumstmtContext | null { + return this.getRuleContext(0, AlterenumstmtContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRowsecuritydefaultpermissive) { - return visitor.visitRowsecuritydefaultpermissive(this); - } else { - return visitor.visitChildren(this); - } + public alterextensionstmt(): AlterextensionstmtContext | null { + return this.getRuleContext(0, AlterextensionstmtContext); } -} - - -export class RowsecuritydefaultforcmdContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public alterextensioncontentsstmt(): AlterextensioncontentsstmtContext | null { + return this.getRuleContext(0, AlterextensioncontentsstmtContext); } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; + public alterfdwstmt(): AlterfdwstmtContext | null { + return this.getRuleContext(0, AlterfdwstmtContext); } - public row_security_cmd(): Row_security_cmdContext { - return this.getRuleContext(0, Row_security_cmdContext)!; + public alterforeignserverstmt(): AlterforeignserverstmtContext | null { + return this.getRuleContext(0, AlterforeignserverstmtContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_rowsecuritydefaultforcmd; + public alterfunctionstmt(): AlterfunctionstmtContext | null { + return this.getRuleContext(0, AlterfunctionstmtContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRowsecuritydefaultforcmd) { - listener.enterRowsecuritydefaultforcmd(this); - } + public altergroupstmt(): AltergroupstmtContext | null { + return this.getRuleContext(0, AltergroupstmtContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRowsecuritydefaultforcmd) { - listener.exitRowsecuritydefaultforcmd(this); - } + public alterobjectdependsstmt(): AlterobjectdependsstmtContext | null { + return this.getRuleContext(0, AlterobjectdependsstmtContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRowsecuritydefaultforcmd) { - return visitor.visitRowsecuritydefaultforcmd(this); - } else { - return visitor.visitChildren(this); - } + public alterobjectschemastmt(): AlterobjectschemastmtContext | null { + return this.getRuleContext(0, AlterobjectschemastmtContext); } -} - - -export class Row_security_cmdContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public alterownerstmt(): AlterownerstmtContext | null { + return this.getRuleContext(0, AlterownerstmtContext); } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); + public alteroperatorstmt(): AlteroperatorstmtContext | null { + return this.getRuleContext(0, AlteroperatorstmtContext); } - public KW_SELECT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SELECT, 0); + public altertypestmt(): AltertypestmtContext | null { + return this.getRuleContext(0, AltertypestmtContext); } - public KW_INSERT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INSERT, 0); + public alterpolicystmt(): AlterpolicystmtContext | null { + return this.getRuleContext(0, AlterpolicystmtContext); } - public KW_UPDATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UPDATE, 0); + public alterprocedurestmt(): AlterprocedurestmtContext | null { + return this.getRuleContext(0, AlterprocedurestmtContext); } - public KW_DELETE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DELETE, 0); + public alterseqstmt(): AlterseqstmtContext | null { + return this.getRuleContext(0, AlterseqstmtContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_row_security_cmd; + public altersystemstmt(): AltersystemstmtContext | null { + return this.getRuleContext(0, AltersystemstmtContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRow_security_cmd) { - listener.enterRow_security_cmd(this); - } + public altertablestmt(): AltertablestmtContext | null { + return this.getRuleContext(0, AltertablestmtContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRow_security_cmd) { - listener.exitRow_security_cmd(this); - } + public altertblspcstmt(): AltertblspcstmtContext | null { + return this.getRuleContext(0, AltertblspcstmtContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRow_security_cmd) { - return visitor.visitRow_security_cmd(this); - } else { - return visitor.visitChildren(this); - } + public altercompositetypestmt(): AltercompositetypestmtContext | null { + return this.getRuleContext(0, AltercompositetypestmtContext); } -} - - -export class CreateamstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public alterpublicationstmt(): AlterpublicationstmtContext | null { + return this.getRuleContext(0, AlterpublicationstmtContext); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + public alterrolesetstmt(): AlterrolesetstmtContext | null { + return this.getRuleContext(0, AlterrolesetstmtContext); } - public KW_ACCESS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ACCESS, 0)!; + public alterroutinestmt(): AlterroutinestmtContext | null { + return this.getRuleContext(0, AlterroutinestmtContext); } - public KW_METHOD(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_METHOD, 0)!; + public alterrolestmt(): AlterrolestmtContext | null { + return this.getRuleContext(0, AlterrolestmtContext); } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public altersubscriptionstmt(): AltersubscriptionstmtContext | null { + return this.getRuleContext(0, AltersubscriptionstmtContext); } - public KW_TYPE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TYPE, 0)!; + public alterstatsstmt(): AlterstatsstmtContext | null { + return this.getRuleContext(0, AlterstatsstmtContext); } - public am_type(): Am_typeContext { - return this.getRuleContext(0, Am_typeContext)!; + public altertsconfigurationstmt(): AltertsconfigurationstmtContext | null { + return this.getRuleContext(0, AltertsconfigurationstmtContext); } - public KW_HANDLER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_HANDLER, 0)!; + public altertsdictionarystmt(): AltertsdictionarystmtContext | null { + return this.getRuleContext(0, AltertsdictionarystmtContext); } - public handler_name(): Handler_nameContext { - return this.getRuleContext(0, Handler_nameContext)!; + public alterusermappingstmt(): AlterusermappingstmtContext | null { + return this.getRuleContext(0, AlterusermappingstmtContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createamstmt; + public analyzestmt(): AnalyzestmtContext | null { + return this.getRuleContext(0, AnalyzestmtContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateamstmt) { - listener.enterCreateamstmt(this); - } + public callstmt(): CallstmtContext | null { + return this.getRuleContext(0, CallstmtContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateamstmt) { - listener.exitCreateamstmt(this); - } + public checkpointstmt(): CheckpointstmtContext | null { + return this.getRuleContext(0, CheckpointstmtContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateamstmt) { - return visitor.visitCreateamstmt(this); - } else { - return visitor.visitChildren(this); - } + public closeportalstmt(): CloseportalstmtContext | null { + return this.getRuleContext(0, CloseportalstmtContext); } -} - - -export class Am_typeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public clusterstmt(): ClusterstmtContext | null { + return this.getRuleContext(0, ClusterstmtContext); } - public KW_INDEX(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INDEX, 0); + public commentstmt(): CommentstmtContext | null { + return this.getRuleContext(0, CommentstmtContext); } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); + public constraintssetstmt(): ConstraintssetstmtContext | null { + return this.getRuleContext(0, ConstraintssetstmtContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_am_type; + public copystmt(): CopystmtContext | null { + return this.getRuleContext(0, CopystmtContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAm_type) { - listener.enterAm_type(this); - } + public createamstmt(): CreateamstmtContext | null { + return this.getRuleContext(0, CreateamstmtContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAm_type) { - listener.exitAm_type(this); - } + public createasstmt(): CreateasstmtContext | null { + return this.getRuleContext(0, CreateasstmtContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAm_type) { - return visitor.visitAm_type(this); - } else { - return visitor.visitChildren(this); - } + public createassertionstmt(): CreateassertionstmtContext | null { + return this.getRuleContext(0, CreateassertionstmtContext); } -} - - -export class CreatetrigstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public createcaststmt(): CreatecaststmtContext | null { + return this.getRuleContext(0, CreatecaststmtContext); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + public createconversionstmt(): CreateconversionstmtContext | null { + return this.getRuleContext(0, CreateconversionstmtContext); } - public KW_TRIGGER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0)!; + public createdomainstmt(): CreatedomainstmtContext | null { + return this.getRuleContext(0, CreatedomainstmtContext); } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public createextensionstmt(): CreateextensionstmtContext | null { + return this.getRuleContext(0, CreateextensionstmtContext); } - public triggeractiontime(): TriggeractiontimeContext { - return this.getRuleContext(0, TriggeractiontimeContext)!; + public createfdwstmt(): CreatefdwstmtContext | null { + return this.getRuleContext(0, CreatefdwstmtContext); } - public triggerevents(): TriggereventsContext { - return this.getRuleContext(0, TriggereventsContext)!; + public createforeignserverstmt(): CreateforeignserverstmtContext | null { + return this.getRuleContext(0, CreateforeignserverstmtContext); } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; + public createforeigntablestmt(): CreateforeigntablestmtContext | null { + return this.getRuleContext(0, CreateforeigntablestmtContext); } - public table_name(): Table_nameContext { - return this.getRuleContext(0, Table_nameContext)!; + public createfunctionstmt(): CreatefunctionstmtContext | null { + return this.getRuleContext(0, CreatefunctionstmtContext); } - public KW_EXECUTE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXECUTE, 0)!; + public creategroupstmt(): CreategroupstmtContext | null { + return this.getRuleContext(0, CreategroupstmtContext); } - public function_or_procedure(): Function_or_procedureContext { - return this.getRuleContext(0, Function_or_procedureContext)!; + public creatematviewstmt(): CreatematviewstmtContext | null { + return this.getRuleContext(0, CreatematviewstmtContext); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public createopclassstmt(): CreateopclassstmtContext | null { + return this.getRuleContext(0, CreateopclassstmtContext); } - public triggerfuncargs(): TriggerfuncargsContext { - return this.getRuleContext(0, TriggerfuncargsContext)!; + public createopfamilystmt(): CreateopfamilystmtContext | null { + return this.getRuleContext(0, CreateopfamilystmtContext); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public createpublicationstmt(): CreatepublicationstmtContext | null { + return this.getRuleContext(0, CreatepublicationstmtContext); } - public opt_or_replace(): Opt_or_replaceContext | null { - return this.getRuleContext(0, Opt_or_replaceContext); + public alteropfamilystmt(): AlteropfamilystmtContext | null { + return this.getRuleContext(0, AlteropfamilystmtContext); } - public triggerreferencing(): TriggerreferencingContext | null { - return this.getRuleContext(0, TriggerreferencingContext); + public createpolicystmt(): CreatepolicystmtContext | null { + return this.getRuleContext(0, CreatepolicystmtContext); } - public triggerforspec(): TriggerforspecContext | null { - return this.getRuleContext(0, TriggerforspecContext); + public createplangstmt(): CreateplangstmtContext | null { + return this.getRuleContext(0, CreateplangstmtContext); } - public triggerwhen(): TriggerwhenContext | null { - return this.getRuleContext(0, TriggerwhenContext); + public createschemastmt(): CreateschemastmtContext | null { + return this.getRuleContext(0, CreateschemastmtContext); } - public constraintattributespec(): ConstraintattributespecContext | null { - return this.getRuleContext(0, ConstraintattributespecContext); + public createseqstmt(): CreateseqstmtContext | null { + return this.getRuleContext(0, CreateseqstmtContext); } - public KW_CONSTRAINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); + public createstmt(): CreatestmtContext | null { + return this.getRuleContext(0, CreatestmtContext); } - public optconstrfromtable(): OptconstrfromtableContext | null { - return this.getRuleContext(0, OptconstrfromtableContext); + public createsubscriptionstmt(): CreatesubscriptionstmtContext | null { + return this.getRuleContext(0, CreatesubscriptionstmtContext); } - public foreachrow(): ForeachrowContext | null { - return this.getRuleContext(0, ForeachrowContext); + public createstatsstmt(): CreatestatsstmtContext | null { + return this.getRuleContext(0, CreatestatsstmtContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createtrigstmt; + public createtablespacestmt(): CreatetablespacestmtContext | null { + return this.getRuleContext(0, CreatetablespacestmtContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatetrigstmt) { - listener.enterCreatetrigstmt(this); - } + public createtransformstmt(): CreatetransformstmtContext | null { + return this.getRuleContext(0, CreatetransformstmtContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatetrigstmt) { - listener.exitCreatetrigstmt(this); - } + public createtrigstmt(): CreatetrigstmtContext | null { + return this.getRuleContext(0, CreatetrigstmtContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatetrigstmt) { - return visitor.visitCreatetrigstmt(this); - } else { - return visitor.visitChildren(this); - } + public createeventtrigstmt(): CreateeventtrigstmtContext | null { + return this.getRuleContext(0, CreateeventtrigstmtContext); } -} - - -export class TriggeractiontimeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public createrolestmt(): CreaterolestmtContext | null { + return this.getRuleContext(0, CreaterolestmtContext); } - public KW_BEFORE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BEFORE, 0); + public createuserstmt(): CreateuserstmtContext | null { + return this.getRuleContext(0, CreateuserstmtContext); } - public KW_AFTER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AFTER, 0); + public createusermappingstmt(): CreateusermappingstmtContext | null { + return this.getRuleContext(0, CreateusermappingstmtContext); } - public KW_INSTEAD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INSTEAD, 0); + public createdbstmt(): CreatedbstmtContext | null { + return this.getRuleContext(0, CreatedbstmtContext); } - public KW_OF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OF, 0); + public deallocatestmt(): DeallocatestmtContext | null { + return this.getRuleContext(0, DeallocatestmtContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggeractiontime; + public declarecursorstmt(): DeclarecursorstmtContext | null { + return this.getRuleContext(0, DeclarecursorstmtContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggeractiontime) { - listener.enterTriggeractiontime(this); - } + public definestmt(): DefinestmtContext | null { + return this.getRuleContext(0, DefinestmtContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggeractiontime) { - listener.exitTriggeractiontime(this); - } + public deletestmt(): DeletestmtContext | null { + return this.getRuleContext(0, DeletestmtContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggeractiontime) { - return visitor.visitTriggeractiontime(this); - } else { - return visitor.visitChildren(this); - } + public discardstmt(): DiscardstmtContext | null { + return this.getRuleContext(0, DiscardstmtContext); } -} - - -export class ForeachrowContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public dostmt(): DostmtContext | null { + return this.getRuleContext(0, DostmtContext); + } + public dropstmt(): DropstmtContext | null { + return this.getRuleContext(0, DropstmtContext); + } + public executestmt(): ExecutestmtContext | null { + return this.getRuleContext(0, ExecutestmtContext); + } + public explainstmt(): ExplainstmtContext | null { + return this.getRuleContext(0, ExplainstmtContext); + } + public fetchstmt(): FetchstmtContext | null { + return this.getRuleContext(0, FetchstmtContext); + } + public grantstmt(): GrantstmtContext | null { + return this.getRuleContext(0, GrantstmtContext); + } + public grantrolestmt(): GrantrolestmtContext | null { + return this.getRuleContext(0, GrantrolestmtContext); + } + public mergestmt(): MergestmtContext | null { + return this.getRuleContext(0, MergestmtContext); + } + public importforeignschemastmt(): ImportforeignschemastmtContext | null { + return this.getRuleContext(0, ImportforeignschemastmtContext); + } + public indexstmt(): IndexstmtContext | null { + return this.getRuleContext(0, IndexstmtContext); + } + public insertstmt(): InsertstmtContext | null { + return this.getRuleContext(0, InsertstmtContext); + } + public listenstmt(): ListenstmtContext | null { + return this.getRuleContext(0, ListenstmtContext); + } + public refreshmatviewstmt(): RefreshmatviewstmtContext | null { + return this.getRuleContext(0, RefreshmatviewstmtContext); + } + public loadstmt(): LoadstmtContext | null { + return this.getRuleContext(0, LoadstmtContext); + } + public lockstmt(): LockstmtContext | null { + return this.getRuleContext(0, LockstmtContext); + } + public notifystmt(): NotifystmtContext | null { + return this.getRuleContext(0, NotifystmtContext); + } + public preparestmt(): PreparestmtContext | null { + return this.getRuleContext(0, PreparestmtContext); + } + public reassignownedstmt(): ReassignownedstmtContext | null { + return this.getRuleContext(0, ReassignownedstmtContext); + } + public reindexstmt(): ReindexstmtContext | null { + return this.getRuleContext(0, ReindexstmtContext); + } + public removeaggrstmt(): RemoveaggrstmtContext | null { + return this.getRuleContext(0, RemoveaggrstmtContext); + } + public removefuncstmt(): RemovefuncstmtContext | null { + return this.getRuleContext(0, RemovefuncstmtContext); + } + public removeoperstmt(): RemoveoperstmtContext | null { + return this.getRuleContext(0, RemoveoperstmtContext); + } + public renamestmt(): RenamestmtContext | null { + return this.getRuleContext(0, RenamestmtContext); + } + public revokestmt(): RevokestmtContext | null { + return this.getRuleContext(0, RevokestmtContext); + } + public revokerolestmt(): RevokerolestmtContext | null { + return this.getRuleContext(0, RevokerolestmtContext); + } + public rulestmt(): RulestmtContext | null { + return this.getRuleContext(0, RulestmtContext); + } + public seclabelstmt(): SeclabelstmtContext | null { + return this.getRuleContext(0, SeclabelstmtContext); + } + public selectstmt(): SelectstmtContext | null { + return this.getRuleContext(0, SelectstmtContext); + } + public transactionstmt(): TransactionstmtContext | null { + return this.getRuleContext(0, TransactionstmtContext); + } + public truncatestmt(): TruncatestmtContext | null { + return this.getRuleContext(0, TruncatestmtContext); + } + public unlistenstmt(): UnlistenstmtContext | null { + return this.getRuleContext(0, UnlistenstmtContext); + } + public updatestmt(): UpdatestmtContext | null { + return this.getRuleContext(0, UpdatestmtContext); + } + public vacuumstmt(): VacuumstmtContext | null { + return this.getRuleContext(0, VacuumstmtContext); + } + public variableresetstmt(): VariableresetstmtContext | null { + return this.getRuleContext(0, VariableresetstmtContext); + } + public variablesetstmt(): VariablesetstmtContext | null { + return this.getRuleContext(0, VariablesetstmtContext); } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; + public variableshowstmt(): VariableshowstmtContext | null { + return this.getRuleContext(0, VariableshowstmtContext); + } + public viewstmt(): ViewstmtContext | null { + return this.getRuleContext(0, ViewstmtContext); } - public roworstatment(): RoworstatmentContext { - return this.getRuleContext(0, RoworstatmentContext)!; + public MetaCommand(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.MetaCommand, 0); } - public KW_EACH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EACH, 0); + public EndMetaCommand(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.EndMetaCommand, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_foreachrow; + return PostgreSqlParser.RULE_stmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterForeachrow) { - listener.enterForeachrow(this); + if(listener.enterStmt) { + listener.enterStmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitForeachrow) { - listener.exitForeachrow(this); + if(listener.exitStmt) { + listener.exitStmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitForeachrow) { - return visitor.visitForeachrow(this); + if (visitor.visitStmt) { + return visitor.visitStmt(this); } else { return visitor.visitChildren(this); } @@ -84579,32 +59108,32 @@ export class ForeachrowContext extends antlr.ParserRuleContext { } -export class RoworstatmentContext extends antlr.ParserRuleContext { +export class CallstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ROW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROW, 0); + public KW_CALL(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CALL, 0)!; } - public KW_STATEMENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STATEMENT, 0); + public func_application(): Func_applicationContext { + return this.getRuleContext(0, Func_applicationContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_roworstatment; + return PostgreSqlParser.RULE_callstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRoworstatment) { - listener.enterRoworstatment(this); + if(listener.enterCallstmt) { + listener.enterCallstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRoworstatment) { - listener.exitRoworstatment(this); + if(listener.exitCallstmt) { + listener.exitCallstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRoworstatment) { - return visitor.visitRoworstatment(this); + if (visitor.visitCallstmt) { + return visitor.visitCallstmt(this); } else { return visitor.visitChildren(this); } @@ -84612,44 +59141,47 @@ export class RoworstatmentContext extends antlr.ParserRuleContext { } -export class TriggereventsContext extends antlr.ParserRuleContext { +export class CreaterolestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public triggeroneevent(): TriggeroneeventContext[]; - public triggeroneevent(i: number): TriggeroneeventContext | null; - public triggeroneevent(i?: number): TriggeroneeventContext[] | TriggeroneeventContext | null { + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + } + public KW_ROLE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ROLE, 0)!; + } + public rolespec(): RolespecContext { + return this.getRuleContext(0, RolespecContext)!; + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); + } + public createoptroleelem(): CreateoptroleelemContext[]; + public createoptroleelem(i: number): CreateoptroleelemContext | null; + public createoptroleelem(i?: number): CreateoptroleelemContext[] | CreateoptroleelemContext | null { if (i === undefined) { - return this.getRuleContexts(TriggeroneeventContext); + return this.getRuleContexts(CreateoptroleelemContext); } - return this.getRuleContext(i, TriggeroneeventContext); - } - public KW_OR(): antlr.TerminalNode[]; - public KW_OR(i: number): antlr.TerminalNode | null; - public KW_OR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_OR); - } else { - return this.getToken(PostgreSqlParser.KW_OR, i); - } + return this.getRuleContext(i, CreateoptroleelemContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggerevents; + return PostgreSqlParser.RULE_createrolestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggerevents) { - listener.enterTriggerevents(this); + if(listener.enterCreaterolestmt) { + listener.enterCreaterolestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggerevents) { - listener.exitTriggerevents(this); + if(listener.exitCreaterolestmt) { + listener.exitCreaterolestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggerevents) { - return visitor.visitTriggerevents(this); + if (visitor.visitCreaterolestmt) { + return visitor.visitCreaterolestmt(this); } else { return visitor.visitChildren(this); } @@ -84657,44 +59189,128 @@ export class TriggereventsContext extends antlr.ParserRuleContext { } -export class TriggeroneeventContext extends antlr.ParserRuleContext { +export class AlteroptroleelemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_INSERT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INSERT, 0); + public KW_PASSWORD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PASSWORD, 0); } - public KW_DELETE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DELETE, 0); + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } - public KW_UPDATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UPDATE, 0); + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULL, 0); } - public KW_OF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OF, 0); + public KW_ENCRYPTED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ENCRYPTED, 0); } - public column_list(): Column_listContext | null { - return this.getRuleContext(0, Column_listContext); + public KW_UNENCRYPTED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNENCRYPTED, 0); } - public KW_TRUNCATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRUNCATE, 0); + public KW_INHERIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INHERIT, 0); + } + public KW_NOINHERIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOINHERIT, 0); + } + public KW_CREATEUSER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CREATEUSER, 0); + } + public KW_NOCREATEUSER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOCREATEUSER, 0); + } + public KW_CREATEROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CREATEROLE, 0); + } + public KW_NOCREATEROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOCREATEROLE, 0); + } + public KW_CREATEDB(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CREATEDB, 0); + } + public KW_NOCREATEDB(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOCREATEDB, 0); + } + public KW_SUPERUSER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SUPERUSER, 0); + } + public KW_NOSUPERUSER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOSUPERUSER, 0); + } + public KW_LOGIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LOGIN, 0); + } + public KW_NOLOGIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOLOGIN, 0); + } + public KW_REPLICATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REPLICATION, 0); + } + public KW_NOREPLICATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOREPLICATION, 0); + } + public KW_BYPASSRLS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BYPASSRLS, 0); + } + public KW_NOBYPASSRLS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOBYPASSRLS, 0); + } + public KW_CONNECTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONNECTION, 0); + } + public KW_LIMIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LIMIT, 0); + } + public signediconst(): SignediconstContext | null { + return this.getRuleContext(0, SignediconstContext); + } + public KW_VALID(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALID, 0); + } + public KW_UNTIL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNTIL, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); + } + public name_list(): Name_listContext | null { + return this.getRuleContext(0, Name_listContext); + } + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLE, 0); + } + public KW_GROUP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GROUP, 0); + } + public role_list(): Role_listContext | null { + return this.getRuleContext(0, Role_listContext); + } + public KW_USER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USER, 0); + } + public KW_ADMIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADMIN, 0); + } + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggeroneevent; + return PostgreSqlParser.RULE_alteroptroleelem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggeroneevent) { - listener.enterTriggeroneevent(this); + if(listener.enterAlteroptroleelem) { + listener.enterAlteroptroleelem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggeroneevent) { - listener.exitTriggeroneevent(this); + if(listener.exitAlteroptroleelem) { + listener.exitAlteroptroleelem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggeroneevent) { - return visitor.visitTriggeroneevent(this); + if (visitor.visitAlteroptroleelem) { + return visitor.visitAlteroptroleelem(this); } else { return visitor.visitChildren(this); } @@ -84702,32 +59318,50 @@ export class TriggeroneeventContext extends antlr.ParserRuleContext { } -export class TriggerreferencingContext extends antlr.ParserRuleContext { +export class CreateoptroleelemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_REFERENCING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_REFERENCING, 0)!; + public alteroptroleelem(): AlteroptroleelemContext | null { + return this.getRuleContext(0, AlteroptroleelemContext); + } + public KW_SYSID(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SYSID, 0); + } + public Integral(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.Integral, 0); + } + public role_list(): Role_listContext | null { + return this.getRuleContext(0, Role_listContext); + } + public KW_ADMIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADMIN, 0); + } + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLE, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); } - public triggertransitions(): TriggertransitionsContext { - return this.getRuleContext(0, TriggertransitionsContext)!; + public KW_GROUP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GROUP, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggerreferencing; + return PostgreSqlParser.RULE_createoptroleelem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggerreferencing) { - listener.enterTriggerreferencing(this); + if(listener.enterCreateoptroleelem) { + listener.enterCreateoptroleelem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggerreferencing) { - listener.exitTriggerreferencing(this); + if(listener.exitCreateoptroleelem) { + listener.exitCreateoptroleelem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggerreferencing) { - return visitor.visitTriggerreferencing(this); + if (visitor.visitCreateoptroleelem) { + return visitor.visitCreateoptroleelem(this); } else { return visitor.visitChildren(this); } @@ -84735,35 +59369,47 @@ export class TriggerreferencingContext extends antlr.ParserRuleContext { } -export class TriggertransitionsContext extends antlr.ParserRuleContext { +export class CreateuserstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public triggertransition(): TriggertransitionContext[]; - public triggertransition(i: number): TriggertransitionContext | null; - public triggertransition(i?: number): TriggertransitionContext[] | TriggertransitionContext | null { + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + } + public KW_USER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_USER, 0)!; + } + public rolespec(): RolespecContext { + return this.getRuleContext(0, RolespecContext)!; + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); + } + public createoptroleelem(): CreateoptroleelemContext[]; + public createoptroleelem(i: number): CreateoptroleelemContext | null; + public createoptroleelem(i?: number): CreateoptroleelemContext[] | CreateoptroleelemContext | null { if (i === undefined) { - return this.getRuleContexts(TriggertransitionContext); + return this.getRuleContexts(CreateoptroleelemContext); } - return this.getRuleContext(i, TriggertransitionContext); + return this.getRuleContext(i, CreateoptroleelemContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggertransitions; + return PostgreSqlParser.RULE_createuserstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggertransitions) { - listener.enterTriggertransitions(this); + if(listener.enterCreateuserstmt) { + listener.enterCreateuserstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggertransitions) { - listener.exitTriggertransitions(this); + if(listener.exitCreateuserstmt) { + listener.exitCreateuserstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggertransitions) { - return visitor.visitTriggertransitions(this); + if (visitor.visitCreateuserstmt) { + return visitor.visitCreateuserstmt(this); } else { return visitor.visitChildren(this); } @@ -84771,38 +59417,50 @@ export class TriggertransitionsContext extends antlr.ParserRuleContext { } -export class TriggertransitionContext extends antlr.ParserRuleContext { +export class AlterrolestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public transitionoldornew(): TransitionoldornewContext { - return this.getRuleContext(0, TransitionoldornewContext)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public rolespec(): RolespecContext { + return this.getRuleContext(0, RolespecContext)!; + } + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLE, 0); } - public transitionrowortable(): TransitionrowortableContext { - return this.getRuleContext(0, TransitionrowortableContext)!; + public KW_USER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USER, 0); } - public transitionrelname(): TransitionrelnameContext { - return this.getRuleContext(0, TransitionrelnameContext)!; + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public opt_as(): Opt_asContext | null { - return this.getRuleContext(0, Opt_asContext); + public alteroptroleelem(): AlteroptroleelemContext[]; + public alteroptroleelem(i: number): AlteroptroleelemContext | null; + public alteroptroleelem(i?: number): AlteroptroleelemContext[] | AlteroptroleelemContext | null { + if (i === undefined) { + return this.getRuleContexts(AlteroptroleelemContext); + } + + return this.getRuleContext(i, AlteroptroleelemContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggertransition; + return PostgreSqlParser.RULE_alterrolestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggertransition) { - listener.enterTriggertransition(this); + if(listener.enterAlterrolestmt) { + listener.enterAlterrolestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggertransition) { - listener.exitTriggertransition(this); + if(listener.exitAlterrolestmt) { + listener.exitAlterrolestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggertransition) { - return visitor.visitTriggertransition(this); + if (visitor.visitAlterrolestmt) { + return visitor.visitAlterrolestmt(this); } else { return visitor.visitChildren(this); } @@ -84810,65 +59468,53 @@ export class TriggertransitionContext extends antlr.ParserRuleContext { } -export class TransitionoldornewContext extends antlr.ParserRuleContext { +export class AlterrolesetstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_NEW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NEW, 0); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public KW_OLD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OLD, 0); + public KW_IN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_IN, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_transitionoldornew; + public KW_DATABASE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DATABASE, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTransitionoldornew) { - listener.enterTransitionoldornew(this); - } + public database_name(): Database_nameContext { + return this.getRuleContext(0, Database_nameContext)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTransitionoldornew) { - listener.exitTransitionoldornew(this); - } + public setresetclause(): SetresetclauseContext { + return this.getRuleContext(0, SetresetclauseContext)!; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTransitionoldornew) { - return visitor.visitTransitionoldornew(this); - } else { - return visitor.visitChildren(this); - } + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLE, 0); } -} - - -export class TransitionrowortableContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_USER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USER, 0); } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public KW_ROW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROW, 0); + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_transitionrowortable; + return PostgreSqlParser.RULE_alterrolesetstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTransitionrowortable) { - listener.enterTransitionrowortable(this); + if(listener.enterAlterrolesetstmt) { + listener.enterAlterrolesetstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTransitionrowortable) { - listener.exitTransitionrowortable(this); + if(listener.exitAlterrolesetstmt) { + listener.exitAlterrolesetstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTransitionrowortable) { - return visitor.visitTransitionrowortable(this); + if (visitor.visitAlterrolesetstmt) { + return visitor.visitAlterrolesetstmt(this); } else { return visitor.visitChildren(this); } @@ -84876,29 +59522,41 @@ export class TransitionrowortableContext extends antlr.ParserRuleContext { } -export class TransitionrelnameContext extends antlr.ParserRuleContext { +export class AlterroutinestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public KW_ROUTINE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0)!; + } + public routine_name(): Routine_nameContext { + return this.getRuleContext(0, Routine_nameContext)!; + } + public alter_routine_cluase(): Alter_routine_cluaseContext { + return this.getRuleContext(0, Alter_routine_cluaseContext)!; + } + public func_args(): Func_argsContext | null { + return this.getRuleContext(0, Func_argsContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_transitionrelname; + return PostgreSqlParser.RULE_alterroutinestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTransitionrelname) { - listener.enterTransitionrelname(this); + if(listener.enterAlterroutinestmt) { + listener.enterAlterroutinestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTransitionrelname) { - listener.exitTransitionrelname(this); + if(listener.exitAlterroutinestmt) { + listener.exitAlterroutinestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTransitionrelname) { - return visitor.visitTransitionrelname(this); + if (visitor.visitAlterroutinestmt) { + return visitor.visitAlterroutinestmt(this); } else { return visitor.visitChildren(this); } @@ -84906,35 +59564,77 @@ export class TransitionrelnameContext extends antlr.ParserRuleContext { } -export class TriggerforspecContext extends antlr.ParserRuleContext { +export class Alter_routine_cluaseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; + public routine_action(): Routine_actionContext[]; + public routine_action(i: number): Routine_actionContext | null; + public routine_action(i?: number): Routine_actionContext[] | Routine_actionContext | null { + if (i === undefined) { + return this.getRuleContexts(Routine_actionContext); + } + + return this.getRuleContext(i, Routine_actionContext); + } + public KW_RESTRICT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESTRICT, 0); + } + public KW_RENAME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RENAME, 0); + } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); + } + public routine_name_create(): Routine_name_createContext | null { + return this.getRuleContext(0, Routine_name_createContext); + } + public KW_OWNER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OWNER, 0); + } + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); + } + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); + } + public schema_name_create(): Schema_name_createContext | null { + return this.getRuleContext(0, Schema_name_createContext); + } + public KW_DEPENDS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEPENDS, 0); + } + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ON, 0); } - public triggerfortype(): TriggerfortypeContext { - return this.getRuleContext(0, TriggerfortypeContext)!; + public KW_EXTENSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXTENSION, 0); + } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public triggerforopteach(): TriggerforopteachContext | null { - return this.getRuleContext(0, TriggerforopteachContext); + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggerforspec; + return PostgreSqlParser.RULE_alter_routine_cluase; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggerforspec) { - listener.enterTriggerforspec(this); + if(listener.enterAlter_routine_cluase) { + listener.enterAlter_routine_cluase(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggerforspec) { - listener.exitTriggerforspec(this); + if(listener.exitAlter_routine_cluase) { + listener.exitAlter_routine_cluase(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggerforspec) { - return visitor.visitTriggerforspec(this); + if (visitor.visitAlter_routine_cluase) { + return visitor.visitAlter_routine_cluase(this); } else { return visitor.visitChildren(this); } @@ -84942,62 +59642,107 @@ export class TriggerforspecContext extends antlr.ParserRuleContext { } -export class TriggerforopteachContext extends antlr.ParserRuleContext { +export class Routine_actionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_EACH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EACH, 0)!; + public KW_IMMUTABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IMMUTABLE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggerforopteach; + public KW_STABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STABLE, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggerforopteach) { - listener.enterTriggerforopteach(this); - } + public KW_VOLATILE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VOLATILE, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggerforopteach) { - listener.exitTriggerforopteach(this); - } + public KW_LEAKPROOF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LEAKPROOF, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggerforopteach) { - return visitor.visitTriggerforopteach(this); - } else { - return visitor.visitChildren(this); - } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } -} - + public KW_SECURITY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SECURITY, 0); + } + public KW_INVOKER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INVOKER, 0); + } + public KW_DEFINER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFINER, 0); + } + public KW_EXTERNAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXTERNAL, 0); + } + public KW_PARALLEL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARALLEL, 0); + } + public KW_UNSAFE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNSAFE, 0); + } + public KW_RESTRICTED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESTRICTED, 0); + } + public KW_SAFE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SAFE, 0); + } + public KW_COST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COST, 0); + } + public collabel(): CollabelContext | null { + return this.getRuleContext(0, CollabelContext); + } + public KW_ROWS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROWS, 0); + } + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { + if (i === undefined) { + return this.getRuleContexts(ColidContext); + } -export class TriggerfortypeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, ColidContext); } - public KW_ROW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROW, 0); + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public KW_STATEMENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STATEMENT, 0); + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); + } + public EQUAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.EQUAL, 0); + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); + } + public KW_CURRENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT, 0); + } + public KW_RESET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESET, 0); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggerfortype; + return PostgreSqlParser.RULE_routine_action; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggerfortype) { - listener.enterTriggerfortype(this); + if(listener.enterRoutine_action) { + listener.enterRoutine_action(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggerfortype) { - listener.exitTriggerfortype(this); + if(listener.exitRoutine_action) { + listener.exitRoutine_action(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggerfortype) { - return visitor.visitTriggerfortype(this); + if (visitor.visitRoutine_action) { + return visitor.visitRoutine_action(this); } else { return visitor.visitChildren(this); } @@ -85005,38 +59750,47 @@ export class TriggerfortypeContext extends antlr.ParserRuleContext { } -export class TriggerwhenContext extends antlr.ParserRuleContext { +export class CreategroupstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WHEN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WHEN, 0)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_GROUP(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_GROUP, 0)!; } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; + public rolespec(): RolespecContext { + return this.getRuleContext(0, RolespecContext)!; } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); + } + public createoptroleelem(): CreateoptroleelemContext[]; + public createoptroleelem(i: number): CreateoptroleelemContext | null; + public createoptroleelem(i?: number): CreateoptroleelemContext[] | CreateoptroleelemContext | null { + if (i === undefined) { + return this.getRuleContexts(CreateoptroleelemContext); + } + + return this.getRuleContext(i, CreateoptroleelemContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggerwhen; + return PostgreSqlParser.RULE_creategroupstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggerwhen) { - listener.enterTriggerwhen(this); + if(listener.enterCreategroupstmt) { + listener.enterCreategroupstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggerwhen) { - listener.exitTriggerwhen(this); + if(listener.exitCreategroupstmt) { + listener.exitCreategroupstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggerwhen) { - return visitor.visitTriggerwhen(this); + if (visitor.visitCreategroupstmt) { + return visitor.visitCreategroupstmt(this); } else { return visitor.visitChildren(this); } @@ -85044,38 +59798,47 @@ export class TriggerwhenContext extends antlr.ParserRuleContext { } -export class Function_or_procedureContext extends antlr.ParserRuleContext { +export class AltergroupstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public function_name(): Function_nameContext | null { - return this.getRuleContext(0, Function_nameContext); + public KW_GROUP(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_GROUP, 0)!; } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + public rolespec(): RolespecContext { + return this.getRuleContext(0, RolespecContext)!; } - public procedure_name(): Procedure_nameContext | null { - return this.getRuleContext(0, Procedure_nameContext); + public KW_USER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_USER, 0)!; + } + public role_list(): Role_listContext { + return this.getRuleContext(0, Role_listContext)!; + } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADD, 0); + } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_function_or_procedure; + return PostgreSqlParser.RULE_altergroupstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunction_or_procedure) { - listener.enterFunction_or_procedure(this); + if(listener.enterAltergroupstmt) { + listener.enterAltergroupstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunction_or_procedure) { - listener.exitFunction_or_procedure(this); + if(listener.exitAltergroupstmt) { + listener.exitAltergroupstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunction_or_procedure) { - return visitor.visitFunction_or_procedure(this); + if (visitor.visitAltergroupstmt) { + return visitor.visitAltergroupstmt(this); } else { return visitor.visitChildren(this); } @@ -85083,44 +59846,53 @@ export class Function_or_procedureContext extends antlr.ParserRuleContext { } -export class TriggerfuncargsContext extends antlr.ParserRuleContext { +export class CreateschemastmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public triggerfuncarg(): TriggerfuncargContext[]; - public triggerfuncarg(i: number): TriggerfuncargContext | null; - public triggerfuncarg(i?: number): TriggerfuncargContext[] | TriggerfuncargContext | null { + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + } + public KW_SCHEMA(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0)!; + } + public KW_AUTHORIZATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AUTHORIZATION, 0); + } + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); + } + public schema_name_create(): Schema_name_createContext | null { + return this.getRuleContext(0, Schema_name_createContext); + } + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); + } + public schema_stmt(): Schema_stmtContext[]; + public schema_stmt(i: number): Schema_stmtContext | null; + public schema_stmt(i?: number): Schema_stmtContext[] | Schema_stmtContext | null { if (i === undefined) { - return this.getRuleContexts(TriggerfuncargContext); + return this.getRuleContexts(Schema_stmtContext); } - return this.getRuleContext(i, TriggerfuncargContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + return this.getRuleContext(i, Schema_stmtContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggerfuncargs; + return PostgreSqlParser.RULE_createschemastmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggerfuncargs) { - listener.enterTriggerfuncargs(this); + if(listener.enterCreateschemastmt) { + listener.enterCreateschemastmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggerfuncargs) { - listener.exitTriggerfuncargs(this); + if(listener.exitCreateschemastmt) { + listener.exitCreateschemastmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggerfuncargs) { - return visitor.visitTriggerfuncargs(this); + if (visitor.visitCreateschemastmt) { + return visitor.visitCreateschemastmt(this); } else { return visitor.visitChildren(this); } @@ -85128,38 +59900,38 @@ export class TriggerfuncargsContext extends antlr.ParserRuleContext { } -export class TriggerfuncargContext extends antlr.ParserRuleContext { +export class Schema_name_createContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); - } - public fconst(): FconstContext | null { - return this.getRuleContext(0, FconstContext); + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_schema_name_create; } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); + public override copyFrom(ctx: Schema_name_createContext): void { + super.copyFrom(ctx); } - public collabel(): CollabelContext | null { - return this.getRuleContext(0, CollabelContext); +} +export class SchemaNameCreateContext extends Schema_name_createContext { + public constructor(ctx: Schema_name_createContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_triggerfuncarg; + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTriggerfuncarg) { - listener.enterTriggerfuncarg(this); + if(listener.enterSchemaNameCreate) { + listener.enterSchemaNameCreate(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTriggerfuncarg) { - listener.exitTriggerfuncarg(this); + if(listener.exitSchemaNameCreate) { + listener.exitSchemaNameCreate(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTriggerfuncarg) { - return visitor.visitTriggerfuncarg(this); + if (visitor.visitSchemaNameCreate) { + return visitor.visitSchemaNameCreate(this); } else { return visitor.visitChildren(this); } @@ -85167,32 +59939,44 @@ export class TriggerfuncargContext extends antlr.ParserRuleContext { } -export class OptconstrfromtableContext extends antlr.ParserRuleContext { +export class Schema_stmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FROM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FROM, 0)!; + public createstmt(): CreatestmtContext | null { + return this.getRuleContext(0, CreatestmtContext); } - public qualified_name(): Qualified_nameContext { - return this.getRuleContext(0, Qualified_nameContext)!; + public indexstmt(): IndexstmtContext | null { + return this.getRuleContext(0, IndexstmtContext); + } + public createseqstmt(): CreateseqstmtContext | null { + return this.getRuleContext(0, CreateseqstmtContext); + } + public createtrigstmt(): CreatetrigstmtContext | null { + return this.getRuleContext(0, CreatetrigstmtContext); + } + public grantstmt(): GrantstmtContext | null { + return this.getRuleContext(0, GrantstmtContext); + } + public viewstmt(): ViewstmtContext | null { + return this.getRuleContext(0, ViewstmtContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_optconstrfromtable; + return PostgreSqlParser.RULE_schema_stmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOptconstrfromtable) { - listener.enterOptconstrfromtable(this); + if(listener.enterSchema_stmt) { + listener.enterSchema_stmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOptconstrfromtable) { - listener.exitOptconstrfromtable(this); + if(listener.exitSchema_stmt) { + listener.exitSchema_stmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOptconstrfromtable) { - return visitor.visitOptconstrfromtable(this); + if (visitor.visitSchema_stmt) { + return visitor.visitSchema_stmt(this); } else { return visitor.visitChildren(this); } @@ -85200,35 +59984,38 @@ export class OptconstrfromtableContext extends antlr.ParserRuleContext { } -export class ConstraintattributespecContext extends antlr.ParserRuleContext { +export class VariablesetstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public constraintattributeElem(): ConstraintattributeElemContext[]; - public constraintattributeElem(i: number): ConstraintattributeElemContext | null; - public constraintattributeElem(i?: number): ConstraintattributeElemContext[] | ConstraintattributeElemContext | null { - if (i === undefined) { - return this.getRuleContexts(ConstraintattributeElemContext); - } - - return this.getRuleContext(i, ConstraintattributeElemContext); + public KW_SET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SET, 0)!; + } + public set_rest(): Set_restContext { + return this.getRuleContext(0, Set_restContext)!; + } + public KW_LOCAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LOCAL, 0); + } + public KW_SESSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SESSION, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_constraintattributespec; + return PostgreSqlParser.RULE_variablesetstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterConstraintattributespec) { - listener.enterConstraintattributespec(this); + if(listener.enterVariablesetstmt) { + listener.enterVariablesetstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitConstraintattributespec) { - listener.exitConstraintattributespec(this); + if(listener.exitVariablesetstmt) { + listener.exitVariablesetstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitConstraintattributespec) { - return visitor.visitConstraintattributespec(this); + if (visitor.visitVariablesetstmt) { + return visitor.visitVariablesetstmt(this); } else { return visitor.visitChildren(this); } @@ -85236,50 +60023,44 @@ export class ConstraintattributespecContext extends antlr.ParserRuleContext { } -export class ConstraintattributeElemContext extends antlr.ParserRuleContext { +export class Set_restContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); - } - public KW_DEFERRABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFERRABLE, 0); - } - public KW_INITIALLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INITIALLY, 0); + public KW_TRANSACTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); } - public KW_IMMEDIATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IMMEDIATE, 0); + public transaction_mode_list(): Transaction_mode_listContext | null { + return this.getRuleContext(0, Transaction_mode_listContext); } - public KW_DEFERRED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFERRED, 0); + public KW_SESSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SESSION, 0); } - public KW_VALID(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALID, 0); + public KW_CHARACTERISTICS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CHARACTERISTICS, 0); } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } - public KW_INHERIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INHERIT, 0); + public set_rest_more(): Set_rest_moreContext | null { + return this.getRuleContext(0, Set_rest_moreContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_constraintattributeElem; + return PostgreSqlParser.RULE_set_rest; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterConstraintattributeElem) { - listener.enterConstraintattributeElem(this); + if(listener.enterSet_rest) { + listener.enterSet_rest(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitConstraintattributeElem) { - listener.exitConstraintattributeElem(this); + if(listener.exitSet_rest) { + listener.exitSet_rest(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitConstraintattributeElem) { - return visitor.visitConstraintattributeElem(this); + if (visitor.visitSet_rest) { + return visitor.visitSet_rest(this); } else { return visitor.visitChildren(this); } @@ -85287,62 +60068,44 @@ export class ConstraintattributeElemContext extends antlr.ParserRuleContext { } -export class CreateeventtrigstmtContext extends antlr.ParserRuleContext { +export class Generic_setContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_EVENT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EVENT, 0)!; - } - public KW_TRIGGER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; - } - public collabel(): CollabelContext { - return this.getRuleContext(0, CollabelContext)!; - } - public KW_EXECUTE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXECUTE, 0)!; + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public function_or_procedure(): Function_or_procedureContext { - return this.getRuleContext(0, Function_or_procedureContext)!; + public var_name(): Var_nameContext | null { + return this.getRuleContext(0, Var_nameContext); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public var_list(): Var_listContext | null { + return this.getRuleContext(0, Var_listContext); } - public KW_WHEN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WHEN, 0); + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } - public event_trigger_when_list(): Event_trigger_when_listContext | null { - return this.getRuleContext(0, Event_trigger_when_listContext); + public EQUAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.EQUAL, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createeventtrigstmt; + return PostgreSqlParser.RULE_generic_set; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateeventtrigstmt) { - listener.enterCreateeventtrigstmt(this); + if(listener.enterGeneric_set) { + listener.enterGeneric_set(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateeventtrigstmt) { - listener.exitCreateeventtrigstmt(this); + if(listener.exitGeneric_set) { + listener.exitGeneric_set(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateeventtrigstmt) { - return visitor.visitCreateeventtrigstmt(this); + if (visitor.visitGeneric_set) { + return visitor.visitGeneric_set(this); } else { return visitor.visitChildren(this); } @@ -85350,86 +60113,92 @@ export class CreateeventtrigstmtContext extends antlr.ParserRuleContext { } -export class Event_trigger_when_listContext extends antlr.ParserRuleContext { +export class Set_rest_moreContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public event_trigger_when_item(): Event_trigger_when_itemContext[]; - public event_trigger_when_item(i: number): Event_trigger_when_itemContext | null; - public event_trigger_when_item(i?: number): Event_trigger_when_itemContext[] | Event_trigger_when_itemContext | null { - if (i === undefined) { - return this.getRuleContexts(Event_trigger_when_itemContext); - } - - return this.getRuleContext(i, Event_trigger_when_itemContext); + public KW_TIME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TIME, 0); } - public KW_AND(): antlr.TerminalNode[]; - public KW_AND(i: number): antlr.TerminalNode | null; - public KW_AND(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_AND); - } else { - return this.getToken(PostgreSqlParser.KW_AND, i); - } + public KW_ZONE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ZONE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_event_trigger_when_list; + public zone_value(): Zone_valueContext | null { + return this.getRuleContext(0, Zone_valueContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterEvent_trigger_when_list) { - listener.enterEvent_trigger_when_list(this); - } + public KW_CATALOG(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CATALOG, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitEvent_trigger_when_list) { - listener.exitEvent_trigger_when_list(this); - } + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitEvent_trigger_when_list) { - return visitor.visitEvent_trigger_when_list(this); - } else { - return visitor.visitChildren(this); - } + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); } -} - - -export class Event_trigger_when_itemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public schema_name(): Schema_nameContext | null { + return this.getRuleContext(0, Schema_nameContext); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; + public KW_NAMES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NAMES, 0); } - public KW_IN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_IN, 0)!; + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLE, 0); } - public event_trigger_value_list(): Event_trigger_value_listContext { - return this.getRuleContext(0, Event_trigger_value_listContext)!; + public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | null { + return this.getRuleContext(0, Nonreservedword_or_sconstContext); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public KW_SESSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SESSION, 0); + } + public KW_AUTHORIZATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AUTHORIZATION, 0); + } + public KW_XML(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XML, 0); + } + public KW_OPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPTION, 0); + } + public document_or_content(): Document_or_contentContext | null { + return this.getRuleContext(0, Document_or_contentContext); + } + public KW_TRANSACTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); + } + public KW_SNAPSHOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SNAPSHOT, 0); + } + public var_name(): Var_nameContext | null { + return this.getRuleContext(0, Var_nameContext); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); + } + public KW_CURRENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT, 0); + } + public generic_set(): Generic_setContext | null { + return this.getRuleContext(0, Generic_setContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_event_trigger_when_item; + return PostgreSqlParser.RULE_set_rest_more; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterEvent_trigger_when_item) { - listener.enterEvent_trigger_when_item(this); + if(listener.enterSet_rest_more) { + listener.enterSet_rest_more(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitEvent_trigger_when_item) { - listener.exitEvent_trigger_when_item(this); + if(listener.exitSet_rest_more) { + listener.exitSet_rest_more(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitEvent_trigger_when_item) { - return visitor.visitEvent_trigger_when_item(this); + if (visitor.visitSet_rest_more) { + return visitor.visitSet_rest_more(this); } else { return visitor.visitChildren(this); } @@ -85437,44 +60206,44 @@ export class Event_trigger_when_itemContext extends antlr.ParserRuleContext { } -export class Event_trigger_value_listContext extends antlr.ParserRuleContext { +export class Var_nameContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public sconst(): SconstContext[]; - public sconst(i: number): SconstContext | null; - public sconst(i?: number): SconstContext[] | SconstContext | null { + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { if (i === undefined) { - return this.getRuleContexts(SconstContext); + return this.getRuleContexts(ColidContext); } - return this.getRuleContext(i, SconstContext); + return this.getRuleContext(i, ColidContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); + return this.getTokens(PostgreSqlParser.DOT); } else { - return this.getToken(PostgreSqlParser.COMMA, i); + return this.getToken(PostgreSqlParser.DOT, i); } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_event_trigger_value_list; + return PostgreSqlParser.RULE_var_name; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterEvent_trigger_value_list) { - listener.enterEvent_trigger_value_list(this); + if(listener.enterVar_name) { + listener.enterVar_name(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitEvent_trigger_value_list) { - listener.exitEvent_trigger_value_list(this); + if(listener.exitVar_name) { + listener.exitVar_name(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitEvent_trigger_value_list) { - return visitor.visitEvent_trigger_value_list(this); + if (visitor.visitVar_name) { + return visitor.visitVar_name(this); } else { return visitor.visitChildren(this); } @@ -85482,80 +60251,44 @@ export class Event_trigger_value_listContext extends antlr.ParserRuleContext { } -export class AltereventtrigstmtContext extends antlr.ParserRuleContext { +export class Var_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_EVENT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EVENT, 0)!; - } - public KW_TRIGGER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public enable_trigger(): Enable_triggerContext { - return this.getRuleContext(0, Enable_triggerContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_altereventtrigstmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAltereventtrigstmt) { - listener.enterAltereventtrigstmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAltereventtrigstmt) { - listener.exitAltereventtrigstmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAltereventtrigstmt) { - return visitor.visitAltereventtrigstmt(this); - } else { - return visitor.visitChildren(this); + public var_value(): Var_valueContext[]; + public var_value(i: number): Var_valueContext | null; + public var_value(i?: number): Var_valueContext[] | Var_valueContext | null { + if (i === undefined) { + return this.getRuleContexts(Var_valueContext); } - } -} - -export class Enable_triggerContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ENABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ENABLE, 0); - } - public KW_REPLICA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REPLICA, 0); - } - public KW_ALWAYS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALWAYS, 0); + return this.getRuleContext(i, Var_valueContext); } - public KW_DISABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DISABLE, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_enable_trigger; + return PostgreSqlParser.RULE_var_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterEnable_trigger) { - listener.enterEnable_trigger(this); + if(listener.enterVar_list) { + listener.enterVar_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitEnable_trigger) { - listener.exitEnable_trigger(this); + if(listener.exitVar_list) { + listener.exitVar_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitEnable_trigger) { - return visitor.visitEnable_trigger(this); + if (visitor.visitVar_list) { + return visitor.visitVar_list(this); } else { return visitor.visitChildren(this); } @@ -85563,50 +60296,32 @@ export class Enable_triggerContext extends antlr.ParserRuleContext { } -export class CreateassertionstmtContext extends antlr.ParserRuleContext { +export class Var_valueContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_ASSERTION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ASSERTION, 0)!; - } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; - } - public KW_CHECK(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CHECK, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public opt_boolean_or_string(): Opt_boolean_or_stringContext | null { + return this.getRuleContext(0, Opt_boolean_or_stringContext); } - public constraintattributespec(): ConstraintattributespecContext { - return this.getRuleContext(0, ConstraintattributespecContext)!; + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createassertionstmt; + return PostgreSqlParser.RULE_var_value; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateassertionstmt) { - listener.enterCreateassertionstmt(this); + if(listener.enterVar_value) { + listener.enterVar_value(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateassertionstmt) { - listener.exitCreateassertionstmt(this); + if(listener.exitVar_value) { + listener.exitVar_value(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateassertionstmt) { - return visitor.visitCreateassertionstmt(this); + if (visitor.visitVar_value) { + return visitor.visitVar_value(this); } else { return visitor.visitChildren(this); } @@ -85614,113 +60329,41 @@ export class CreateassertionstmtContext extends antlr.ParserRuleContext { } -export class DefinestmtContext extends antlr.ParserRuleContext { +export class Iso_levelContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_AGGREGATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); - } - public function_name(): Function_nameContext | null { - return this.getRuleContext(0, Function_nameContext); - } - public aggr_args(): Aggr_argsContext | null { - return this.getRuleContext(0, Aggr_argsContext); - } - public definition(): DefinitionContext | null { - return this.getRuleContext(0, DefinitionContext); - } - public opt_or_replace(): Opt_or_replaceContext | null { - return this.getRuleContext(0, Opt_or_replaceContext); - } - public old_aggr_definition(): Old_aggr_definitionContext | null { - return this.getRuleContext(0, Old_aggr_definitionContext); - } - public KW_OPERATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); - } - public any_operator(): Any_operatorContext | null { - return this.getRuleContext(0, Any_operatorContext); - } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); - } - public any_name(): Any_nameContext[]; - public any_name(i: number): Any_nameContext | null; - public any_name(i?: number): Any_nameContext[] | Any_nameContext | null { - if (i === undefined) { - return this.getRuleContexts(Any_nameContext); - } - - return this.getRuleContext(i, Any_nameContext); - } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public opttablefuncelementlist(): OpttablefuncelementlistContext | null { - return this.getRuleContext(0, OpttablefuncelementlistContext); - } - public KW_ENUM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ENUM, 0); - } - public opt_enum_val_list(): Opt_enum_val_listContext | null { - return this.getRuleContext(0, Opt_enum_val_listContext); - } - public KW_RANGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RANGE, 0); - } - public KW_TEXT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEXT, 0); - } - public KW_SEARCH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEARCH, 0); - } - public KW_PARSER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARSER, 0); - } - public KW_DICTIONARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); - } - public KW_TEMPLATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); + public KW_READ(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_READ, 0); } - public KW_CONFIGURATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); + public KW_UNCOMMITTED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNCOMMITTED, 0); } - public KW_COLLATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLLATION, 0); + public KW_COMMITTED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COMMITTED, 0); } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); + public KW_REPEATABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REPEATABLE, 0); } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); + public KW_SERIALIZABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SERIALIZABLE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_definestmt; + return PostgreSqlParser.RULE_iso_level; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDefinestmt) { - listener.enterDefinestmt(this); + if(listener.enterIso_level) { + listener.enterIso_level(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDefinestmt) { - listener.exitDefinestmt(this); + if(listener.exitIso_level) { + listener.exitIso_level(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDefinestmt) { - return visitor.visitDefinestmt(this); + if (visitor.visitIso_level) { + return visitor.visitIso_level(this); } else { return visitor.visitChildren(this); } @@ -85728,35 +60371,44 @@ export class DefinestmtContext extends antlr.ParserRuleContext { } -export class DefinitionContext extends antlr.ParserRuleContext { +export class Opt_boolean_or_string_columnContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_TRUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRUE, 0); } - public def_list(): Def_listContext { - return this.getRuleContext(0, Def_listContext)!; + public KW_FALSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FALSE, 0); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ON, 0); + } + public column_name(): Column_nameContext | null { + return this.getRuleContext(0, Column_nameContext); + } + public type_func_name_keyword(): Type_func_name_keywordContext | null { + return this.getRuleContext(0, Type_func_name_keywordContext); + } + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_definition; + return PostgreSqlParser.RULE_opt_boolean_or_string_column; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDefinition) { - listener.enterDefinition(this); + if(listener.enterOpt_boolean_or_string_column) { + listener.enterOpt_boolean_or_string_column(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDefinition) { - listener.exitDefinition(this); + if(listener.exitOpt_boolean_or_string_column) { + listener.exitOpt_boolean_or_string_column(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDefinition) { - return visitor.visitDefinition(this); + if (visitor.visitOpt_boolean_or_string_column) { + return visitor.visitOpt_boolean_or_string_column(this); } else { return visitor.visitChildren(this); } @@ -85764,44 +60416,38 @@ export class DefinitionContext extends antlr.ParserRuleContext { } -export class Def_listContext extends antlr.ParserRuleContext { +export class Opt_boolean_or_stringContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public def_elem(): Def_elemContext[]; - public def_elem(i: number): Def_elemContext | null; - public def_elem(i?: number): Def_elemContext[] | Def_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Def_elemContext); - } - - return this.getRuleContext(i, Def_elemContext); + public KW_TRUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRUE, 0); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_FALSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FALSE, 0); + } + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ON, 0); + } + public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | null { + return this.getRuleContext(0, Nonreservedword_or_sconstContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_def_list; + return PostgreSqlParser.RULE_opt_boolean_or_string; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDef_list) { - listener.enterDef_list(this); + if(listener.enterOpt_boolean_or_string) { + listener.enterOpt_boolean_or_string(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDef_list) { - listener.exitDef_list(this); + if(listener.exitOpt_boolean_or_string) { + listener.exitOpt_boolean_or_string(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDef_list) { - return visitor.visitDef_list(this); + if (visitor.visitOpt_boolean_or_string) { + return visitor.visitOpt_boolean_or_string(this); } else { return visitor.visitChildren(this); } @@ -85809,35 +60455,50 @@ export class Def_listContext extends antlr.ParserRuleContext { } -export class Def_elemContext extends antlr.ParserRuleContext { +export class Zone_valueContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public collabel(): CollabelContext { - return this.getRuleContext(0, CollabelContext)!; + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } - public EQUAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.EQUAL, 0); + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } - public def_arg(): Def_argContext | null { - return this.getRuleContext(0, Def_argContext); + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public KW_INTERVAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INTERVAL, 0); + } + public opt_interval(): Opt_intervalContext | null { + return this.getRuleContext(0, Opt_intervalContext); + } + public opt_float(): Opt_floatContext | null { + return this.getRuleContext(0, Opt_floatContext); + } + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); + } + public KW_LOCAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LOCAL, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_def_elem; + return PostgreSqlParser.RULE_zone_value; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDef_elem) { - listener.enterDef_elem(this); + if(listener.enterZone_value) { + listener.enterZone_value(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDef_elem) { - listener.exitDef_elem(this); + if(listener.exitZone_value) { + listener.exitZone_value(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDef_elem) { - return visitor.visitDef_elem(this); + if (visitor.visitZone_value) { + return visitor.visitZone_value(this); } else { return visitor.visitChildren(this); } @@ -85845,44 +60506,32 @@ export class Def_elemContext extends antlr.ParserRuleContext { } -export class Def_argContext extends antlr.ParserRuleContext { +export class Nonreservedword_or_sconstContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public func_type(): Func_typeContext | null { - return this.getRuleContext(0, Func_typeContext); - } - public reserved_keyword(): Reserved_keywordContext | null { - return this.getRuleContext(0, Reserved_keywordContext); - } - public qual_all_op(): Qual_all_opContext | null { - return this.getRuleContext(0, Qual_all_opContext); - } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); + public nonreservedword(): NonreservedwordContext | null { + return this.getRuleContext(0, NonreservedwordContext); } public sconst(): SconstContext | null { return this.getRuleContext(0, SconstContext); } - public KW_NONE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NONE, 0); - } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_def_arg; + return PostgreSqlParser.RULE_nonreservedword_or_sconst; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDef_arg) { - listener.enterDef_arg(this); + if(listener.enterNonreservedword_or_sconst) { + listener.enterNonreservedword_or_sconst(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDef_arg) { - listener.exitDef_arg(this); + if(listener.exitNonreservedword_or_sconst) { + listener.exitNonreservedword_or_sconst(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDef_arg) { - return visitor.visitDef_arg(this); + if (visitor.visitNonreservedword_or_sconst) { + return visitor.visitNonreservedword_or_sconst(this); } else { return visitor.visitChildren(this); } @@ -85890,35 +60539,32 @@ export class Def_argContext extends antlr.ParserRuleContext { } -export class Old_aggr_definitionContext extends antlr.ParserRuleContext { +export class VariableresetstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public old_aggr_list(): Old_aggr_listContext { - return this.getRuleContext(0, Old_aggr_listContext)!; + public KW_RESET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_RESET, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public reset_rest(): Reset_restContext { + return this.getRuleContext(0, Reset_restContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_old_aggr_definition; + return PostgreSqlParser.RULE_variableresetstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOld_aggr_definition) { - listener.enterOld_aggr_definition(this); + if(listener.enterVariableresetstmt) { + listener.enterVariableresetstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOld_aggr_definition) { - listener.exitOld_aggr_definition(this); + if(listener.exitVariableresetstmt) { + listener.exitVariableresetstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOld_aggr_definition) { - return visitor.visitOld_aggr_definition(this); + if (visitor.visitVariableresetstmt) { + return visitor.visitVariableresetstmt(this); } else { return visitor.visitChildren(this); } @@ -85926,44 +60572,53 @@ export class Old_aggr_definitionContext extends antlr.ParserRuleContext { } -export class Old_aggr_listContext extends antlr.ParserRuleContext { +export class Reset_restContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public old_aggr_elem(): Old_aggr_elemContext[]; - public old_aggr_elem(i: number): Old_aggr_elemContext | null; - public old_aggr_elem(i?: number): Old_aggr_elemContext[] | Old_aggr_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Old_aggr_elemContext); - } - - return this.getRuleContext(i, Old_aggr_elemContext); + public KW_TIME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TIME, 0); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_ZONE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ZONE, 0); + } + public KW_TRANSACTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); + } + public KW_ISOLATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ISOLATION, 0); + } + public KW_LEVEL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LEVEL, 0); + } + public KW_SESSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SESSION, 0); + } + public KW_AUTHORIZATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AUTHORIZATION, 0); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); + } + public var_name(): Var_nameContext | null { + return this.getRuleContext(0, Var_nameContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_old_aggr_list; + return PostgreSqlParser.RULE_reset_rest; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOld_aggr_list) { - listener.enterOld_aggr_list(this); + if(listener.enterReset_rest) { + listener.enterReset_rest(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOld_aggr_list) { - listener.exitOld_aggr_list(this); + if(listener.exitReset_rest) { + listener.exitReset_rest(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOld_aggr_list) { - return visitor.visitOld_aggr_list(this); + if (visitor.visitReset_rest) { + return visitor.visitReset_rest(this); } else { return visitor.visitChildren(this); } @@ -85971,35 +60626,35 @@ export class Old_aggr_listContext extends antlr.ParserRuleContext { } -export class Old_aggr_elemContext extends antlr.ParserRuleContext { +export class SetresetclauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public identifier(): IdentifierContext { - return this.getRuleContext(0, IdentifierContext)!; + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public EQUAL(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.EQUAL, 0)!; + public set_rest(): Set_restContext | null { + return this.getRuleContext(0, Set_restContext); } - public def_arg(): Def_argContext { - return this.getRuleContext(0, Def_argContext)!; + public variableresetstmt(): VariableresetstmtContext | null { + return this.getRuleContext(0, VariableresetstmtContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_old_aggr_elem; + return PostgreSqlParser.RULE_setresetclause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOld_aggr_elem) { - listener.enterOld_aggr_elem(this); + if(listener.enterSetresetclause) { + listener.enterSetresetclause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOld_aggr_elem) { - listener.exitOld_aggr_elem(this); + if(listener.exitSetresetclause) { + listener.exitSetresetclause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOld_aggr_elem) { - return visitor.visitOld_aggr_elem(this); + if (visitor.visitSetresetclause) { + return visitor.visitSetresetclause(this); } else { return visitor.visitChildren(this); } @@ -86007,29 +60662,35 @@ export class Old_aggr_elemContext extends antlr.ParserRuleContext { } -export class Opt_enum_val_listContext extends antlr.ParserRuleContext { +export class FunctionsetresetclauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public enum_val_list(): Enum_val_listContext { - return this.getRuleContext(0, Enum_val_listContext)!; + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); + } + public set_rest_more(): Set_rest_moreContext | null { + return this.getRuleContext(0, Set_rest_moreContext); + } + public variableresetstmt(): VariableresetstmtContext | null { + return this.getRuleContext(0, VariableresetstmtContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_enum_val_list; + return PostgreSqlParser.RULE_functionsetresetclause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_enum_val_list) { - listener.enterOpt_enum_val_list(this); + if(listener.enterFunctionsetresetclause) { + listener.enterFunctionsetresetclause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_enum_val_list) { - listener.exitOpt_enum_val_list(this); + if(listener.exitFunctionsetresetclause) { + listener.exitFunctionsetresetclause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_enum_val_list) { - return visitor.visitOpt_enum_val_list(this); + if (visitor.visitFunctionsetresetclause) { + return visitor.visitFunctionsetresetclause(this); } else { return visitor.visitChildren(this); } @@ -86037,44 +60698,56 @@ export class Opt_enum_val_listContext extends antlr.ParserRuleContext { } -export class Enum_val_listContext extends antlr.ParserRuleContext { +export class VariableshowstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public sconst(): SconstContext[]; - public sconst(i: number): SconstContext | null; - public sconst(i?: number): SconstContext[] | SconstContext | null { - if (i === undefined) { - return this.getRuleContexts(SconstContext); - } - - return this.getRuleContext(i, SconstContext); + public KW_SHOW(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SHOW, 0)!; } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public var_name(): Var_nameContext | null { + return this.getRuleContext(0, Var_nameContext); + } + public KW_TIME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TIME, 0); + } + public KW_ZONE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ZONE, 0); + } + public KW_TRANSACTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); + } + public KW_ISOLATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ISOLATION, 0); + } + public KW_LEVEL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LEVEL, 0); + } + public KW_SESSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SESSION, 0); + } + public KW_AUTHORIZATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AUTHORIZATION, 0); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_enum_val_list; + return PostgreSqlParser.RULE_variableshowstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterEnum_val_list) { - listener.enterEnum_val_list(this); + if(listener.enterVariableshowstmt) { + listener.enterVariableshowstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitEnum_val_list) { - listener.exitEnum_val_list(this); + if(listener.exitVariableshowstmt) { + listener.exitVariableshowstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitEnum_val_list) { - return visitor.visitEnum_val_list(this); + if (visitor.visitVariableshowstmt) { + return visitor.visitVariableshowstmt(this); } else { return visitor.visitChildren(this); } @@ -86082,65 +60755,44 @@ export class Enum_val_listContext extends antlr.ParserRuleContext { } -export class AlterenumstmtContext extends antlr.ParserRuleContext { +export class ConstraintssetstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_TYPE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TYPE, 0)!; - } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; - } - public KW_ADD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADD, 0); - } - public KW_VALUE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VALUE, 0)!; - } - public sconst(): SconstContext[]; - public sconst(i: number): SconstContext | null; - public sconst(i?: number): SconstContext[] | SconstContext | null { - if (i === undefined) { - return this.getRuleContexts(SconstContext); - } - - return this.getRuleContext(i, SconstContext); + public KW_SET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SET, 0)!; } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); + public KW_CONSTRAINTS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CONSTRAINTS, 0)!; } - public KW_BEFORE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BEFORE, 0); + public KW_DEFERRED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFERRED, 0); } - public KW_AFTER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AFTER, 0); + public KW_IMMEDIATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IMMEDIATE, 0); } - public KW_RENAME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RENAME, 0); + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); + public qualified_name_list(): Qualified_name_listContext | null { + return this.getRuleContext(0, Qualified_name_listContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterenumstmt; + return PostgreSqlParser.RULE_constraintssetstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterenumstmt) { - listener.enterAlterenumstmt(this); + if(listener.enterConstraintssetstmt) { + listener.enterConstraintssetstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterenumstmt) { - listener.exitAlterenumstmt(this); + if(listener.exitConstraintssetstmt) { + listener.exitConstraintssetstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterenumstmt) { - return visitor.visitAlterenumstmt(this); + if (visitor.visitConstraintssetstmt) { + return visitor.visitConstraintssetstmt(this); } else { return visitor.visitChildren(this); } @@ -86148,35 +60800,29 @@ export class AlterenumstmtContext extends antlr.ParserRuleContext { } -export class Opt_if_not_existsContext extends antlr.ParserRuleContext { +export class CheckpointstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_IF(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_IF, 0)!; - } - public KW_NOT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_NOT, 0)!; - } - public KW_EXISTS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXISTS, 0)!; + public KW_CHECKPOINT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CHECKPOINT, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_if_not_exists; + return PostgreSqlParser.RULE_checkpointstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_if_not_exists) { - listener.enterOpt_if_not_exists(this); + if(listener.enterCheckpointstmt) { + listener.enterCheckpointstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_if_not_exists) { - listener.exitOpt_if_not_exists(this); + if(listener.exitCheckpointstmt) { + listener.exitCheckpointstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_if_not_exists) { - return visitor.visitOpt_if_not_exists(this); + if (visitor.visitCheckpointstmt) { + return visitor.visitCheckpointstmt(this); } else { return visitor.visitChildren(this); } @@ -86184,65 +60830,44 @@ export class Opt_if_not_existsContext extends antlr.ParserRuleContext { } -export class CreateopclassstmtContext extends antlr.ParserRuleContext { +export class DiscardstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_OPERATOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0)!; - } - public KW_CLASS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CLASS, 0)!; - } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; - } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; - } - public KW_TYPE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TYPE, 0)!; - } - public typename(): TypenameContext { - return this.getRuleContext(0, TypenameContext)!; - } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; + public KW_DISCARD(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DISCARD, 0)!; } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; + public KW_TEMP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMP, 0); } - public opclass_item_list(): Opclass_item_listContext { - return this.getRuleContext(0, Opclass_item_listContext)!; + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPORARY, 0); } - public opt_default(): Opt_defaultContext | null { - return this.getRuleContext(0, Opt_defaultContext); + public KW_PLANS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PLANS, 0); } - public opt_opfamily(): Opt_opfamilyContext | null { - return this.getRuleContext(0, Opt_opfamilyContext); + public KW_SEQUENCES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCES, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createopclassstmt; + return PostgreSqlParser.RULE_discardstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateopclassstmt) { - listener.enterCreateopclassstmt(this); + if(listener.enterDiscardstmt) { + listener.enterDiscardstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateopclassstmt) { - listener.exitCreateopclassstmt(this); + if(listener.exitDiscardstmt) { + listener.exitDiscardstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateopclassstmt) { - return visitor.visitCreateopclassstmt(this); + if (visitor.visitDiscardstmt) { + return visitor.visitDiscardstmt(this); } else { return visitor.visitChildren(this); } @@ -86250,140 +60875,131 @@ export class CreateopclassstmtContext extends antlr.ParserRuleContext { } -export class Opclass_item_listContext extends antlr.ParserRuleContext { +export class AltertablestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public opclass_item(): Opclass_itemContext[]; - public opclass_item(i: number): Opclass_itemContext | null; - public opclass_item(i?: number): Opclass_itemContext[] | Opclass_itemContext | null { + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); + } + public relation_expr(): Relation_exprContext | null { + return this.getRuleContext(0, Relation_exprContext); + } + public alter_table_cmds(): Alter_table_cmdsContext | null { + return this.getRuleContext(0, Alter_table_cmdsContext); + } + public partition_cmd(): Partition_cmdContext | null { + return this.getRuleContext(0, Partition_cmdContext); + } + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); + } + public opttablespace(): OpttablespaceContext[]; + public opttablespace(i: number): OpttablespaceContext | null; + public opttablespace(i?: number): OpttablespaceContext[] | OpttablespaceContext | null { if (i === undefined) { - return this.getRuleContexts(Opclass_itemContext); + return this.getRuleContexts(OpttablespaceContext); } - return this.getRuleContext(i, Opclass_itemContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + return this.getRuleContext(i, OpttablespaceContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opclass_item_list; + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpclass_item_list) { - listener.enterOpclass_item_list(this); - } + public KW_TABLESPACE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpclass_item_list) { - listener.exitOpclass_item_list(this); - } + public tablespace_name_create(): Tablespace_name_createContext | null { + return this.getRuleContext(0, Tablespace_name_createContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpclass_item_list) { - return visitor.visitOpclass_item_list(this); - } else { - return visitor.visitChildren(this); - } + public KW_OWNED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OWNED, 0); } -} - - -export class Opclass_itemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BY, 0); } - public KW_OPERATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); + public role_list(): Role_listContext | null { + return this.getRuleContext(0, Role_listContext); } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); + public KW_NOWAIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOWAIT, 0); } - public any_operator(): Any_operatorContext | null { - return this.getRuleContext(0, Any_operatorContext); + public table_name(): Table_nameContext | null { + return this.getRuleContext(0, Table_nameContext); } - public opclass_purpose(): Opclass_purposeContext | null { - return this.getRuleContext(0, Opclass_purposeContext); + public index_partition_cmd(): Index_partition_cmdContext | null { + return this.getRuleContext(0, Index_partition_cmdContext); } - public opt_recheck(): Opt_recheckContext | null { - return this.getRuleContext(0, Opt_recheckContext); + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } - public operator_with_argtypes(): Operator_with_argtypesContext | null { - return this.getRuleContext(0, Operator_with_argtypesContext); + public KW_VALUES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALUES, 0); } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + public partition_bound_spec(): Partition_bound_specContext | null { + return this.getRuleContext(0, Partition_bound_specContext); } - public function_with_argtypes(): Function_with_argtypesContext | null { - return this.getRuleContext(0, Function_with_argtypesContext); + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_DETACH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DETACH, 0); } - public type_list(): Type_listContext | null { - return this.getRuleContext(0, Type_listContext); + public KW_PARTITION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARTITION, 0); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } - public KW_STORAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STORAGE, 0); + public KW_CONCURRENTLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONCURRENTLY, 0); } - public typename(): TypenameContext | null { - return this.getRuleContext(0, TypenameContext); + public KW_FINALIZE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FINALIZE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opclass_item; + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INDEX, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpclass_item) { - listener.enterOpclass_item(this); - } + public KW_SEQUENCE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpclass_item) { - listener.exitOpclass_item(this); - } + public KW_VIEW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VIEW, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpclass_item) { - return visitor.visitOpclass_item(this); - } else { - return visitor.visitChildren(this); - } + public view_name(): View_nameContext | null { + return this.getRuleContext(0, View_nameContext); } -} - - -export class Opt_defaultContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_MATERIALIZED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); } - public KW_DEFAULT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0)!; + public KW_FOREIGN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_default; + return PostgreSqlParser.RULE_altertablestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_default) { - listener.enterOpt_default(this); + if(listener.enterAltertablestmt) { + listener.enterAltertablestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_default) { - listener.exitOpt_default(this); + if(listener.exitAltertablestmt) { + listener.exitAltertablestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_default) { - return visitor.visitOpt_default(this); + if (visitor.visitAltertablestmt) { + return visitor.visitAltertablestmt(this); } else { return visitor.visitChildren(this); } @@ -86391,32 +61007,44 @@ export class Opt_defaultContext extends antlr.ParserRuleContext { } -export class Opt_opfamilyContext extends antlr.ParserRuleContext { +export class Alter_table_cmdsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FAMILY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FAMILY, 0)!; + public alter_table_cmd(): Alter_table_cmdContext[]; + public alter_table_cmd(i: number): Alter_table_cmdContext | null; + public alter_table_cmd(i?: number): Alter_table_cmdContext[] | Alter_table_cmdContext | null { + if (i === undefined) { + return this.getRuleContexts(Alter_table_cmdContext); + } + + return this.getRuleContext(i, Alter_table_cmdContext); } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_opfamily; + return PostgreSqlParser.RULE_alter_table_cmds; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_opfamily) { - listener.enterOpt_opfamily(this); + if(listener.enterAlter_table_cmds) { + listener.enterAlter_table_cmds(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_opfamily) { - listener.exitOpt_opfamily(this); + if(listener.exitAlter_table_cmds) { + listener.exitAlter_table_cmds(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_opfamily) { - return visitor.visitOpt_opfamily(this); + if (visitor.visitAlter_table_cmds) { + return visitor.visitAlter_table_cmds(this); } else { return visitor.visitChildren(this); } @@ -86424,71 +61052,53 @@ export class Opt_opfamilyContext extends antlr.ParserRuleContext { } -export class Opclass_purposeContext extends antlr.ParserRuleContext { +export class Partition_bound_specContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; - } - public KW_SEARCH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEARCH, 0); - } - public KW_ORDER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ORDER, 0); - } - public KW_BY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BY, 0); - } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opclass_purpose; + public execute_param_clause(): Execute_param_clauseContext | null { + return this.getRuleContext(0, Execute_param_clauseContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpclass_purpose) { - listener.enterOpclass_purpose(this); - } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpclass_purpose) { - listener.exitOpclass_purpose(this); + public partition_bound_cluase(): Partition_bound_cluaseContext[]; + public partition_bound_cluase(i: number): Partition_bound_cluaseContext | null; + public partition_bound_cluase(i?: number): Partition_bound_cluaseContext[] | Partition_bound_cluaseContext | null { + if (i === undefined) { + return this.getRuleContexts(Partition_bound_cluaseContext); } + + return this.getRuleContext(i, Partition_bound_cluaseContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpclass_purpose) { - return visitor.visitOpclass_purpose(this); - } else { - return visitor.visitChildren(this); - } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } -} - - -export class Opt_recheckContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public KW_RECHECK(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_RECHECK, 0)!; + public partition_with_cluase(): Partition_with_cluaseContext | null { + return this.getRuleContext(0, Partition_with_cluaseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_recheck; + return PostgreSqlParser.RULE_partition_bound_spec; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_recheck) { - listener.enterOpt_recheck(this); + if(listener.enterPartition_bound_spec) { + listener.enterPartition_bound_spec(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_recheck) { - listener.exitOpt_recheck(this); + if(listener.exitPartition_bound_spec) { + listener.exitPartition_bound_spec(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_recheck) { - return visitor.visitOpt_recheck(this); + if (visitor.visitPartition_bound_spec) { + return visitor.visitPartition_bound_spec(this); } else { return visitor.visitChildren(this); } @@ -86496,44 +61106,50 @@ export class Opt_recheckContext extends antlr.ParserRuleContext { } -export class CreateopfamilystmtContext extends antlr.ParserRuleContext { +export class Partition_bound_cluaseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_OPERATOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0)!; - } - public KW_FAMILY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FAMILY, 0)!; + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; + public partition_bound_choose(): Partition_bound_chooseContext[]; + public partition_bound_choose(i: number): Partition_bound_chooseContext | null; + public partition_bound_choose(i?: number): Partition_bound_chooseContext[] | Partition_bound_chooseContext | null { + if (i === undefined) { + return this.getRuleContexts(Partition_bound_chooseContext); + } + + return this.getRuleContext(i, Partition_bound_chooseContext); } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createopfamilystmt; + return PostgreSqlParser.RULE_partition_bound_cluase; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateopfamilystmt) { - listener.enterCreateopfamilystmt(this); + if(listener.enterPartition_bound_cluase) { + listener.enterPartition_bound_cluase(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateopfamilystmt) { - listener.exitCreateopfamilystmt(this); + if(listener.exitPartition_bound_cluase) { + listener.exitPartition_bound_cluase(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateopfamilystmt) { - return visitor.visitCreateopfamilystmt(this); + if (visitor.visitPartition_bound_cluase) { + return visitor.visitPartition_bound_cluase(this); } else { return visitor.visitChildren(this); } @@ -86541,56 +61157,35 @@ export class CreateopfamilystmtContext extends antlr.ParserRuleContext { } -export class AlteropfamilystmtContext extends antlr.ParserRuleContext { +export class Partition_bound_chooseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_OPERATOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0)!; - } - public KW_FAMILY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FAMILY, 0)!; - } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; - } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public KW_ADD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADD, 0); - } - public opclass_item_list(): Opclass_item_listContext | null { - return this.getRuleContext(0, Opclass_item_listContext); + public execute_param_clause(): Execute_param_clauseContext | null { + return this.getRuleContext(0, Execute_param_clauseContext); } - public KW_DROP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DROP, 0); + public KW_MINVALUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MINVALUE, 0); } - public opclass_drop_list(): Opclass_drop_listContext | null { - return this.getRuleContext(0, Opclass_drop_listContext); + public KW_MAXVALUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MAXVALUE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alteropfamilystmt; + return PostgreSqlParser.RULE_partition_bound_choose; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlteropfamilystmt) { - listener.enterAlteropfamilystmt(this); + if(listener.enterPartition_bound_choose) { + listener.enterPartition_bound_choose(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlteropfamilystmt) { - listener.exitAlteropfamilystmt(this); + if(listener.exitPartition_bound_choose) { + listener.exitPartition_bound_choose(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlteropfamilystmt) { - return visitor.visitAlteropfamilystmt(this); + if (visitor.visitPartition_bound_choose) { + return visitor.visitPartition_bound_choose(this); } else { return visitor.visitChildren(this); } @@ -86598,44 +61193,50 @@ export class AlteropfamilystmtContext extends antlr.ParserRuleContext { } -export class Opclass_drop_listContext extends antlr.ParserRuleContext { +export class Partition_with_cluaseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public opclass_drop(): Opclass_dropContext[]; - public opclass_drop(i: number): Opclass_dropContext | null; - public opclass_drop(i?: number): Opclass_dropContext[] | Opclass_dropContext | null { + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + } + public KW_MODULUS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_MODULUS, 0)!; + } + public numericonly(): NumericonlyContext[]; + public numericonly(i: number): NumericonlyContext | null; + public numericonly(i?: number): NumericonlyContext[] | NumericonlyContext | null { if (i === undefined) { - return this.getRuleContexts(Opclass_dropContext); + return this.getRuleContexts(NumericonlyContext); } - return this.getRuleContext(i, Opclass_dropContext); + return this.getRuleContext(i, NumericonlyContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public COMMA(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.COMMA, 0)!; + } + public KW_REMAINDER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_REMAINDER, 0)!; + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opclass_drop_list; + return PostgreSqlParser.RULE_partition_with_cluase; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpclass_drop_list) { - listener.enterOpclass_drop_list(this); + if(listener.enterPartition_with_cluase) { + listener.enterPartition_with_cluase(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpclass_drop_list) { - listener.exitOpclass_drop_list(this); + if(listener.exitPartition_with_cluase) { + listener.exitPartition_with_cluase(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpclass_drop_list) { - return visitor.visitOpclass_drop_list(this); + if (visitor.visitPartition_with_cluase) { + return visitor.visitPartition_with_cluase(this); } else { return visitor.visitChildren(this); } @@ -86643,44 +61244,41 @@ export class Opclass_drop_listContext extends antlr.ParserRuleContext { } -export class Opclass_dropContext extends antlr.ParserRuleContext { +export class Partition_cmdContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_OPERATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); - } - public iconst(): IconstContext { - return this.getRuleContext(0, IconstContext)!; + public index_partition_cmd(): Index_partition_cmdContext | null { + return this.getRuleContext(0, Index_partition_cmdContext); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public partitionboundspec(): PartitionboundspecContext | null { + return this.getRuleContext(0, PartitionboundspecContext); } - public type_list(): Type_listContext { - return this.getRuleContext(0, Type_listContext)!; + public KW_DETACH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DETACH, 0); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public KW_PARTITION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARTITION, 0); } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opclass_drop; + return PostgreSqlParser.RULE_partition_cmd; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpclass_drop) { - listener.enterOpclass_drop(this); + if(listener.enterPartition_cmd) { + listener.enterPartition_cmd(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpclass_drop) { - listener.exitOpclass_drop(this); + if(listener.exitPartition_cmd) { + listener.exitPartition_cmd(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpclass_drop) { - return visitor.visitOpclass_drop(this); + if (visitor.visitPartition_cmd) { + return visitor.visitPartition_cmd(this); } else { return visitor.visitChildren(this); } @@ -86688,44 +61286,35 @@ export class Opclass_dropContext extends antlr.ParserRuleContext { } -export class ReassignownedstmtContext extends antlr.ParserRuleContext { +export class Index_partition_cmdContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_REASSIGN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_REASSIGN, 0)!; - } - public KW_OWNED(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OWNED, 0)!; - } - public KW_BY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BY, 0)!; - } - public role_list(): Role_listContext { - return this.getRuleContext(0, Role_listContext)!; + public KW_ATTACH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ATTACH, 0)!; } - public KW_TO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TO, 0)!; + public KW_PARTITION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_PARTITION, 0)!; } - public rolespec(): RolespecContext { - return this.getRuleContext(0, RolespecContext)!; + public qualified_name(): Qualified_nameContext { + return this.getRuleContext(0, Qualified_nameContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_reassignownedstmt; + return PostgreSqlParser.RULE_index_partition_cmd; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReassignownedstmt) { - listener.enterReassignownedstmt(this); + if(listener.enterIndex_partition_cmd) { + listener.enterIndex_partition_cmd(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReassignownedstmt) { - listener.exitReassignownedstmt(this); + if(listener.exitIndex_partition_cmd) { + listener.exitIndex_partition_cmd(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReassignownedstmt) { - return visitor.visitReassignownedstmt(this); + if (visitor.visitIndex_partition_cmd) { + return visitor.visitIndex_partition_cmd(this); } else { return visitor.visitChildren(this); } @@ -86733,287 +61322,293 @@ export class ReassignownedstmtContext extends antlr.ParserRuleContext { } -export class DropstmtContext extends antlr.ParserRuleContext { +export class Alter_table_cmdContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_DROP(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DROP, 0)!; - } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); - } - public table_name_list(): Table_name_listContext | null { - return this.getRuleContext(0, Table_name_listContext); - } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); - } - public opt_drop_behavior(): Opt_drop_behaviorContext | null { - return this.getRuleContext(0, Opt_drop_behaviorContext); - } - public KW_SEQUENCE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); - } - public name_list(): Name_listContext | null { - return this.getRuleContext(0, Name_listContext); + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADD, 0); } - public KW_VIEW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VIEW, 0); + public constraintelem(): ConstraintelemContext | null { + return this.getRuleContext(0, ConstraintelemContext); } - public view_nameList(): View_nameListContext | null { - return this.getRuleContext(0, View_nameListContext); + public KW_CONSTRAINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); } - public KW_MATERIALIZED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public KW_INDEX(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INDEX, 0); + public KW_ALTER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALTER, 0); } - public KW_FOREIGN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); + public constraintattributeElem(): ConstraintattributeElemContext[]; + public constraintattributeElem(i: number): ConstraintattributeElemContext | null; + public constraintattributeElem(i?: number): ConstraintattributeElemContext[] | ConstraintattributeElemContext | null { + if (i === undefined) { + return this.getRuleContexts(ConstraintattributeElemContext); + } + + return this.getRuleContext(i, ConstraintattributeElemContext); } - public KW_COLLATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLLATION, 0); + public KW_VALIDATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALIDATE, 0); } - public KW_CONVERSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONVERSION, 0); + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); } - public KW_STATISTICS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); } - public KW_TEXT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEXT, 0); + public opt_drop_behavior(): Opt_drop_behaviorContext | null { + return this.getRuleContext(0, Opt_drop_behaviorContext); } - public KW_SEARCH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEARCH, 0); + public KW_SET(): antlr.TerminalNode[]; + public KW_SET(i: number): antlr.TerminalNode | null; + public KW_SET(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_SET); + } else { + return this.getToken(PostgreSqlParser.KW_SET, i); + } } - public KW_PARSER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARSER, 0); + public KW_WITHOUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); } - public KW_DICTIONARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); + public KW_OIDS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OIDS, 0); } - public KW_TEMPLATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); + public KW_CLUSTER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CLUSTER, 0); } - public KW_CONFIGURATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ON, 0); } - public KW_ACCESS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ACCESS, 0); + public KW_LOGGED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LOGGED, 0); } - public KW_METHOD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_METHOD, 0); + public KW_UNLOGGED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNLOGGED, 0); } - public KW_EVENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EVENT, 0); + public KW_ENABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ENABLE, 0); } public KW_TRIGGER(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); } - public KW_EXTENSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXTENSION, 0); - } - public KW_DATA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATA, 0); - } - public KW_WRAPPER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); + public KW_REPLICA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REPLICA, 0); } - public KW_LANGUAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); + public KW_ALWAYS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALWAYS, 0); } - public opt_procedural(): Opt_proceduralContext | null { - return this.getRuleContext(0, Opt_proceduralContext); + public KW_DISABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DISABLE, 0); } - public KW_PUBLICATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public KW_SERVER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SERVER, 0); + public KW_USER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USER, 0); } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); + public KW_RULE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RULE, 0); } - public schema_name_list(): Schema_name_listContext | null { - return this.getRuleContext(0, Schema_name_listContext); + public KW_INHERIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INHERIT, 0); } - public KW_POLICY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_POLICY, 0); + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); + public KW_OF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OF, 0); } public any_name(): Any_nameContext | null { return this.getRuleContext(0, Any_nameContext); } - public KW_RULE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RULE, 0); - } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); - } - public type_name_list(): Type_name_listContext | null { - return this.getRuleContext(0, Type_name_listContext); + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } - public KW_DOMAIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); + public KW_OWNER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OWNER, 0); } - public KW_CONCURRENTLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONCURRENTLY, 0); + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } - public any_name_list(): Any_name_listContext | null { - return this.getRuleContext(0, Any_name_listContext); + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); } - public KW_CAST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CAST, 0); + public KW_TABLESPACE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public tablespace_name_create(): Tablespace_name_createContext | null { + return this.getRuleContext(0, Tablespace_name_createContext); } - public typename(): TypenameContext[]; - public typename(i: number): TypenameContext | null; - public typename(i?: number): TypenameContext[] | TypenameContext | null { - if (i === undefined) { - return this.getRuleContexts(TypenameContext); - } - - return this.getRuleContext(i, TypenameContext); + public KW_IDENTITY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IDENTITY, 0); } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); + public KW_NOTHING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOTHING, 0); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_FULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FULL, 0); } - public KW_OPERATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } - public KW_CLASS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CLASS, 0); + public existingindex(): ExistingindexContext | null { + return this.getRuleContext(0, ExistingindexContext); } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); + public KW_ROW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROW, 0); } - public KW_FAMILY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FAMILY, 0); + public KW_LEVEL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LEVEL, 0); } - public KW_OWNED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OWNED, 0); + public KW_SECURITY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SECURITY, 0); } - public KW_BY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BY, 0); + public KW_FORCE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FORCE, 0); } - public role_list(): Role_listContext | null { - return this.getRuleContext(0, Role_listContext); + public column_name(): Column_nameContext | null { + return this.getRuleContext(0, Column_nameContext); } - public KW_SUBSCRIPTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0); + public KW_COLUMN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLUMN, 0); } - public KW_TABLESPACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); + public column_def(): Column_defContext | null { + return this.getRuleContext(0, Column_defContext); } - public tablespace_name(): Tablespace_nameContext | null { - return this.getRuleContext(0, Tablespace_nameContext); + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); } - public KW_TRANSFORM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0); + public alter_column_default(): Alter_column_defaultContext | null { + return this.getRuleContext(0, Alter_column_defaultContext); } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); + public alter_generic_options(): Alter_generic_optionsContext | null { + return this.getRuleContext(0, Alter_generic_optionsContext); } - public KW_ROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLE, 0); + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULL, 0); } - public KW_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USER, 0); + public KW_EXPRESSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXPRESSION, 0); } - public KW_GROUP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GROUP, 0); + public KW_STATISTICS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); } - public KW_MAPPING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MAPPING, 0); + public signediconst(): SignediconstContext | null { + return this.getRuleContext(0, SignediconstContext); } - public auth_ident(): Auth_identContext | null { - return this.getRuleContext(0, Auth_identContext); + public reloptions(): ReloptionsContext | null { + return this.getRuleContext(0, ReloptionsContext); } - public KW_DATABASE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATABASE, 0); + public KW_RESET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESET, 0); } - public database_name(): Database_nameContext | null { - return this.getRuleContext(0, Database_nameContext); + public KW_STORAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STORAGE, 0); } - public drop_option_list(): Drop_option_listContext | null { - return this.getRuleContext(0, Drop_option_listContext); + public KW_GENERATED(): antlr.TerminalNode[]; + public KW_GENERATED(i: number): antlr.TerminalNode | null; + public KW_GENERATED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_GENERATED); + } else { + return this.getToken(PostgreSqlParser.KW_GENERATED, i); + } } - public opt_with(): Opt_withContext | null { - return this.getRuleContext(0, Opt_withContext); + public generated_when(): Generated_whenContext[]; + public generated_when(i: number): Generated_whenContext | null; + public generated_when(i?: number): Generated_whenContext[] | Generated_whenContext | null { + if (i === undefined) { + return this.getRuleContexts(Generated_whenContext); + } + + return this.getRuleContext(i, Generated_whenContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_dropstmt; + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDropstmt) { - listener.enterDropstmt(this); - } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDropstmt) { - listener.exitDropstmt(this); - } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDropstmt) { - return visitor.visitDropstmt(this); - } else { - return visitor.visitChildren(this); + public seqoptelem(): SeqoptelemContext[]; + public seqoptelem(i: number): SeqoptelemContext | null; + public seqoptelem(i?: number): SeqoptelemContext[] | SeqoptelemContext | null { + if (i === undefined) { + return this.getRuleContexts(SeqoptelemContext); } - } -} - -export class View_nameListContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, SeqoptelemContext); } - public view_name(): View_nameContext[]; - public view_name(i: number): View_nameContext | null; - public view_name(i?: number): View_nameContext[] | View_nameContext | null { + public KW_RESTART(): antlr.TerminalNode[]; + public KW_RESTART(i: number): antlr.TerminalNode | null; + public KW_RESTART(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_RESTART); + } else { + return this.getToken(PostgreSqlParser.KW_RESTART, i); + } + } + public numericonly(): NumericonlyContext[]; + public numericonly(i: number): NumericonlyContext | null; + public numericonly(i?: number): NumericonlyContext[] | NumericonlyContext | null { if (i === undefined) { - return this.getRuleContexts(View_nameContext); + return this.getRuleContexts(NumericonlyContext); } - return this.getRuleContext(i, View_nameContext); + return this.getRuleContext(i, NumericonlyContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public KW_WITH(): antlr.TerminalNode[]; + public KW_WITH(i: number): antlr.TerminalNode | null; + public KW_WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); + return this.getTokens(PostgreSqlParser.KW_WITH); } else { - return this.getToken(PostgreSqlParser.COMMA, i); + return this.getToken(PostgreSqlParser.KW_WITH, i); } } + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); + } + public typename(): TypenameContext | null { + return this.getRuleContext(0, TypenameContext); + } + public KW_DATA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATA, 0); + } + public opt_collate_clause(): Opt_collate_clauseContext | null { + return this.getRuleContext(0, Opt_collate_clauseContext); + } + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USING, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_view_nameList; + return PostgreSqlParser.RULE_alter_table_cmd; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterView_nameList) { - listener.enterView_nameList(this); + if(listener.enterAlter_table_cmd) { + listener.enterAlter_table_cmd(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitView_nameList) { - listener.exitView_nameList(this); + if(listener.exitAlter_table_cmd) { + listener.exitAlter_table_cmd(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitView_nameList) { - return visitor.visitView_nameList(this); + if (visitor.visitAlter_table_cmd) { + return visitor.visitAlter_table_cmd(this); } else { return visitor.visitChildren(this); } @@ -87021,80 +61616,38 @@ export class View_nameListContext extends antlr.ParserRuleContext { } -export class Object_type_any_nameContext extends antlr.ParserRuleContext { +export class Alter_column_defaultContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); - } - public table_name(): Table_nameContext | null { - return this.getRuleContext(0, Table_nameContext); - } - public KW_FOREIGN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); - } - public KW_VIEW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VIEW, 0); - } - public view_name(): View_nameContext | null { - return this.getRuleContext(0, View_nameContext); - } - public KW_MATERIALIZED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); - } - public KW_INDEX(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INDEX, 0); - } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); - } - public KW_COLLATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLLATION, 0); - } - public KW_CONVERSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONVERSION, 0); - } - public KW_STATISTICS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); - } - public KW_SEQUENCE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); - } - public KW_TEXT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEXT, 0); - } - public KW_SEARCH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEARCH, 0); - } - public KW_PARSER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARSER, 0); + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public KW_DICTIONARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); + public KW_DEFAULT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0)!; } - public KW_TEMPLATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } - public KW_CONFIGURATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_object_type_any_name; + return PostgreSqlParser.RULE_alter_column_default; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterObject_type_any_name) { - listener.enterObject_type_any_name(this); + if(listener.enterAlter_column_default) { + listener.enterAlter_column_default(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitObject_type_any_name) { - listener.exitObject_type_any_name(this); + if(listener.exitAlter_column_default) { + listener.exitAlter_column_default(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitObject_type_any_name) { - return visitor.visitObject_type_any_name(this); + if (visitor.visitAlter_column_default) { + return visitor.visitAlter_column_default(this); } else { return visitor.visitChildren(this); } @@ -87102,89 +61655,32 @@ export class Object_type_any_nameContext extends antlr.ParserRuleContext { } -export class Object_type_nameContext extends antlr.ParserRuleContext { +export class Opt_drop_behaviorContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ACCESS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ACCESS, 0); - } - public KW_METHOD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_METHOD, 0); - } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); - } - public KW_EVENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EVENT, 0); - } - public KW_TRIGGER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); - } - public KW_EXTENSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXTENSION, 0); - } - public KW_FOREIGN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); - } - public KW_DATA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATA, 0); - } - public KW_WRAPPER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); - } - public KW_LANGUAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); - } - public opt_procedural(): Opt_proceduralContext | null { - return this.getRuleContext(0, Opt_proceduralContext); - } - public KW_PUBLICATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); - } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); - } - public schema_name(): Schema_nameContext | null { - return this.getRuleContext(0, Schema_nameContext); - } - public KW_SERVER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SERVER, 0); - } - public KW_DATABASE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATABASE, 0); - } - public database_name(): Database_nameContext | null { - return this.getRuleContext(0, Database_nameContext); - } - public KW_ROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLE, 0); - } - public KW_SUBSCRIPTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0); - } - public KW_TABLESPACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); + public KW_CASCADE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CASCADE, 0); } - public tablespace_name(): Tablespace_nameContext | null { - return this.getRuleContext(0, Tablespace_nameContext); + public KW_RESTRICT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESTRICT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_object_type_name; + return PostgreSqlParser.RULE_opt_drop_behavior; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterObject_type_name) { - listener.enterObject_type_name(this); + if(listener.enterOpt_drop_behavior) { + listener.enterOpt_drop_behavior(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitObject_type_name) { - listener.exitObject_type_name(this); + if(listener.exitOpt_drop_behavior) { + listener.exitOpt_drop_behavior(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitObject_type_name) { - return visitor.visitObject_type_name(this); + if (visitor.visitOpt_drop_behavior) { + return visitor.visitOpt_drop_behavior(this); } else { return visitor.visitChildren(this); } @@ -87192,35 +61688,32 @@ export class Object_type_nameContext extends antlr.ParserRuleContext { } -export class Object_type_name_on_any_nameContext extends antlr.ParserRuleContext { +export class Opt_collate_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_POLICY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_POLICY, 0); - } - public KW_RULE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RULE, 0); - } - public KW_TRIGGER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); + public KW_COLLATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_COLLATE, 0)!; + } + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_object_type_name_on_any_name; + return PostgreSqlParser.RULE_opt_collate_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterObject_type_name_on_any_name) { - listener.enterObject_type_name_on_any_name(this); + if(listener.enterOpt_collate_clause) { + listener.enterOpt_collate_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitObject_type_name_on_any_name) { - listener.exitObject_type_name_on_any_name(this); + if(listener.exitOpt_collate_clause) { + listener.exitOpt_collate_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitObject_type_name_on_any_name) { - return visitor.visitObject_type_name_on_any_name(this); + if (visitor.visitOpt_collate_clause) { + return visitor.visitOpt_collate_clause(this); } else { return visitor.visitChildren(this); } @@ -87228,18 +61721,24 @@ export class Object_type_name_on_any_nameContext extends antlr.ParserRuleContext } -export class Any_name_listContext extends antlr.ParserRuleContext { +export class ReloptionsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public any_name(): Any_nameContext[]; - public any_name(i: number): Any_nameContext | null; - public any_name(i?: number): Any_nameContext[] | Any_nameContext | null { + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + } + public reloption_elem(): Reloption_elemContext[]; + public reloption_elem(i: number): Reloption_elemContext | null; + public reloption_elem(i?: number): Reloption_elemContext[] | Reloption_elemContext | null { if (i === undefined) { - return this.getRuleContexts(Any_nameContext); + return this.getRuleContexts(Reloption_elemContext); } - return this.getRuleContext(i, Any_nameContext); + return this.getRuleContext(i, Reloption_elemContext); + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -87251,21 +61750,21 @@ export class Any_name_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_any_name_list; + return PostgreSqlParser.RULE_reloptions; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAny_name_list) { - listener.enterAny_name_list(this); + if(listener.enterReloptions) { + listener.enterReloptions(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAny_name_list) { - listener.exitAny_name_list(this); + if(listener.exitReloptions) { + listener.exitReloptions(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAny_name_list) { - return visitor.visitAny_name_list(this); + if (visitor.visitReloptions) { + return visitor.visitReloptions(this); } else { return visitor.visitChildren(this); } @@ -87273,35 +61772,32 @@ export class Any_name_listContext extends antlr.ParserRuleContext { } -export class Relation_column_nameContext extends antlr.ParserRuleContext { +export class Opt_reloptionsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public relation_name(): Relation_nameContext { - return this.getRuleContext(0, Relation_nameContext)!; - } - public DOT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.DOT, 0)!; + public KW_WITH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WITH, 0)!; } - public column_name(): Column_nameContext { - return this.getRuleContext(0, Column_nameContext)!; + public reloptions(): ReloptionsContext { + return this.getRuleContext(0, ReloptionsContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_relation_column_name; + return PostgreSqlParser.RULE_opt_reloptions; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRelation_column_name) { - listener.enterRelation_column_name(this); + if(listener.enterOpt_reloptions) { + listener.enterOpt_reloptions(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRelation_column_name) { - listener.exitRelation_column_name(this); + if(listener.exitOpt_reloptions) { + listener.exitOpt_reloptions(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRelation_column_name) { - return visitor.visitRelation_column_name(this); + if (visitor.visitOpt_reloptions) { + return visitor.visitOpt_reloptions(this); } else { return visitor.visitChildren(this); } @@ -87309,32 +61805,41 @@ export class Relation_column_nameContext extends antlr.ParserRuleContext { } -export class Relation_nameContext extends antlr.ParserRuleContext { +export class Reloption_elemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; + public collabel(): CollabelContext { + return this.getRuleContext(0, CollabelContext)!; } - public attrs(): AttrsContext | null { - return this.getRuleContext(0, AttrsContext); + public EQUAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.EQUAL, 0); + } + public def_arg(): Def_argContext | null { + return this.getRuleContext(0, Def_argContext); + } + public DOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.DOT, 0); + } + public def_elem(): Def_elemContext | null { + return this.getRuleContext(0, Def_elemContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_relation_name; + return PostgreSqlParser.RULE_reloption_elem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRelation_name) { - listener.enterRelation_name(this); + if(listener.enterReloption_elem) { + listener.enterReloption_elem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRelation_name) { - listener.exitRelation_name(this); + if(listener.exitReloption_elem) { + listener.exitReloption_elem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRelation_name) { - return visitor.visitRelation_name(this); + if (visitor.visitReloption_elem) { + return visitor.visitReloption_elem(this); } else { return visitor.visitChildren(this); } @@ -87342,77 +61847,89 @@ export class Relation_nameContext extends antlr.ParserRuleContext { } -export class Any_nameContext extends antlr.ParserRuleContext { +export class PartitionboundspecContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } - public attrs(): AttrsContext | null { - return this.getRuleContext(0, AttrsContext); + public KW_VALUES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALUES, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_any_name; + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAny_name) { - listener.enterAny_name(this); - } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAny_name) { - listener.exitAny_name(this); + public nonreservedword(): NonreservedwordContext[]; + public nonreservedword(i: number): NonreservedwordContext | null; + public nonreservedword(i?: number): NonreservedwordContext[] | NonreservedwordContext | null { + if (i === undefined) { + return this.getRuleContexts(NonreservedwordContext); } + + return this.getRuleContext(i, NonreservedwordContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAny_name) { - return visitor.visitAny_name(this); - } else { - return visitor.visitChildren(this); - } + public Integral(): antlr.TerminalNode[]; + public Integral(i: number): antlr.TerminalNode | null; + public Integral(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.Integral); + } else { + return this.getToken(PostgreSqlParser.Integral, i); + } } -} - - -export class AttrsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public DOT(): antlr.TerminalNode[]; - public DOT(i: number): antlr.TerminalNode | null; - public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.DOT); + return this.getTokens(PostgreSqlParser.COMMA); } else { - return this.getToken(PostgreSqlParser.DOT, i); + return this.getToken(PostgreSqlParser.COMMA, i); } } - public attr_name(): Attr_nameContext[]; - public attr_name(i: number): Attr_nameContext | null; - public attr_name(i?: number): Attr_nameContext[] | Attr_nameContext | null { + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); + } + public execute_param_clause(): Execute_param_clauseContext[]; + public execute_param_clause(i: number): Execute_param_clauseContext | null; + public execute_param_clause(i?: number): Execute_param_clauseContext[] | Execute_param_clauseContext | null { if (i === undefined) { - return this.getRuleContexts(Attr_nameContext); + return this.getRuleContexts(Execute_param_clauseContext); } - return this.getRuleContext(i, Attr_nameContext); + return this.getRuleContext(i, Execute_param_clauseContext); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); + } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_attrs; + return PostgreSqlParser.RULE_partitionboundspec; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAttrs) { - listener.enterAttrs(this); + if(listener.enterPartitionboundspec) { + listener.enterPartitionboundspec(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAttrs) { - listener.exitAttrs(this); + if(listener.exitPartitionboundspec) { + listener.exitPartitionboundspec(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAttrs) { - return visitor.visitAttrs(this); + if (visitor.visitPartitionboundspec) { + return visitor.visitPartitionboundspec(this); } else { return visitor.visitChildren(this); } @@ -87420,18 +61937,27 @@ export class AttrsContext extends antlr.ParserRuleContext { } -export class Type_name_listContext extends antlr.ParserRuleContext { +export class AltercompositetypestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public typename(): TypenameContext[]; - public typename(i: number): TypenameContext | null; - public typename(i?: number): TypenameContext[] | TypenameContext | null { + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public KW_TYPE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TYPE, 0)!; + } + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; + } + public alter_type_cmd(): Alter_type_cmdContext[]; + public alter_type_cmd(i: number): Alter_type_cmdContext | null; + public alter_type_cmd(i?: number): Alter_type_cmdContext[] | Alter_type_cmdContext | null { if (i === undefined) { - return this.getRuleContexts(TypenameContext); + return this.getRuleContexts(Alter_type_cmdContext); } - return this.getRuleContext(i, TypenameContext); + return this.getRuleContext(i, Alter_type_cmdContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -87443,21 +61969,21 @@ export class Type_name_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_type_name_list; + return PostgreSqlParser.RULE_altercompositetypestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterType_name_list) { - listener.enterType_name_list(this); + if(listener.enterAltercompositetypestmt) { + listener.enterAltercompositetypestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitType_name_list) { - listener.exitType_name_list(this); + if(listener.exitAltercompositetypestmt) { + listener.exitAltercompositetypestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitType_name_list) { - return visitor.visitType_name_list(this); + if (visitor.visitAltercompositetypestmt) { + return visitor.visitAltercompositetypestmt(this); } else { return visitor.visitChildren(this); } @@ -87465,62 +61991,65 @@ export class Type_name_listContext extends antlr.ParserRuleContext { } -export class TruncatestmtContext extends antlr.ParserRuleContext { +export class Alter_type_cmdContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_TRUNCATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TRUNCATE, 0)!; - } - public truncate_table(): Truncate_tableContext[]; - public truncate_table(i: number): Truncate_tableContext | null; - public truncate_table(i?: number): Truncate_tableContext[] | Truncate_tableContext | null { - if (i === undefined) { - return this.getRuleContexts(Truncate_tableContext); - } - - return this.getRuleContext(i, Truncate_tableContext); - } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADD, 0); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_ATTRIBUTE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ATTRIBUTE, 0)!; } - public KW_IDENTITY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IDENTITY, 0); + public tablefuncelement(): TablefuncelementContext | null { + return this.getRuleContext(0, TablefuncelementContext); } public opt_drop_behavior(): Opt_drop_behaviorContext | null { return this.getRuleContext(0, Opt_drop_behaviorContext); } - public KW_CONTINUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONTINUE, 0); + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); } - public KW_RESTART(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESTART, 0); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); + } + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); + } + public KW_ALTER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALTER, 0); + } + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); + } + public typename(): TypenameContext | null { + return this.getRuleContext(0, TypenameContext); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); + } + public KW_DATA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATA, 0); + } + public opt_collate_clause(): Opt_collate_clauseContext | null { + return this.getRuleContext(0, Opt_collate_clauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_truncatestmt; + return PostgreSqlParser.RULE_alter_type_cmd; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTruncatestmt) { - listener.enterTruncatestmt(this); + if(listener.enterAlter_type_cmd) { + listener.enterAlter_type_cmd(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTruncatestmt) { - listener.exitTruncatestmt(this); + if(listener.exitAlter_type_cmd) { + listener.exitAlter_type_cmd(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTruncatestmt) { - return visitor.visitTruncatestmt(this); + if (visitor.visitAlter_type_cmd) { + return visitor.visitAlter_type_cmd(this); } else { return visitor.visitChildren(this); } @@ -87528,35 +62057,35 @@ export class TruncatestmtContext extends antlr.ParserRuleContext { } -export class Truncate_tableContext extends antlr.ParserRuleContext { +export class CloseportalstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public table_name(): Table_nameContext { - return this.getRuleContext(0, Table_nameContext)!; + public KW_CLOSE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CLOSE, 0)!; } - public KW_ONLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ONLY, 0); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public STAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.STAR, 0); + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_truncate_table; + return PostgreSqlParser.RULE_closeportalstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTruncate_table) { - listener.enterTruncate_table(this); + if(listener.enterCloseportalstmt) { + listener.enterCloseportalstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTruncate_table) { - listener.exitTruncate_table(this); + if(listener.exitCloseportalstmt) { + listener.exitCloseportalstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTruncate_table) { - return visitor.visitTruncate_table(this); + if (visitor.visitCloseportalstmt) { + return visitor.visitCloseportalstmt(this); } else { return visitor.visitChildren(this); } @@ -87564,161 +62093,272 @@ export class Truncate_tableContext extends antlr.ParserRuleContext { } -export class CommentstmtContext extends antlr.ParserRuleContext { +export class CopystmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_COMMENT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_COMMENT, 0)!; + public KW_COPY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_COPY, 0)!; } - public KW_ON(): antlr.TerminalNode[]; - public KW_ON(i: number): antlr.TerminalNode | null; - public KW_ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_ON); - } else { - return this.getToken(PostgreSqlParser.KW_ON, i); - } + public table_name(): Table_nameContext | null { + return this.getRuleContext(0, Table_nameContext); } - public object_type_any_name(): Object_type_any_nameContext | null { - return this.getRuleContext(0, Object_type_any_nameContext); + public copy_options(): Copy_optionsContext { + return this.getRuleContext(0, Copy_optionsContext)!; } - public KW_IS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_IS, 0)!; + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); } - public comment_text(): Comment_textContext { - return this.getRuleContext(0, Comment_textContext)!; + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } - public KW_COLUMN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLUMN, 0); + public sconst(): SconstContext[]; + public sconst(i: number): SconstContext | null; + public sconst(i?: number): SconstContext[] | SconstContext | null { + if (i === undefined) { + return this.getRuleContexts(SconstContext); + } + + return this.getRuleContext(i, SconstContext); } - public relation_column_name(): Relation_column_nameContext | null { - return this.getRuleContext(0, Relation_column_nameContext); + public KW_STDIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STDIN, 0); } - public object_type_name(): Object_type_nameContext | null { - return this.getRuleContext(0, Object_type_nameContext); + public KW_STDOUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STDOUT, 0); } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); + public KW_BINARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BINARY, 0); } - public typename(): TypenameContext[]; - public typename(i: number): TypenameContext | null; - public typename(i?: number): TypenameContext[] | TypenameContext | null { - if (i === undefined) { - return this.getRuleContexts(TypenameContext); - } - - return this.getRuleContext(i, TypenameContext); + public opt_column_list(): Opt_column_listContext | null { + return this.getRuleContext(0, Opt_column_listContext); } - public KW_DOMAIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); + public KW_PROGRAM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROGRAM, 0); } - public KW_AGGREGATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); + public KW_DELIMITERS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DELIMITERS, 0); } - public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { - return this.getRuleContext(0, Aggregate_with_argtypesContext); + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + public where_clause(): Where_clauseContext | null { + return this.getRuleContext(0, Where_clauseContext); } - public function_with_argtypes(): Function_with_argtypesContext | null { - return this.getRuleContext(0, Function_with_argtypesContext); + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USING, 0); } - public KW_OPERATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public operator_with_argtypes(): Operator_with_argtypesContext | null { - return this.getRuleContext(0, Operator_with_argtypesContext); + public preparablestmt(): PreparablestmtContext | null { + return this.getRuleContext(0, PreparablestmtContext); } - public KW_CONSTRAINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_copystmt; } - public table_name(): Table_nameContext | null { - return this.getRuleContext(0, Table_nameContext); + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterCopystmt) { + listener.enterCopystmt(this); + } } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); + public override exitRule(listener: PostgreSqlParserListener): void { + if(listener.exitCopystmt) { + listener.exitCopystmt(this); + } } - public KW_POLICY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_POLICY, 0); + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitCopystmt) { + return visitor.visitCopystmt(this); + } else { + return visitor.visitChildren(this); + } } - public KW_RULE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RULE, 0); +} + + +export class Copy_optionsContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); } - public KW_TRIGGER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); + public KW_BINARY(): antlr.TerminalNode[]; + public KW_BINARY(i: number): antlr.TerminalNode | null; + public KW_BINARY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_BINARY); + } else { + return this.getToken(PostgreSqlParser.KW_BINARY, i); + } } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + public KW_FREEZE(): antlr.TerminalNode[]; + public KW_FREEZE(i: number): antlr.TerminalNode | null; + public KW_FREEZE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_FREEZE); + } else { + return this.getToken(PostgreSqlParser.KW_FREEZE, i); + } } - public procedure_with_argtypes(): Procedure_with_argtypesContext | null { - return this.getRuleContext(0, Procedure_with_argtypesContext); + public sconst(): SconstContext[]; + public sconst(i: number): SconstContext | null; + public sconst(i?: number): SconstContext[] | SconstContext | null { + if (i === undefined) { + return this.getRuleContexts(SconstContext); + } + + return this.getRuleContext(i, SconstContext); } - public KW_ROUTINE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); + public KW_CSV(): antlr.TerminalNode[]; + public KW_CSV(i: number): antlr.TerminalNode | null; + public KW_CSV(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_CSV); + } else { + return this.getToken(PostgreSqlParser.KW_CSV, i); + } } - public routine_with_argtypes(): Routine_with_argtypesContext | null { - return this.getRuleContext(0, Routine_with_argtypesContext); + public KW_HEADER(): antlr.TerminalNode[]; + public KW_HEADER(i: number): antlr.TerminalNode | null; + public KW_HEADER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_HEADER); + } else { + return this.getToken(PostgreSqlParser.KW_HEADER, i); + } } - public KW_TRANSFORM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0); + public KW_FORCE(): antlr.TerminalNode[]; + public KW_FORCE(i: number): antlr.TerminalNode | null; + public KW_FORCE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_FORCE); + } else { + return this.getToken(PostgreSqlParser.KW_FORCE, i); + } } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); + public KW_QUOTE(): antlr.TerminalNode[]; + public KW_QUOTE(i: number): antlr.TerminalNode | null; + public KW_QUOTE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_QUOTE); + } else { + return this.getToken(PostgreSqlParser.KW_QUOTE, i); + } } - public KW_LANGUAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); + public KW_NULL(): antlr.TerminalNode[]; + public KW_NULL(i: number): antlr.TerminalNode | null; + public KW_NULL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_NULL); + } else { + return this.getToken(PostgreSqlParser.KW_NULL, i); + } } - public KW_CLASS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CLASS, 0); + public column_list(): Column_listContext[]; + public column_list(i: number): Column_listContext | null; + public column_list(i?: number): Column_listContext[] | Column_listContext | null { + if (i === undefined) { + return this.getRuleContexts(Column_listContext); + } + + return this.getRuleContext(i, Column_listContext); } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); + public KW_ENCODING(): antlr.TerminalNode[]; + public KW_ENCODING(i: number): antlr.TerminalNode | null; + public KW_ENCODING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_ENCODING); + } else { + return this.getToken(PostgreSqlParser.KW_ENCODING, i); + } } - public KW_FAMILY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FAMILY, 0); + public KW_DELIMITER(): antlr.TerminalNode[]; + public KW_DELIMITER(i: number): antlr.TerminalNode | null; + public KW_DELIMITER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_DELIMITER); + } else { + return this.getToken(PostgreSqlParser.KW_DELIMITER, i); + } } - public KW_LARGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LARGE, 0); + public KW_ESCAPE(): antlr.TerminalNode[]; + public KW_ESCAPE(i: number): antlr.TerminalNode | null; + public KW_ESCAPE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_ESCAPE); + } else { + return this.getToken(PostgreSqlParser.KW_ESCAPE, i); + } } - public KW_OBJECT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OBJECT, 0); + public STAR(): antlr.TerminalNode[]; + public STAR(i: number): antlr.TerminalNode | null; + public STAR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.STAR); + } else { + return this.getToken(PostgreSqlParser.STAR, i); + } } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); + public KW_AS(): antlr.TerminalNode[]; + public KW_AS(i: number): antlr.TerminalNode | null; + public KW_AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_AS); + } else { + return this.getToken(PostgreSqlParser.KW_AS, i); + } } - public KW_CAST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CAST, 0); + public KW_NOT(): antlr.TerminalNode[]; + public KW_NOT(i: number): antlr.TerminalNode | null; + public KW_NOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_NOT); + } else { + return this.getToken(PostgreSqlParser.KW_NOT, i); + } } public OPEN_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); + public copy_generic_opt_elem(): Copy_generic_opt_elemContext[]; + public copy_generic_opt_elem(i: number): Copy_generic_opt_elemContext | null; + public copy_generic_opt_elem(i?: number): Copy_generic_opt_elemContext[] | Copy_generic_opt_elemContext | null { + if (i === undefined) { + return this.getRuleContexts(Copy_generic_opt_elemContext); + } + + return this.getRuleContext(i, Copy_generic_opt_elemContext); } public CLOSE_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_commentstmt; + return PostgreSqlParser.RULE_copy_options; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCommentstmt) { - listener.enterCommentstmt(this); + if(listener.enterCopy_options) { + listener.enterCopy_options(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCommentstmt) { - listener.exitCommentstmt(this); + if(listener.exitCopy_options) { + listener.exitCopy_options(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCommentstmt) { - return visitor.visitCommentstmt(this); + if (visitor.visitCopy_options) { + return visitor.visitCopy_options(this); } else { return visitor.visitChildren(this); } @@ -87726,32 +62366,62 @@ export class CommentstmtContext extends antlr.ParserRuleContext { } -export class Comment_textContext extends antlr.ParserRuleContext { +export class Copy_generic_opt_elemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); + public collabel(): CollabelContext { + return this.getRuleContext(0, CollabelContext)!; } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); + public opt_boolean_or_string(): Opt_boolean_or_stringContext | null { + return this.getRuleContext(0, Opt_boolean_or_stringContext); + } + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); + } + public STAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.STAR, 0); + } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + } + public opt_boolean_or_string_column(): Opt_boolean_or_string_columnContext[]; + public opt_boolean_or_string_column(i: number): Opt_boolean_or_string_columnContext | null; + public opt_boolean_or_string_column(i?: number): Opt_boolean_or_string_columnContext[] | Opt_boolean_or_string_columnContext | null { + if (i === undefined) { + return this.getRuleContexts(Opt_boolean_or_string_columnContext); + } + + return this.getRuleContext(i, Opt_boolean_or_string_columnContext); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_comment_text; + return PostgreSqlParser.RULE_copy_generic_opt_elem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterComment_text) { - listener.enterComment_text(this); + if(listener.enterCopy_generic_opt_elem) { + listener.enterCopy_generic_opt_elem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitComment_text) { - listener.exitComment_text(this); + if(listener.exitCopy_generic_opt_elem) { + listener.exitCopy_generic_opt_elem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitComment_text) { - return visitor.visitComment_text(this); + if (visitor.visitCopy_generic_opt_elem) { + return visitor.visitCopy_generic_opt_elem(this); } else { return visitor.visitChildren(this); } @@ -87759,98 +62429,95 @@ export class Comment_textContext extends antlr.ParserRuleContext { } -export class SeclabelstmtContext extends antlr.ParserRuleContext { +export class CreatestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_SECURITY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SECURITY, 0)!; - } - public KW_LABEL(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_LABEL, 0)!; - } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_createstmt; } - public KW_COLUMN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLUMN, 0); + public override copyFrom(ctx: CreatestmtContext): void { + super.copyFrom(ctx); } - public column_name(): Column_nameContext | null { - return this.getRuleContext(0, Column_nameContext); +} +export class ColumnCreateTableContext extends CreatestmtContext { + public constructor(ctx: CreatestmtContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public KW_IS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_IS, 0)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public security_label(): Security_labelContext { - return this.getRuleContext(0, Security_labelContext)!; + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TABLE, 0)!; } - public opt_provider(): Opt_providerContext | null { - return this.getRuleContext(0, Opt_providerContext); + public table_name_create(): Table_name_createContext { + return this.getRuleContext(0, Table_name_createContext)!; } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public typename(): TypenameContext | null { - return this.getRuleContext(0, TypenameContext); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public KW_DOMAIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); + public KW_OF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OF, 0); } - public KW_AGGREGATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); } - public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { - return this.getRuleContext(0, Aggregate_with_argtypesContext); + public KW_PARTITION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARTITION, 0); } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } - public function_with_argtypes(): Function_with_argtypesContext | null { - return this.getRuleContext(0, Function_with_argtypesContext); + public partitionboundspec(): PartitionboundspecContext | null { + return this.getRuleContext(0, PartitionboundspecContext); } - public KW_LARGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LARGE, 0); + public opttemp(): OpttempContext | null { + return this.getRuleContext(0, OpttempContext); } - public KW_OBJECT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OBJECT, 0); + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); + public tableelementlist(): TableelementlistContext | null { + return this.getRuleContext(0, TableelementlistContext); } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + public optinherit(): OptinheritContext | null { + return this.getRuleContext(0, OptinheritContext); } - public procedure_with_argtypes(): Procedure_with_argtypesContext | null { - return this.getRuleContext(0, Procedure_with_argtypesContext); + public partitionspec(): PartitionspecContext | null { + return this.getRuleContext(0, PartitionspecContext); } - public KW_ROUTINE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); } - public routine_with_argtypes(): Routine_with_argtypesContext | null { - return this.getRuleContext(0, Routine_with_argtypesContext); + public optwith(): OptwithContext | null { + return this.getRuleContext(0, OptwithContext); } - public object_type_any_name(): Object_type_any_nameContext | null { - return this.getRuleContext(0, Object_type_any_nameContext); + public oncommitoption(): OncommitoptionContext | null { + return this.getRuleContext(0, OncommitoptionContext); } - public object_type_name(): Object_type_nameContext | null { - return this.getRuleContext(0, Object_type_nameContext); + public opttablespace(): OpttablespaceContext | null { + return this.getRuleContext(0, OpttablespaceContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_seclabelstmt; + public opttypedtableelementlist(): OpttypedtableelementlistContext | null { + return this.getRuleContext(0, OpttypedtableelementlistContext); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSeclabelstmt) { - listener.enterSeclabelstmt(this); + if(listener.enterColumnCreateTable) { + listener.enterColumnCreateTable(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSeclabelstmt) { - listener.exitSeclabelstmt(this); + if(listener.exitColumnCreateTable) { + listener.exitColumnCreateTable(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSeclabelstmt) { - return visitor.visitSeclabelstmt(this); + if (visitor.visitColumnCreateTable) { + return visitor.visitColumnCreateTable(this); } else { return visitor.visitChildren(this); } @@ -87858,32 +62525,41 @@ export class SeclabelstmtContext extends antlr.ParserRuleContext { } -export class Opt_providerContext extends antlr.ParserRuleContext { +export class OpttempContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPORARY, 0); } - public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext { - return this.getRuleContext(0, Nonreservedword_or_sconstContext)!; + public KW_TEMP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMP, 0); + } + public KW_LOCAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LOCAL, 0); + } + public KW_GLOBAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GLOBAL, 0); + } + public KW_UNLOGGED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNLOGGED, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_provider; + return PostgreSqlParser.RULE_opttemp; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_provider) { - listener.enterOpt_provider(this); + if(listener.enterOpttemp) { + listener.enterOpttemp(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_provider) { - listener.exitOpt_provider(this); + if(listener.exitOpttemp) { + listener.exitOpttemp(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_provider) { - return visitor.visitOpt_provider(this); + if (visitor.visitOpttemp) { + return visitor.visitOpttemp(this); } else { return visitor.visitChildren(this); } @@ -87891,32 +62567,50 @@ export class Opt_providerContext extends antlr.ParserRuleContext { } -export class Security_labelContext extends antlr.ParserRuleContext { +export class OpttypedtableelementlistContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); + public typedtableelement(): TypedtableelementContext[]; + public typedtableelement(i: number): TypedtableelementContext | null; + public typedtableelement(i?: number): TypedtableelementContext[] | TypedtableelementContext | null { + if (i === undefined) { + return this.getRuleContexts(TypedtableelementContext); + } + + return this.getRuleContext(i, TypedtableelementContext); + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_security_label; + return PostgreSqlParser.RULE_opttypedtableelementlist; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSecurity_label) { - listener.enterSecurity_label(this); + if(listener.enterOpttypedtableelementlist) { + listener.enterOpttypedtableelementlist(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSecurity_label) { - listener.exitSecurity_label(this); + if(listener.exitOpttypedtableelementlist) { + listener.exitOpttypedtableelementlist(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSecurity_label) { - return visitor.visitSecurity_label(this); + if (visitor.visitOpttypedtableelementlist) { + return visitor.visitOpttypedtableelementlist(this); } else { return visitor.visitChildren(this); } @@ -87924,35 +62618,44 @@ export class Security_labelContext extends antlr.ParserRuleContext { } -export class FetchstmtContext extends antlr.ParserRuleContext { +export class TableelementlistContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FETCH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FETCH, 0); - } - public fetch_args(): Fetch_argsContext { - return this.getRuleContext(0, Fetch_argsContext)!; + public tableelement(): TableelementContext[]; + public tableelement(i: number): TableelementContext | null; + public tableelement(i?: number): TableelementContext[] | TableelementContext | null { + if (i === undefined) { + return this.getRuleContexts(TableelementContext); + } + + return this.getRuleContext(i, TableelementContext); } - public KW_MOVE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MOVE, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_fetchstmt; + return PostgreSqlParser.RULE_tableelementlist; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFetchstmt) { - listener.enterFetchstmt(this); + if(listener.enterTableelementlist) { + listener.enterTableelementlist(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFetchstmt) { - listener.exitFetchstmt(this); + if(listener.exitTableelementlist) { + listener.exitTableelementlist(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFetchstmt) { - return visitor.visitFetchstmt(this); + if (visitor.visitTableelementlist) { + return visitor.visitTableelementlist(this); } else { return visitor.visitChildren(this); } @@ -87960,65 +62663,71 @@ export class FetchstmtContext extends antlr.ParserRuleContext { } -export class Fetch_argsContext extends antlr.ParserRuleContext { +export class TableelementContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public cursor_name(): Cursor_nameContext { - return this.getRuleContext(0, Cursor_nameContext)!; - } - public from_in(): From_inContext | null { - return this.getRuleContext(0, From_inContext); - } - public KW_NEXT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NEXT, 0); - } - public opt_from_in(): Opt_from_inContext | null { - return this.getRuleContext(0, Opt_from_inContext); - } - public KW_PRIOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRIOR, 0); + public column_def(): Column_defContext | null { + return this.getRuleContext(0, Column_defContext); } - public KW_FIRST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FIRST, 0); + public KW_LIKE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LIKE, 0); } - public KW_LAST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LAST, 0); + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } - public KW_ABSOLUTE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ABSOLUTE, 0); + public tablelikeoption(): TablelikeoptionContext[]; + public tablelikeoption(i: number): TablelikeoptionContext | null; + public tablelikeoption(i?: number): TablelikeoptionContext[] | TablelikeoptionContext | null { + if (i === undefined) { + return this.getRuleContexts(TablelikeoptionContext); + } + + return this.getRuleContext(i, TablelikeoptionContext); } - public signediconst(): SignediconstContext | null { - return this.getRuleContext(0, SignediconstContext); + public KW_INCLUDING(): antlr.TerminalNode[]; + public KW_INCLUDING(i: number): antlr.TerminalNode | null; + public KW_INCLUDING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_INCLUDING); + } else { + return this.getToken(PostgreSqlParser.KW_INCLUDING, i); + } } - public KW_RELATIVE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RELATIVE, 0); + public KW_EXCLUDING(): antlr.TerminalNode[]; + public KW_EXCLUDING(i: number): antlr.TerminalNode | null; + public KW_EXCLUDING(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_EXCLUDING); + } else { + return this.getToken(PostgreSqlParser.KW_EXCLUDING, i); + } } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); + public constraintelem(): ConstraintelemContext | null { + return this.getRuleContext(0, ConstraintelemContext); } - public KW_FORWARD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FORWARD, 0); + public KW_CONSTRAINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); } - public KW_BACKWARD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BACKWARD, 0); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_fetch_args; + return PostgreSqlParser.RULE_tableelement; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFetch_args) { - listener.enterFetch_args(this); + if(listener.enterTableelement) { + listener.enterTableelement(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFetch_args) { - listener.exitFetch_args(this); + if(listener.exitTableelement) { + listener.exitTableelement(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFetch_args) { - return visitor.visitFetch_args(this); + if (visitor.visitTableelement) { + return visitor.visitTableelement(this); } else { return visitor.visitChildren(this); } @@ -88026,62 +62735,53 @@ export class Fetch_argsContext extends antlr.ParserRuleContext { } -export class From_inContext extends antlr.ParserRuleContext { +export class TypedtableelementContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); + public column_name_create(): Column_name_createContext | null { + return this.getRuleContext(0, Column_name_createContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_from_in; + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFrom_in) { - listener.enterFrom_in(this); - } + public KW_OPTIONS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPTIONS, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFrom_in) { - listener.exitFrom_in(this); + public colconstraint(): ColconstraintContext[]; + public colconstraint(i: number): ColconstraintContext | null; + public colconstraint(i?: number): ColconstraintContext[] | ColconstraintContext | null { + if (i === undefined) { + return this.getRuleContexts(ColconstraintContext); } + + return this.getRuleContext(i, ColconstraintContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFrom_in) { - return visitor.visitFrom_in(this); - } else { - return visitor.visitChildren(this); - } + public constraintelem(): ConstraintelemContext | null { + return this.getRuleContext(0, ConstraintelemContext); } -} - - -export class Opt_from_inContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_CONSTRAINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); } - public from_in(): From_inContext { - return this.getRuleContext(0, From_inContext)!; + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_from_in; + return PostgreSqlParser.RULE_typedtableelement; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_from_in) { - listener.enterOpt_from_in(this); + if(listener.enterTypedtableelement) { + listener.enterTypedtableelement(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_from_in) { - listener.exitOpt_from_in(this); + if(listener.exitTypedtableelement) { + listener.exitTypedtableelement(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_from_in) { - return visitor.visitOpt_from_in(this); + if (visitor.visitTypedtableelement) { + return visitor.visitTypedtableelement(this); } else { return visitor.visitChildren(this); } @@ -88089,104 +62789,83 @@ export class Opt_from_inContext extends antlr.ParserRuleContext { } -export class GrantstmtContext extends antlr.ParserRuleContext { +export class Column_defContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_GRANT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_GRANT, 0)!; - } - public privileges(): PrivilegesContext { - return this.getRuleContext(0, PrivilegesContext)!; - } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; - } - public privilege_target(): Privilege_targetContext { - return this.getRuleContext(0, Privilege_targetContext)!; - } - public KW_TO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TO, 0)!; - } - public grantee_list(): Grantee_listContext { - return this.getRuleContext(0, Grantee_listContext)!; + public column_name_create(): Column_name_createContext { + return this.getRuleContext(0, Column_name_createContext)!; } - public opt_grant_grant_option(): Opt_grant_grant_optionContext | null { - return this.getRuleContext(0, Opt_grant_grant_optionContext); + public typename(): TypenameContext { + return this.getRuleContext(0, TypenameContext)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_grantstmt; + public create_generic_options(): Create_generic_optionsContext | null { + return this.getRuleContext(0, Create_generic_optionsContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGrantstmt) { - listener.enterGrantstmt(this); - } + public KW_STORAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STORAGE, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGrantstmt) { - listener.exitGrantstmt(this); - } + public KW_COMPRESSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COMPRESSION, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGrantstmt) { - return visitor.visitGrantstmt(this); - } else { - return visitor.visitChildren(this); + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { + if (i === undefined) { + return this.getRuleContexts(ColidContext); } - } -} - -export class RevokestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_REVOKE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_REVOKE, 0)!; + return this.getRuleContext(i, ColidContext); } - public privileges(): PrivilegesContext { - return this.getRuleContext(0, PrivilegesContext)!; + public opt_collate_clause(): Opt_collate_clauseContext | null { + return this.getRuleContext(0, Opt_collate_clauseContext); } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public privilege_target(): Privilege_targetContext { - return this.getRuleContext(0, Privilege_targetContext)!; + public KW_OPTIONS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPTIONS, 0); } - public KW_FROM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FROM, 0)!; + public colconstraint(): ColconstraintContext[]; + public colconstraint(i: number): ColconstraintContext | null; + public colconstraint(i?: number): ColconstraintContext[] | ColconstraintContext | null { + if (i === undefined) { + return this.getRuleContexts(ColconstraintContext); + } + + return this.getRuleContext(i, ColconstraintContext); } - public grantee_list(): Grantee_listContext { - return this.getRuleContext(0, Grantee_listContext)!; + public KW_PLAIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PLAIN, 0); } - public opt_drop_behavior(): Opt_drop_behaviorContext | null { - return this.getRuleContext(0, Opt_drop_behaviorContext); + public KW_EXTERNAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXTERNAL, 0); } - public KW_GRANT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GRANT, 0); + public KW_EXTENDED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXTENDED, 0); } - public KW_OPTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPTION, 0); + public KW_MAIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MAIN, 0); } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_revokestmt; + return PostgreSqlParser.RULE_column_def; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRevokestmt) { - listener.enterRevokestmt(this); + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterColumn_def) { + listener.enterColumn_def(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRevokestmt) { - listener.exitRevokestmt(this); + if(listener.exitColumn_def) { + listener.exitColumn_def(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRevokestmt) { - return visitor.visitRevokestmt(this); + if (visitor.visitColumn_def) { + return visitor.visitColumn_def(this); } else { return visitor.visitChildren(this); } @@ -88194,47 +62873,50 @@ export class RevokestmtContext extends antlr.ParserRuleContext { } -export class PrivilegesContext extends antlr.ParserRuleContext { +export class ColconstraintContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public privilege_list(): Privilege_listContext | null { - return this.getRuleContext(0, Privilege_listContext); + public colconstraintelem(): ColconstraintelemContext { + return this.getRuleContext(0, ColconstraintelemContext)!; } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); + public KW_CONSTRAINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); } - public KW_PRIVILEGES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRIVILEGES, 0); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_DEFERRABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFERRABLE, 0); } - public column_list(): Column_listContext | null { - return this.getRuleContext(0, Column_listContext); + public KW_INITIALLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INITIALLY, 0); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_DEFERRED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFERRED, 0); + } + public KW_IMMEDIATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IMMEDIATE, 0); } - public beforeprivilegeselectlist(): BeforeprivilegeselectlistContext | null { - return this.getRuleContext(0, BeforeprivilegeselectlistContext); + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_privileges; + return PostgreSqlParser.RULE_colconstraint; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPrivileges) { - listener.enterPrivileges(this); + if(listener.enterColconstraint) { + listener.enterColconstraint(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPrivileges) { - listener.exitPrivileges(this); + if(listener.exitColconstraint) { + listener.exitColconstraint(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPrivileges) { - return visitor.visitPrivileges(this); + if (visitor.visitColconstraint) { + return visitor.visitColconstraint(this); } else { return visitor.visitChildren(this); } @@ -88242,155 +62924,128 @@ export class PrivilegesContext extends antlr.ParserRuleContext { } -export class BeforeprivilegeselectlistContext extends antlr.ParserRuleContext { +export class ColconstraintelemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public beforeprivilegeselect(): BeforeprivilegeselectContext[]; - public beforeprivilegeselect(i: number): BeforeprivilegeselectContext | null; - public beforeprivilegeselect(i?: number): BeforeprivilegeselectContext[] | BeforeprivilegeselectContext | null { - if (i === undefined) { - return this.getRuleContexts(BeforeprivilegeselectContext); - } - - return this.getRuleContext(i, BeforeprivilegeselectContext); + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULL, 0); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_beforeprivilegeselectlist; + public KW_UNIQUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNIQUE, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterBeforeprivilegeselectlist) { - listener.enterBeforeprivilegeselectlist(this); - } + public opt_definition(): Opt_definitionContext | null { + return this.getRuleContext(0, Opt_definitionContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitBeforeprivilegeselectlist) { - listener.exitBeforeprivilegeselectlist(this); - } + public optconstablespace(): OptconstablespaceContext | null { + return this.getRuleContext(0, OptconstablespaceContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitBeforeprivilegeselectlist) { - return visitor.visitBeforeprivilegeselectlist(this); - } else { - return visitor.visitChildren(this); - } + public KW_NULLS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULLS, 0); } -} - - -export class BeforeprivilegeselectContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DISTINCT, 0); } - public KW_SELECT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SELECT, 0); + public KW_INCLUDE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INCLUDE, 0); } - public KW_INSERT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INSERT, 0); + public index_params(): Index_paramsContext | null { + return this.getRuleContext(0, Index_paramsContext); } - public KW_UPDATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UPDATE, 0); + public with_clause(): With_clauseContext | null { + return this.getRuleContext(0, With_clauseContext); } - public KW_DELETE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DELETE, 0); + public KW_PRIMARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRIMARY, 0); } - public KW_TRUNCATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRUNCATE, 0); + public KW_KEY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_KEY, 0); } - public KW_PEFERENCES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PEFERENCES, 0); + public KW_CHECK(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CHECK, 0); } - public KW_TRIGGER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public KW_USAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USAGE, 0); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } - public KW_CREATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CREATE, 0); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public KW_CONNECT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONNECT, 0); + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); } - public KW_TEMPORARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPORARY, 0); + public KW_INHERIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INHERIT, 0); } - public KW_TEMP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMP, 0); + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } - public KW_EXECUTE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXECUTE, 0); + public primaryExpression(): PrimaryExpressionContext | null { + return this.getRuleContext(0, PrimaryExpressionContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_beforeprivilegeselect; + public KW_GENERATED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GENERATED, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterBeforeprivilegeselect) { - listener.enterBeforeprivilegeselect(this); - } + public generated_when(): Generated_whenContext | null { + return this.getRuleContext(0, Generated_whenContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitBeforeprivilegeselect) { - listener.exitBeforeprivilegeselect(this); - } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitBeforeprivilegeselect) { - return visitor.visitBeforeprivilegeselect(this); - } else { - return visitor.visitChildren(this); - } + public KW_IDENTITY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IDENTITY, 0); } -} - - -export class Privilege_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_STORED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STORED, 0); } - public privilege(): PrivilegeContext[]; - public privilege(i: number): PrivilegeContext | null; - public privilege(i?: number): PrivilegeContext[] | PrivilegeContext | null { + public seqoptelem(): SeqoptelemContext[]; + public seqoptelem(i: number): SeqoptelemContext | null; + public seqoptelem(i?: number): SeqoptelemContext[] | SeqoptelemContext | null { if (i === undefined) { - return this.getRuleContexts(PrivilegeContext); + return this.getRuleContexts(SeqoptelemContext); } - return this.getRuleContext(i, PrivilegeContext); + return this.getRuleContext(i, SeqoptelemContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_REFERENCES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REFERENCES, 0); + } + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); + } + public opt_column_list(): Opt_column_listContext | null { + return this.getRuleContext(0, Opt_column_listContext); + } + public key_match(): Key_matchContext | null { + return this.getRuleContext(0, Key_matchContext); + } + public key_actions(): Key_actionsContext | null { + return this.getRuleContext(0, Key_actionsContext); + } + public opt_collate_clause(): Opt_collate_clauseContext | null { + return this.getRuleContext(0, Opt_collate_clauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_privilege_list; + return PostgreSqlParser.RULE_colconstraintelem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPrivilege_list) { - listener.enterPrivilege_list(this); + if(listener.enterColconstraintelem) { + listener.enterColconstraintelem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPrivilege_list) { - listener.exitPrivilege_list(this); + if(listener.exitColconstraintelem) { + listener.exitColconstraintelem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPrivilege_list) { - return visitor.visitPrivilege_list(this); + if (visitor.visitColconstraintelem) { + return visitor.visitColconstraintelem(this); } else { return visitor.visitChildren(this); } @@ -88398,41 +63053,35 @@ export class Privilege_listContext extends antlr.ParserRuleContext { } -export class PrivilegeContext extends antlr.ParserRuleContext { +export class Generated_whenContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_SELECT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SELECT, 0); - } - public opt_column_list(): Opt_column_listContext | null { - return this.getRuleContext(0, Opt_column_listContext); - } - public KW_REFERENCES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REFERENCES, 0); + public KW_ALWAYS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALWAYS, 0); } - public KW_CREATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CREATE, 0); + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BY, 0); } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_privilege; + return PostgreSqlParser.RULE_generated_when; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPrivilege) { - listener.enterPrivilege(this); + if(listener.enterGenerated_when) { + listener.enterGenerated_when(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPrivilege) { - listener.exitPrivilege(this); + if(listener.exitGenerated_when) { + listener.exitGenerated_when(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPrivilege) { - return visitor.visitPrivilege(this); + if (visitor.visitGenerated_when) { + return visitor.visitGenerated_when(this); } else { return visitor.visitChildren(this); } @@ -88440,131 +63089,53 @@ export class PrivilegeContext extends antlr.ParserRuleContext { } -export class Privilege_targetContext extends antlr.ParserRuleContext { +export class TablelikeoptionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public qualified_name_list(): Qualified_name_listContext | null { - return this.getRuleContext(0, Qualified_name_listContext); - } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); - } - public table_name_list(): Table_name_listContext | null { - return this.getRuleContext(0, Table_name_listContext); - } - public KW_SEQUENCE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); - } - public KW_FOREIGN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); - } - public KW_DATA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATA, 0); - } - public KW_WRAPPER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); - } - public name_list(): Name_listContext | null { - return this.getRuleContext(0, Name_listContext); - } - public KW_SERVER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SERVER, 0); - } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); - } - public function_with_argtypes_list(): Function_with_argtypes_listContext | null { - return this.getRuleContext(0, Function_with_argtypes_listContext); - } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); - } - public procedure_with_argtypes_list(): Procedure_with_argtypes_listContext | null { - return this.getRuleContext(0, Procedure_with_argtypes_listContext); - } - public KW_ROUTINE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); - } - public routine_with_argtypes_list(): Routine_with_argtypes_listContext | null { - return this.getRuleContext(0, Routine_with_argtypes_listContext); - } - public KW_DATABASE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATABASE, 0); - } - public database_nameList(): Database_nameListContext | null { - return this.getRuleContext(0, Database_nameListContext); - } - public KW_DOMAIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); - } - public any_name_list(): Any_name_listContext | null { - return this.getRuleContext(0, Any_name_listContext); - } - public KW_LANGUAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); - } - public KW_LARGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LARGE, 0); + public KW_COMMENTS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COMMENTS, 0); } - public KW_OBJECT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OBJECT, 0); + public KW_CONSTRAINTS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTRAINTS, 0); } - public numericonly_list(): Numericonly_listContext | null { - return this.getRuleContext(0, Numericonly_listContext); + public KW_DEFAULTS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULTS, 0); } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); + public KW_IDENTITY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IDENTITY, 0); } - public schema_name_list(): Schema_name_listContext | null { - return this.getRuleContext(0, Schema_name_listContext); + public KW_GENERATED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GENERATED, 0); } - public KW_TABLESPACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); + public KW_INDEXES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INDEXES, 0); } - public tablespace_name_list(): Tablespace_name_listContext | null { - return this.getRuleContext(0, Tablespace_name_listContext); + public KW_STATISTICS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); + public KW_STORAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STORAGE, 0); } public KW_ALL(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public KW_TABLES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLES, 0); - } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); - } - public KW_SEQUENCES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCES, 0); - } - public KW_FUNCTIONS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTIONS, 0); - } - public KW_PROCEDURES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURES, 0); - } - public KW_ROUTINES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINES, 0); - } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_privilege_target; + return PostgreSqlParser.RULE_tablelikeoption; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPrivilege_target) { - listener.enterPrivilege_target(this); + if(listener.enterTablelikeoption) { + listener.enterTablelikeoption(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPrivilege_target) { - listener.exitPrivilege_target(this); + if(listener.exitTablelikeoption) { + listener.exitTablelikeoption(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPrivilege_target) { - return visitor.visitPrivilege_target(this); + if (visitor.visitTablelikeoption) { + return visitor.visitTablelikeoption(this); } else { return visitor.visitChildren(this); } @@ -88572,18 +63143,87 @@ export class Privilege_targetContext extends antlr.ParserRuleContext { } -export class Grantee_listContext extends antlr.ParserRuleContext { +export class ConstraintelemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public grantee(): GranteeContext[]; - public grantee(i: number): GranteeContext | null; - public grantee(i?: number): GranteeContext[] | GranteeContext | null { + public KW_CHECK(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CHECK, 0); + } + public OPEN_PAREN(): antlr.TerminalNode[]; + public OPEN_PAREN(i: number): antlr.TerminalNode | null; + public OPEN_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.OPEN_PAREN); + } else { + return this.getToken(PostgreSqlParser.OPEN_PAREN, i); + } + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public CLOSE_PAREN(): antlr.TerminalNode[]; + public CLOSE_PAREN(i: number): antlr.TerminalNode | null; + public CLOSE_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.CLOSE_PAREN); + } else { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, i); + } + } + public constraintattributeElem(): ConstraintattributeElemContext[]; + public constraintattributeElem(i: number): ConstraintattributeElemContext | null; + public constraintattributeElem(i?: number): ConstraintattributeElemContext[] | ConstraintattributeElemContext | null { + if (i === undefined) { + return this.getRuleContexts(ConstraintattributeElemContext); + } + + return this.getRuleContext(i, ConstraintattributeElemContext); + } + public KW_UNIQUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNIQUE, 0); + } + public opt_column_list(): Opt_column_listContext[]; + public opt_column_list(i: number): Opt_column_listContext | null; + public opt_column_list(i?: number): Opt_column_listContext[] | Opt_column_listContext | null { + if (i === undefined) { + return this.getRuleContexts(Opt_column_listContext); + } + + return this.getRuleContext(i, Opt_column_listContext); + } + public existingindex(): ExistingindexContext | null { + return this.getRuleContext(0, ExistingindexContext); + } + public KW_PRIMARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRIMARY, 0); + } + public KW_KEY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_KEY, 0); + } + public opt_c_include(): Opt_c_includeContext | null { + return this.getRuleContext(0, Opt_c_includeContext); + } + public opt_definition(): Opt_definitionContext | null { + return this.getRuleContext(0, Opt_definitionContext); + } + public optconstablespace(): OptconstablespaceContext | null { + return this.getRuleContext(0, OptconstablespaceContext); + } + public KW_EXCLUDE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXCLUDE, 0); + } + public exclusionconstraintelem(): ExclusionconstraintelemContext[]; + public exclusionconstraintelem(i: number): ExclusionconstraintelemContext | null; + public exclusionconstraintelem(i?: number): ExclusionconstraintelemContext[] | ExclusionconstraintelemContext | null { if (i === undefined) { - return this.getRuleContexts(GranteeContext); + return this.getRuleContexts(ExclusionconstraintelemContext); } - return this.getRuleContext(i, GranteeContext); + return this.getRuleContext(i, ExclusionconstraintelemContext); + } + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -88594,22 +63234,40 @@ export class Grantee_listContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.COMMA, i); } } + public KW_WHERE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WHERE, 0); + } + public KW_FOREIGN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); + } + public KW_REFERENCES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REFERENCES, 0); + } + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); + } + public key_match(): Key_matchContext | null { + return this.getRuleContext(0, Key_matchContext); + } + public key_actions(): Key_actionsContext | null { + return this.getRuleContext(0, Key_actionsContext); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_grantee_list; + return PostgreSqlParser.RULE_constraintelem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGrantee_list) { - listener.enterGrantee_list(this); + if(listener.enterConstraintelem) { + listener.enterConstraintelem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGrantee_list) { - listener.exitGrantee_list(this); + if(listener.exitConstraintelem) { + listener.exitConstraintelem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGrantee_list) { - return visitor.visitGrantee_list(this); + if (visitor.visitConstraintelem) { + return visitor.visitConstraintelem(this); } else { return visitor.visitChildren(this); } @@ -88617,32 +63275,35 @@ export class Grantee_listContext extends antlr.ParserRuleContext { } -export class GranteeContext extends antlr.ParserRuleContext { +export class Opt_column_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public rolespec(): RolespecContext { - return this.getRuleContext(0, RolespecContext)!; + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public KW_GROUP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GROUP, 0); + public column_list(): Column_listContext { + return this.getRuleContext(0, Column_listContext)!; + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_grantee; + return PostgreSqlParser.RULE_opt_column_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGrantee) { - listener.enterGrantee(this); + if(listener.enterOpt_column_list) { + listener.enterOpt_column_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGrantee) { - listener.exitGrantee(this); + if(listener.exitOpt_column_list) { + listener.exitOpt_column_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGrantee) { - return visitor.visitGrantee(this); + if (visitor.visitOpt_column_list) { + return visitor.visitOpt_column_list(this); } else { return visitor.visitChildren(this); } @@ -88650,35 +63311,50 @@ export class GranteeContext extends antlr.ParserRuleContext { } -export class Opt_grant_grant_optionContext extends antlr.ParserRuleContext { +export class Opt_column_list_createContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + } + public column_name_create(): Column_name_createContext[]; + public column_name_create(i: number): Column_name_createContext | null; + public column_name_create(i?: number): Column_name_createContext[] | Column_name_createContext | null { + if (i === undefined) { + return this.getRuleContexts(Column_name_createContext); + } + + return this.getRuleContext(i, Column_name_createContext); } - public KW_GRANT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_GRANT, 0)!; + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public KW_OPTION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OPTION, 0)!; + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_grant_grant_option; + return PostgreSqlParser.RULE_opt_column_list_create; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_grant_grant_option) { - listener.enterOpt_grant_grant_option(this); + if(listener.enterOpt_column_list_create) { + listener.enterOpt_column_list_create(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_grant_grant_option) { - listener.exitOpt_grant_grant_option(this); + if(listener.exitOpt_column_list_create) { + listener.exitOpt_column_list_create(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_grant_grant_option) { - return visitor.visitOpt_grant_grant_option(this); + if (visitor.visitOpt_column_list_create) { + return visitor.visitOpt_column_list_create(this); } else { return visitor.visitChildren(this); } @@ -88686,44 +63362,44 @@ export class Opt_grant_grant_optionContext extends antlr.ParserRuleContext { } -export class GrantrolestmtContext extends antlr.ParserRuleContext { +export class Column_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_GRANT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_GRANT, 0)!; - } - public privilege_list(): Privilege_listContext { - return this.getRuleContext(0, Privilege_listContext)!; - } - public KW_TO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TO, 0)!; - } - public role_list(): Role_listContext { - return this.getRuleContext(0, Role_listContext)!; - } - public opt_grant_admin_option(): Opt_grant_admin_optionContext | null { - return this.getRuleContext(0, Opt_grant_admin_optionContext); + public column_name(): Column_nameContext[]; + public column_name(i: number): Column_nameContext | null; + public column_name(i?: number): Column_nameContext[] | Column_nameContext | null { + if (i === undefined) { + return this.getRuleContexts(Column_nameContext); + } + + return this.getRuleContext(i, Column_nameContext); } - public opt_granted_by(): Opt_granted_byContext | null { - return this.getRuleContext(0, Opt_granted_byContext); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_grantrolestmt; + return PostgreSqlParser.RULE_column_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGrantrolestmt) { - listener.enterGrantrolestmt(this); + if(listener.enterColumn_list) { + listener.enterColumn_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGrantrolestmt) { - listener.exitGrantrolestmt(this); + if(listener.exitColumn_list) { + listener.exitColumn_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGrantrolestmt) { - return visitor.visitGrantrolestmt(this); + if (visitor.visitColumn_list) { + return visitor.visitColumn_list(this); } else { return visitor.visitChildren(this); } @@ -88731,53 +63407,32 @@ export class GrantrolestmtContext extends antlr.ParserRuleContext { } -export class RevokerolestmtContext extends antlr.ParserRuleContext { +export class Opt_c_includeContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_REVOKE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_REVOKE, 0)!; - } - public privilege_list(): Privilege_listContext { - return this.getRuleContext(0, Privilege_listContext)!; - } - public KW_FROM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FROM, 0)!; - } - public role_list(): Role_listContext { - return this.getRuleContext(0, Role_listContext)!; - } - public opt_granted_by(): Opt_granted_byContext | null { - return this.getRuleContext(0, Opt_granted_byContext); - } - public opt_drop_behavior(): Opt_drop_behaviorContext | null { - return this.getRuleContext(0, Opt_drop_behaviorContext); - } - public KW_ADMIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADMIN, 0); - } - public KW_OPTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPTION, 0); + public KW_INCLUDE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_INCLUDE, 0)!; } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); + public opt_column_list(): Opt_column_listContext { + return this.getRuleContext(0, Opt_column_listContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_revokerolestmt; + return PostgreSqlParser.RULE_opt_c_include; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRevokerolestmt) { - listener.enterRevokerolestmt(this); + if(listener.enterOpt_c_include) { + listener.enterOpt_c_include(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRevokerolestmt) { - listener.exitRevokerolestmt(this); + if(listener.exitOpt_c_include) { + listener.exitOpt_c_include(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRevokerolestmt) { - return visitor.visitRevokerolestmt(this); + if (visitor.visitOpt_c_include) { + return visitor.visitOpt_c_include(this); } else { return visitor.visitChildren(this); } @@ -88785,35 +63440,38 @@ export class RevokerolestmtContext extends antlr.ParserRuleContext { } -export class Opt_grant_admin_optionContext extends antlr.ParserRuleContext { +export class Key_matchContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; + public KW_MATCH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_MATCH, 0)!; + } + public KW_FULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FULL, 0); } - public KW_ADMIN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ADMIN, 0)!; + public KW_PARTIAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARTIAL, 0); } - public KW_OPTION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OPTION, 0)!; + public KW_SIMPLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SIMPLE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_grant_admin_option; + return PostgreSqlParser.RULE_key_match; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_grant_admin_option) { - listener.enterOpt_grant_admin_option(this); + if(listener.enterKey_match) { + listener.enterKey_match(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_grant_admin_option) { - listener.exitOpt_grant_admin_option(this); + if(listener.exitKey_match) { + listener.exitKey_match(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_grant_admin_option) { - return visitor.visitOpt_grant_admin_option(this); + if (visitor.visitKey_match) { + return visitor.visitKey_match(this); } else { return visitor.visitChildren(this); } @@ -88821,35 +63479,44 @@ export class Opt_grant_admin_optionContext extends antlr.ParserRuleContext { } -export class Opt_granted_byContext extends antlr.ParserRuleContext { +export class ExclusionconstraintelemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_GRANTED(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_GRANTED, 0)!; + public index_elem(): Index_elemContext { + return this.getRuleContext(0, Index_elemContext)!; } - public KW_BY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BY, 0)!; + public KW_WITH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WITH, 0)!; } - public rolespec(): RolespecContext { - return this.getRuleContext(0, RolespecContext)!; + public any_operator(): Any_operatorContext | null { + return this.getRuleContext(0, Any_operatorContext); + } + public KW_OPERATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); + } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_granted_by; + return PostgreSqlParser.RULE_exclusionconstraintelem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_granted_by) { - listener.enterOpt_granted_by(this); + if(listener.enterExclusionconstraintelem) { + listener.enterExclusionconstraintelem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_granted_by) { - listener.exitOpt_granted_by(this); + if(listener.exitExclusionconstraintelem) { + listener.exitExclusionconstraintelem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_granted_by) { - return visitor.visitOpt_granted_by(this); + if (visitor.visitExclusionconstraintelem) { + return visitor.visitExclusionconstraintelem(this); } else { return visitor.visitChildren(this); } @@ -88857,41 +63524,32 @@ export class Opt_granted_byContext extends antlr.ParserRuleContext { } -export class AlterdefaultprivilegesstmtContext extends antlr.ParserRuleContext { +export class Key_actionsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_DEFAULT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0)!; - } - public KW_PRIVILEGES(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PRIVILEGES, 0)!; - } - public defacloptionlist(): DefacloptionlistContext { - return this.getRuleContext(0, DefacloptionlistContext)!; + public key_update(): Key_updateContext | null { + return this.getRuleContext(0, Key_updateContext); } - public defaclaction(): DefaclactionContext { - return this.getRuleContext(0, DefaclactionContext)!; + public key_delete(): Key_deleteContext | null { + return this.getRuleContext(0, Key_deleteContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterdefaultprivilegesstmt; + return PostgreSqlParser.RULE_key_actions; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterdefaultprivilegesstmt) { - listener.enterAlterdefaultprivilegesstmt(this); + if(listener.enterKey_actions) { + listener.enterKey_actions(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterdefaultprivilegesstmt) { - listener.exitAlterdefaultprivilegesstmt(this); + if(listener.exitKey_actions) { + listener.exitKey_actions(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterdefaultprivilegesstmt) { - return visitor.visitAlterdefaultprivilegesstmt(this); + if (visitor.visitKey_actions) { + return visitor.visitKey_actions(this); } else { return visitor.visitChildren(this); } @@ -88899,35 +63557,35 @@ export class AlterdefaultprivilegesstmtContext extends antlr.ParserRuleContext { } -export class DefacloptionlistContext extends antlr.ParserRuleContext { +export class Key_updateContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public defacloption(): DefacloptionContext[]; - public defacloption(i: number): DefacloptionContext | null; - public defacloption(i?: number): DefacloptionContext[] | DefacloptionContext | null { - if (i === undefined) { - return this.getRuleContexts(DefacloptionContext); - } - - return this.getRuleContext(i, DefacloptionContext); + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; + } + public KW_UPDATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_UPDATE, 0)!; + } + public key_action(): Key_actionContext { + return this.getRuleContext(0, Key_actionContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_defacloptionlist; + return PostgreSqlParser.RULE_key_update; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDefacloptionlist) { - listener.enterDefacloptionlist(this); + if(listener.enterKey_update) { + listener.enterKey_update(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDefacloptionlist) { - listener.exitDefacloptionlist(this); + if(listener.exitKey_update) { + listener.exitKey_update(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDefacloptionlist) { - return visitor.visitDefacloptionlist(this); + if (visitor.visitKey_update) { + return visitor.visitKey_update(this); } else { return visitor.visitChildren(this); } @@ -88935,47 +63593,35 @@ export class DefacloptionlistContext extends antlr.ParserRuleContext { } -export class DefacloptionContext extends antlr.ParserRuleContext { +export class Key_deleteContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); - } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); - } - public schema_name_list(): Schema_name_listContext | null { - return this.getRuleContext(0, Schema_name_listContext); - } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); - } - public KW_ROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLE, 0); + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; } - public role_list(): Role_listContext | null { - return this.getRuleContext(0, Role_listContext); + public KW_DELETE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DELETE, 0)!; } - public KW_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USER, 0); + public key_action(): Key_actionContext { + return this.getRuleContext(0, Key_actionContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_defacloption; + return PostgreSqlParser.RULE_key_delete; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDefacloption) { - listener.enterDefacloption(this); + if(listener.enterKey_delete) { + listener.enterKey_delete(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDefacloption) { - listener.exitDefacloption(this); + if(listener.exitKey_delete) { + listener.exitKey_delete(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDefacloption) { - return visitor.visitDefacloption(this); + if (visitor.visitKey_delete) { + return visitor.visitKey_delete(this); } else { return visitor.visitChildren(this); } @@ -88983,62 +63629,50 @@ export class DefacloptionContext extends antlr.ParserRuleContext { } -export class DefaclactionContext extends antlr.ParserRuleContext { +export class Key_actionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_GRANT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GRANT, 0); - } - public privileges(): PrivilegesContext { - return this.getRuleContext(0, PrivilegesContext)!; - } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; - } - public defacl_privilege_target(): Defacl_privilege_targetContext { - return this.getRuleContext(0, Defacl_privilege_targetContext)!; - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); } - public grantee_list(): Grantee_listContext { - return this.getRuleContext(0, Grantee_listContext)!; + public KW_ACTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ACTION, 0); } - public opt_grant_grant_option(): Opt_grant_grant_optionContext | null { - return this.getRuleContext(0, Opt_grant_grant_optionContext); + public KW_RESTRICT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESTRICT, 0); } - public KW_REVOKE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REVOKE, 0); + public KW_CASCADE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CASCADE, 0); } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public opt_drop_behavior(): Opt_drop_behaviorContext | null { - return this.getRuleContext(0, Opt_drop_behaviorContext); + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULL, 0); } - public KW_OPTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPTION, 0); + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); + public column_list(): Column_listContext | null { + return this.getRuleContext(0, Column_listContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_defaclaction; + return PostgreSqlParser.RULE_key_action; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDefaclaction) { - listener.enterDefaclaction(this); + if(listener.enterKey_action) { + listener.enterKey_action(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDefaclaction) { - listener.exitDefaclaction(this); + if(listener.exitKey_action) { + listener.exitKey_action(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDefaclaction) { - return visitor.visitDefaclaction(this); + if (visitor.visitKey_action) { + return visitor.visitKey_action(this); } else { return visitor.visitChildren(this); } @@ -89046,44 +63680,38 @@ export class DefaclactionContext extends antlr.ParserRuleContext { } -export class Defacl_privilege_targetContext extends antlr.ParserRuleContext { +export class OptinheritContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_TABLES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLES, 0); - } - public KW_FUNCTIONS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTIONS, 0); - } - public KW_ROUTINES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINES, 0); + public KW_INHERITS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_INHERITS, 0)!; } - public KW_SEQUENCES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCES, 0); + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public KW_TYPES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPES, 0); + public qualified_name_list(): Qualified_name_listContext { + return this.getRuleContext(0, Qualified_name_listContext)!; } - public KW_SCHEMAS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMAS, 0); + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_defacl_privilege_target; + return PostgreSqlParser.RULE_optinherit; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDefacl_privilege_target) { - listener.enterDefacl_privilege_target(this); + if(listener.enterOptinherit) { + listener.enterOptinherit(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDefacl_privilege_target) { - listener.exitDefacl_privilege_target(this); + if(listener.exitOptinherit) { + listener.exitOptinherit(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDefacl_privilege_target) { - return visitor.visitDefacl_privilege_target(this); + if (visitor.visitOptinherit) { + return visitor.visitOptinherit(this); } else { return visitor.visitChildren(this); } @@ -89091,77 +63719,59 @@ export class Defacl_privilege_targetContext extends antlr.ParserRuleContext { } -export class IndexstmtContext extends antlr.ParserRuleContext { +export class PartitionspecContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_INDEX(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INDEX, 0)!; + public KW_PARTITION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_PARTITION, 0)!; } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; + public KW_BY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_BY, 0)!; } - public relation_expr(): Relation_exprContext { - return this.getRuleContext(0, Relation_exprContext)!; + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } public OPEN_PAREN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public index_params(): Index_paramsContext { - return this.getRuleContext(0, Index_paramsContext)!; + public part_elem(): Part_elemContext[]; + public part_elem(i: number): Part_elemContext | null; + public part_elem(i?: number): Part_elemContext[] | Part_elemContext | null { + if (i === undefined) { + return this.getRuleContexts(Part_elemContext); + } + + return this.getRuleContext(i, Part_elemContext); } public CLOSE_PAREN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public opt_unique(): Opt_uniqueContext | null { - return this.getRuleContext(0, Opt_uniqueContext); - } - public opt_concurrently(): Opt_concurrentlyContext | null { - return this.getRuleContext(0, Opt_concurrentlyContext); - } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); - } - public opt_index_name(): Opt_index_nameContext | null { - return this.getRuleContext(0, Opt_index_nameContext); - } - public access_method_clause(): Access_method_clauseContext | null { - return this.getRuleContext(0, Access_method_clauseContext); - } - public opt_include(): Opt_includeContext | null { - return this.getRuleContext(0, Opt_includeContext); - } - public nulls_distinct(): Nulls_distinctContext | null { - return this.getRuleContext(0, Nulls_distinctContext); - } - public opt_reloptions(): Opt_reloptionsContext | null { - return this.getRuleContext(0, Opt_reloptionsContext); - } - public opttablespace(): OpttablespaceContext | null { - return this.getRuleContext(0, OpttablespaceContext); - } - public where_clause(): Where_clauseContext | null { - return this.getRuleContext(0, Where_clauseContext); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_indexstmt; + return PostgreSqlParser.RULE_partitionspec; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIndexstmt) { - listener.enterIndexstmt(this); + if(listener.enterPartitionspec) { + listener.enterPartitionspec(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIndexstmt) { - listener.exitIndexstmt(this); + if(listener.exitPartitionspec) { + listener.exitPartitionspec(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIndexstmt) { - return visitor.visitIndexstmt(this); + if (visitor.visitPartitionspec) { + return visitor.visitPartitionspec(this); } else { return visitor.visitChildren(this); } @@ -89169,59 +63779,47 @@ export class IndexstmtContext extends antlr.ParserRuleContext { } -export class Opt_uniqueContext extends antlr.ParserRuleContext { +export class Part_elemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_UNIQUE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_UNIQUE, 0)!; + public column_name(): Column_nameContext | null { + return this.getRuleContext(0, Column_nameContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_unique; + public func_expr_windowless(): Func_expr_windowlessContext | null { + return this.getRuleContext(0, Func_expr_windowlessContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_unique) { - listener.enterOpt_unique(this); - } + public opt_collate_clause(): Opt_collate_clauseContext | null { + return this.getRuleContext(0, Opt_collate_clauseContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_unique) { - listener.exitOpt_unique(this); - } + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_unique) { - return visitor.visitOpt_unique(this); - } else { - return visitor.visitChildren(this); - } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } -} - - -export class Opt_concurrentlyContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } - public KW_CONCURRENTLY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CONCURRENTLY, 0)!; + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_concurrently; + return PostgreSqlParser.RULE_part_elem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_concurrently) { - listener.enterOpt_concurrently(this); + if(listener.enterPart_elem) { + listener.enterPart_elem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_concurrently) { - listener.exitOpt_concurrently(this); + if(listener.exitPart_elem) { + listener.exitPart_elem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_concurrently) { - return visitor.visitOpt_concurrently(this); + if (visitor.visitPart_elem) { + return visitor.visitPart_elem(this); } else { return visitor.visitChildren(this); } @@ -89229,29 +63827,32 @@ export class Opt_concurrentlyContext extends antlr.ParserRuleContext { } -export class Opt_index_nameContext extends antlr.ParserRuleContext { +export class Table_access_method_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public KW_USING(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_USING, 0)!; + } + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_index_name; + return PostgreSqlParser.RULE_table_access_method_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_index_name) { - listener.enterOpt_index_name(this); + if(listener.enterTable_access_method_clause) { + listener.enterTable_access_method_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_index_name) { - listener.exitOpt_index_name(this); + if(listener.exitTable_access_method_clause) { + listener.exitTable_access_method_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_index_name) { - return visitor.visitOpt_index_name(this); + if (visitor.visitTable_access_method_clause) { + return visitor.visitTable_access_method_clause(this); } else { return visitor.visitChildren(this); } @@ -89259,32 +63860,38 @@ export class Opt_index_nameContext extends antlr.ParserRuleContext { } -export class Access_method_clauseContext extends antlr.ParserRuleContext { +export class OptwithContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); + } + public reloptions(): ReloptionsContext | null { + return this.getRuleContext(0, ReloptionsContext); + } + public KW_OIDS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OIDS, 0); } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public KW_WITHOUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_access_method_clause; + return PostgreSqlParser.RULE_optwith; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAccess_method_clause) { - listener.enterAccess_method_clause(this); + if(listener.enterOptwith) { + listener.enterOptwith(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAccess_method_clause) { - listener.exitAccess_method_clause(this); + if(listener.exitOptwith) { + listener.exitOptwith(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAccess_method_clause) { - return visitor.visitAccess_method_clause(this); + if (visitor.visitOptwith) { + return visitor.visitOptwith(this); } else { return visitor.visitChildren(this); } @@ -89292,44 +63899,44 @@ export class Access_method_clauseContext extends antlr.ParserRuleContext { } -export class Index_paramsContext extends antlr.ParserRuleContext { +export class OncommitoptionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public index_elem(): Index_elemContext[]; - public index_elem(i: number): Index_elemContext | null; - public index_elem(i?: number): Index_elemContext[] | Index_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Index_elemContext); - } - - return this.getRuleContext(i, Index_elemContext); + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_COMMIT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_COMMIT, 0)!; + } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); + } + public KW_DELETE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DELETE, 0); + } + public KW_ROWS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROWS, 0); + } + public KW_PRESERVE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRESERVE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_index_params; + return PostgreSqlParser.RULE_oncommitoption; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIndex_params) { - listener.enterIndex_params(this); + if(listener.enterOncommitoption) { + listener.enterOncommitoption(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIndex_params) { - listener.exitIndex_params(this); + if(listener.exitOncommitoption) { + listener.exitOncommitoption(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIndex_params) { - return visitor.visitIndex_params(this); + if (visitor.visitOncommitoption) { + return visitor.visitOncommitoption(this); } else { return visitor.visitChildren(this); } @@ -89337,44 +63944,32 @@ export class Index_paramsContext extends antlr.ParserRuleContext { } -export class Index_elem_optionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public opt_collate(): Opt_collateContext | null { - return this.getRuleContext(0, Opt_collateContext); - } - public opt_class(): Opt_classContext | null { - return this.getRuleContext(0, Opt_classContext); - } - public opt_asc_desc(): Opt_asc_descContext | null { - return this.getRuleContext(0, Opt_asc_descContext); - } - public opt_nulls_order(): Opt_nulls_orderContext | null { - return this.getRuleContext(0, Opt_nulls_orderContext); +export class OpttablespaceContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); + public KW_TABLESPACE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0)!; } - public reloptions(): ReloptionsContext | null { - return this.getRuleContext(0, ReloptionsContext); + public tablespace_name(): Tablespace_nameContext { + return this.getRuleContext(0, Tablespace_nameContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_index_elem_options; + return PostgreSqlParser.RULE_opttablespace; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIndex_elem_options) { - listener.enterIndex_elem_options(this); + if(listener.enterOpttablespace) { + listener.enterOpttablespace(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIndex_elem_options) { - listener.exitIndex_elem_options(this); + if(listener.exitOpttablespace) { + listener.exitOpttablespace(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIndex_elem_options) { - return visitor.visitIndex_elem_options(this); + if (visitor.visitOpttablespace) { + return visitor.visitOpttablespace(this); } else { return visitor.visitChildren(this); } @@ -89382,44 +63977,35 @@ export class Index_elem_optionsContext extends antlr.ParserRuleContext { } -export class Index_elemContext extends antlr.ParserRuleContext { +export class OptconstablespaceContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public column_name(): Column_nameContext | null { - return this.getRuleContext(0, Column_nameContext); - } - public index_elem_options(): Index_elem_optionsContext { - return this.getRuleContext(0, Index_elem_optionsContext)!; - } - public func_expr_windowless(): Func_expr_windowlessContext | null { - return this.getRuleContext(0, Func_expr_windowlessContext); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_USING(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_USING, 0)!; } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public KW_INDEX(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_INDEX, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public opttablespace(): OpttablespaceContext { + return this.getRuleContext(0, OpttablespaceContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_index_elem; + return PostgreSqlParser.RULE_optconstablespace; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIndex_elem) { - listener.enterIndex_elem(this); + if(listener.enterOptconstablespace) { + listener.enterOptconstablespace(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIndex_elem) { - listener.exitIndex_elem(this); + if(listener.exitOptconstablespace) { + listener.exitOptconstablespace(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIndex_elem) { - return visitor.visitIndex_elem(this); + if (visitor.visitOptconstablespace) { + return visitor.visitOptconstablespace(this); } else { return visitor.visitChildren(this); } @@ -89427,38 +64013,35 @@ export class Index_elemContext extends antlr.ParserRuleContext { } -export class Opt_includeContext extends antlr.ParserRuleContext { +export class ExistingindexContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_INCLUDE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INCLUDE, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_USING(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_USING, 0)!; } - public index_including_params(): Index_including_paramsContext { - return this.getRuleContext(0, Index_including_paramsContext)!; + public KW_INDEX(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_INDEX, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_include; + return PostgreSqlParser.RULE_existingindex; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_include) { - listener.enterOpt_include(this); + if(listener.enterExistingindex) { + listener.enterExistingindex(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_include) { - listener.exitOpt_include(this); + if(listener.exitExistingindex) { + listener.exitExistingindex(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_include) { - return visitor.visitOpt_include(this); + if (visitor.visitExistingindex) { + return visitor.visitExistingindex(this); } else { return visitor.visitChildren(this); } @@ -89466,18 +64049,39 @@ export class Opt_includeContext extends antlr.ParserRuleContext { } -export class Index_including_paramsContext extends antlr.ParserRuleContext { +export class CreatestatsstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public index_elem(): Index_elemContext[]; - public index_elem(i: number): Index_elemContext | null; - public index_elem(i?: number): Index_elemContext[] | Index_elemContext | null { + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + } + public KW_STATISTICS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_STATISTICS, 0)!; + } + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; + } + public from_clause(): From_clauseContext { + return this.getRuleContext(0, From_clauseContext)!; + } + public column_expr(): Column_exprContext[]; + public column_expr(i: number): Column_exprContext | null; + public column_expr(i?: number): Column_exprContext[] | Column_exprContext | null { if (i === undefined) { - return this.getRuleContexts(Index_elemContext); + return this.getRuleContexts(Column_exprContext); } - return this.getRuleContext(i, Index_elemContext); + return this.getRuleContext(i, Column_exprContext); + } + public expr_list(): Expr_listContext | null { + return this.getRuleContext(0, Expr_listContext); + } + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); + } + public opt_column_list(): Opt_column_listContext | null { + return this.getRuleContext(0, Opt_column_listContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -89488,22 +64092,25 @@ export class Index_including_paramsContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.COMMA, i); } } + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_index_including_params; + return PostgreSqlParser.RULE_createstatsstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIndex_including_params) { - listener.enterIndex_including_params(this); + if(listener.enterCreatestatsstmt) { + listener.enterCreatestatsstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIndex_including_params) { - listener.exitIndex_including_params(this); + if(listener.exitCreatestatsstmt) { + listener.exitCreatestatsstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIndex_including_params) { - return visitor.visitIndex_including_params(this); + if (visitor.visitCreatestatsstmt) { + return visitor.visitCreatestatsstmt(this); } else { return visitor.visitChildren(this); } @@ -89511,32 +64118,50 @@ export class Index_including_paramsContext extends antlr.ParserRuleContext { } -export class Opt_collateContext extends antlr.ParserRuleContext { +export class AlterstatsstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_COLLATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_COLLATE, 0)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public KW_STATISTICS(): antlr.TerminalNode[]; + public KW_STATISTICS(i: number): antlr.TerminalNode | null; + public KW_STATISTICS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_STATISTICS); + } else { + return this.getToken(PostgreSqlParser.KW_STATISTICS, i); + } } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext)!; } + public KW_SET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SET, 0)!; + } + public signediconst(): SignediconstContext { + return this.getRuleContext(0, SignediconstContext)!; + } + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_collate; + return PostgreSqlParser.RULE_alterstatsstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_collate) { - listener.enterOpt_collate(this); + if(listener.enterAlterstatsstmt) { + listener.enterAlterstatsstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_collate) { - listener.exitOpt_collate(this); + if(listener.exitAlterstatsstmt) { + listener.exitAlterstatsstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_collate) { - return visitor.visitOpt_collate(this); + if (visitor.visitAlterstatsstmt) { + return visitor.visitAlterstatsstmt(this); } else { return visitor.visitChildren(this); } @@ -89544,29 +64169,59 @@ export class Opt_collateContext extends antlr.ParserRuleContext { } -export class Opt_classContext extends antlr.ParserRuleContext { +export class CreateasstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; - } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_class; + return PostgreSqlParser.RULE_createasstmt; + } + public override copyFrom(ctx: CreateasstmtContext): void { + super.copyFrom(ctx); + } +} +export class QueryCreateTableContext extends CreateasstmtContext { + public constructor(ctx: CreateasstmtContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + } + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TABLE, 0)!; + } + public create_as_target(): Create_as_targetContext { + return this.getRuleContext(0, Create_as_targetContext)!; + } + public KW_AS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_AS, 0)!; + } + public selectstmt(): SelectstmtContext { + return this.getRuleContext(0, SelectstmtContext)!; + } + public opttemp(): OpttempContext | null { + return this.getRuleContext(0, OpttempContext); + } + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); + } + public opt_with_data(): Opt_with_dataContext | null { + return this.getRuleContext(0, Opt_with_dataContext); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_class) { - listener.enterOpt_class(this); + if(listener.enterQueryCreateTable) { + listener.enterQueryCreateTable(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_class) { - listener.exitOpt_class(this); + if(listener.exitQueryCreateTable) { + listener.exitQueryCreateTable(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_class) { - return visitor.visitOpt_class(this); + if (visitor.visitQueryCreateTable) { + return visitor.visitQueryCreateTable(this); } else { return visitor.visitChildren(this); } @@ -89574,32 +64229,44 @@ export class Opt_classContext extends antlr.ParserRuleContext { } -export class Opt_asc_descContext extends antlr.ParserRuleContext { +export class Create_as_targetContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ASC(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ASC, 0); + public table_name_create(): Table_name_createContext { + return this.getRuleContext(0, Table_name_createContext)!; } - public KW_DESC(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DESC, 0); + public opt_column_list_create(): Opt_column_list_createContext | null { + return this.getRuleContext(0, Opt_column_list_createContext); + } + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); + } + public optwith(): OptwithContext | null { + return this.getRuleContext(0, OptwithContext); + } + public oncommitoption(): OncommitoptionContext | null { + return this.getRuleContext(0, OncommitoptionContext); + } + public opttablespace(): OpttablespaceContext | null { + return this.getRuleContext(0, OpttablespaceContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_asc_desc; + return PostgreSqlParser.RULE_create_as_target; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_asc_desc) { - listener.enterOpt_asc_desc(this); + if(listener.enterCreate_as_target) { + listener.enterCreate_as_target(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_asc_desc) { - listener.exitOpt_asc_desc(this); + if(listener.exitCreate_as_target) { + listener.exitCreate_as_target(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_asc_desc) { - return visitor.visitOpt_asc_desc(this); + if (visitor.visitCreate_as_target) { + return visitor.visitCreate_as_target(this); } else { return visitor.visitChildren(this); } @@ -89607,35 +64274,35 @@ export class Opt_asc_descContext extends antlr.ParserRuleContext { } -export class Opt_nulls_orderContext extends antlr.ParserRuleContext { +export class Opt_with_dataContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_NULLS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_NULLS, 0)!; + public KW_WITH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WITH, 0)!; } - public KW_FIRST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FIRST, 0); + public KW_DATA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATA, 0); } - public KW_LAST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LAST, 0); + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_nulls_order; + return PostgreSqlParser.RULE_opt_with_data; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_nulls_order) { - listener.enterOpt_nulls_order(this); + if(listener.enterOpt_with_data) { + listener.enterOpt_with_data(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_nulls_order) { - listener.exitOpt_nulls_order(this); + if(listener.exitOpt_with_data) { + listener.exitOpt_with_data(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_nulls_order) { - return visitor.visitOpt_nulls_order(this); + if (visitor.visitOpt_with_data) { + return visitor.visitOpt_with_data(this); } else { return visitor.visitChildren(this); } @@ -89643,74 +64310,74 @@ export class Opt_nulls_orderContext extends antlr.ParserRuleContext { } -export class CreatefunctionstmtContext extends antlr.ParserRuleContext { +export class CreatematviewstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public func_args_with_defaults(): Func_args_with_defaultsContext { - return this.getRuleContext(0, Func_args_with_defaultsContext)!; + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_creatematviewstmt; } - public createfunc_opt_list(): Createfunc_opt_listContext { - return this.getRuleContext(0, Createfunc_opt_listContext)!; + public override copyFrom(ctx: CreatematviewstmtContext): void { + super.copyFrom(ctx); } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); +} +export class CreateMaterializedViewContext extends CreatematviewstmtContext { + public constructor(ctx: CreatematviewstmtContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public function_name_create(): Function_name_createContext | null { - return this.getRuleContext(0, Function_name_createContext); + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + public KW_MATERIALIZED(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0)!; } - public procedure_name_create(): Procedure_name_createContext | null { - return this.getRuleContext(0, Procedure_name_createContext); + public KW_VIEW(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_VIEW, 0)!; } - public opt_or_replace(): Opt_or_replaceContext | null { - return this.getRuleContext(0, Opt_or_replaceContext); + public view_name_create(): View_name_createContext { + return this.getRuleContext(0, View_name_createContext)!; } - public KW_RETURNS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RETURNS, 0); + public KW_AS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_AS, 0)!; } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); + public selectstmt(): SelectstmtContext { + return this.getRuleContext(0, SelectstmtContext)!; } - public attrilist(): AttrilistContext | null { - return this.getRuleContext(0, AttrilistContext); + public KW_UNLOGGED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNLOGGED, 0); } - public func_return(): Func_returnContext | null { - return this.getRuleContext(0, Func_returnContext); + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); + public opt_column_list_create(): Opt_column_list_createContext | null { + return this.getRuleContext(0, Opt_column_list_createContext); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); } - public table_func_column_list(): Table_func_column_listContext | null { - return this.getRuleContext(0, Table_func_column_listContext); + public opt_reloptions(): Opt_reloptionsContext | null { + return this.getRuleContext(0, Opt_reloptionsContext); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public opttablespace(): OpttablespaceContext | null { + return this.getRuleContext(0, OpttablespaceContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createfunctionstmt; + public opt_with_data(): Opt_with_dataContext | null { + return this.getRuleContext(0, Opt_with_dataContext); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatefunctionstmt) { - listener.enterCreatefunctionstmt(this); + if(listener.enterCreateMaterializedView) { + listener.enterCreateMaterializedView(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatefunctionstmt) { - listener.exitCreatefunctionstmt(this); + if(listener.exitCreateMaterializedView) { + listener.exitCreateMaterializedView(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatefunctionstmt) { - return visitor.visitCreatefunctionstmt(this); + if (visitor.visitCreateMaterializedView) { + return visitor.visitCreateMaterializedView(this); } else { return visitor.visitChildren(this); } @@ -89718,50 +64385,44 @@ export class CreatefunctionstmtContext extends antlr.ParserRuleContext { } -export class AttrilistContext extends antlr.ParserRuleContext { +export class RefreshmatviewstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_REFRESH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_REFRESH, 0)!; } - public colid(): ColidContext[]; - public colid(i: number): ColidContext | null; - public colid(i?: number): ColidContext[] | ColidContext | null { - if (i === undefined) { - return this.getRuleContexts(ColidContext); - } - - return this.getRuleContext(i, ColidContext); + public KW_MATERIALIZED(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public KW_VIEW(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_VIEW, 0)!; } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public view_name(): View_nameContext { + return this.getRuleContext(0, View_nameContext)!; + } + public KW_CONCURRENTLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONCURRENTLY, 0); + } + public opt_with_data(): Opt_with_dataContext | null { + return this.getRuleContext(0, Opt_with_dataContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_attrilist; + return PostgreSqlParser.RULE_refreshmatviewstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAttrilist) { - listener.enterAttrilist(this); + if(listener.enterRefreshmatviewstmt) { + listener.enterRefreshmatviewstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAttrilist) { - listener.exitAttrilist(this); + if(listener.exitRefreshmatviewstmt) { + listener.exitRefreshmatviewstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAttrilist) { - return visitor.visitAttrilist(this); + if (visitor.visitRefreshmatviewstmt) { + return visitor.visitRefreshmatviewstmt(this); } else { return visitor.visitChildren(this); } @@ -89769,68 +64430,50 @@ export class AttrilistContext extends antlr.ParserRuleContext { } -export class Opt_or_replaceContext extends antlr.ParserRuleContext { +export class CreateseqstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_OR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OR, 0)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public KW_REPLACE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_REPLACE, 0)!; + public KW_SEQUENCE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_or_replace; + public qualified_name(): Qualified_nameContext { + return this.getRuleContext(0, Qualified_nameContext)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_or_replace) { - listener.enterOpt_or_replace(this); - } + public opttemp(): OpttempContext | null { + return this.getRuleContext(0, OpttempContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_or_replace) { - listener.exitOpt_or_replace(this); - } + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_or_replace) { - return visitor.visitOpt_or_replace(this); - } else { - return visitor.visitChildren(this); + public seqoptelem(): SeqoptelemContext[]; + public seqoptelem(i: number): SeqoptelemContext | null; + public seqoptelem(i?: number): SeqoptelemContext[] | SeqoptelemContext | null { + if (i === undefined) { + return this.getRuleContexts(SeqoptelemContext); } - } -} - -export class Func_argsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public func_args_list(): Func_args_listContext | null { - return this.getRuleContext(0, Func_args_listContext); + return this.getRuleContext(i, SeqoptelemContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_func_args; + return PostgreSqlParser.RULE_createseqstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunc_args) { - listener.enterFunc_args(this); + if(listener.enterCreateseqstmt) { + listener.enterCreateseqstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunc_args) { - listener.exitFunc_args(this); + if(listener.exitCreateseqstmt) { + listener.exitCreateseqstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunc_args) { - return visitor.visitFunc_args(this); + if (visitor.visitCreateseqstmt) { + return visitor.visitCreateseqstmt(this); } else { return visitor.visitChildren(this); } @@ -89838,44 +64481,47 @@ export class Func_argsContext extends antlr.ParserRuleContext { } -export class Func_args_listContext extends antlr.ParserRuleContext { +export class AlterseqstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public func_arg(): Func_argContext[]; - public func_arg(i: number): Func_argContext | null; - public func_arg(i?: number): Func_argContext[] | Func_argContext | null { + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public KW_SEQUENCE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0)!; + } + public qualified_name(): Qualified_nameContext { + return this.getRuleContext(0, Qualified_nameContext)!; + } + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); + } + public seqoptelem(): SeqoptelemContext[]; + public seqoptelem(i: number): SeqoptelemContext | null; + public seqoptelem(i?: number): SeqoptelemContext[] | SeqoptelemContext | null { if (i === undefined) { - return this.getRuleContexts(Func_argContext); + return this.getRuleContexts(SeqoptelemContext); } - return this.getRuleContext(i, Func_argContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + return this.getRuleContext(i, SeqoptelemContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_func_args_list; + return PostgreSqlParser.RULE_alterseqstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunc_args_list) { - listener.enterFunc_args_list(this); + if(listener.enterAlterseqstmt) { + listener.enterAlterseqstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunc_args_list) { - listener.exitFunc_args_list(this); + if(listener.exitAlterseqstmt) { + listener.exitAlterseqstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunc_args_list) { - return visitor.visitFunc_args_list(this); + if (visitor.visitAlterseqstmt) { + return visitor.visitAlterseqstmt(this); } else { return visitor.visitChildren(this); } @@ -89883,44 +64529,80 @@ export class Func_args_listContext extends antlr.ParserRuleContext { } -export class Routine_with_argtypes_listContext extends antlr.ParserRuleContext { +export class SeqoptelemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public routine_with_argtypes(): Routine_with_argtypesContext[]; - public routine_with_argtypes(i: number): Routine_with_argtypesContext | null; - public routine_with_argtypes(i?: number): Routine_with_argtypesContext[] | Routine_with_argtypesContext | null { - if (i === undefined) { - return this.getRuleContexts(Routine_with_argtypesContext); - } - - return this.getRuleContext(i, Routine_with_argtypesContext); + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); + } + public simpletypename(): SimpletypenameContext | null { + return this.getRuleContext(0, SimpletypenameContext); + } + public KW_CACHE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CACHE, 0); + } + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); + } + public KW_INCREMENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INCREMENT, 0); + } + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BY, 0); + } + public KW_MAXVALUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MAXVALUE, 0); + } + public KW_MINVALUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MINVALUE, 0); + } + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); + } + public KW_CYCLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CYCLE, 0); + } + public KW_OWNED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OWNED, 0); + } + public column_name(): Column_nameContext | null { + return this.getRuleContext(0, Column_nameContext); + } + public KW_SEQUENCE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); + } + public KW_NAME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NAME, 0); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); + } + public KW_START(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_START, 0); + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); + } + public KW_RESTART(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESTART, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_routine_with_argtypes_list; + return PostgreSqlParser.RULE_seqoptelem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRoutine_with_argtypes_list) { - listener.enterRoutine_with_argtypes_list(this); + if(listener.enterSeqoptelem) { + listener.enterSeqoptelem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRoutine_with_argtypes_list) { - listener.exitRoutine_with_argtypes_list(this); + if(listener.exitSeqoptelem) { + listener.exitSeqoptelem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRoutine_with_argtypes_list) { - return visitor.visitRoutine_with_argtypes_list(this); + if (visitor.visitSeqoptelem) { + return visitor.visitSeqoptelem(this); } else { return visitor.visitChildren(this); } @@ -89928,41 +64610,38 @@ export class Routine_with_argtypes_listContext extends antlr.ParserRuleContext { } -export class Routine_with_argtypesContext extends antlr.ParserRuleContext { +export class NumericonlyContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public routine_name(): Routine_nameContext | null { - return this.getRuleContext(0, Routine_nameContext); - } - public func_args(): Func_argsContext | null { - return this.getRuleContext(0, Func_argsContext); + public Numeric(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.Numeric, 0); } - public type_func_name_keyword(): Type_func_name_keywordContext | null { - return this.getRuleContext(0, Type_func_name_keywordContext); + public PLUS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.PLUS, 0); } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); + public MINUS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.MINUS, 0); } - public indirection(): IndirectionContext | null { - return this.getRuleContext(0, IndirectionContext); + public signediconst(): SignediconstContext | null { + return this.getRuleContext(0, SignediconstContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_routine_with_argtypes; + return PostgreSqlParser.RULE_numericonly; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRoutine_with_argtypes) { - listener.enterRoutine_with_argtypes(this); + if(listener.enterNumericonly) { + listener.enterNumericonly(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRoutine_with_argtypes) { - listener.exitRoutine_with_argtypes(this); + if(listener.exitNumericonly) { + listener.exitNumericonly(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRoutine_with_argtypes) { - return visitor.visitRoutine_with_argtypes(this); + if (visitor.visitNumericonly) { + return visitor.visitNumericonly(this); } else { return visitor.visitChildren(this); } @@ -89970,44 +64649,65 @@ export class Routine_with_argtypesContext extends antlr.ParserRuleContext { } -export class Procedure_with_argtypes_listContext extends antlr.ParserRuleContext { +export class CreateplangstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public procedure_with_argtypes(): Procedure_with_argtypesContext[]; - public procedure_with_argtypes(i: number): Procedure_with_argtypesContext | null; - public procedure_with_argtypes(i?: number): Procedure_with_argtypesContext[] | Procedure_with_argtypesContext | null { + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + } + public KW_LANGUAGE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0)!; + } + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; + } + public opt_or_replace(): Opt_or_replaceContext | null { + return this.getRuleContext(0, Opt_or_replaceContext); + } + public KW_TRUSTED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRUSTED, 0); + } + public KW_PROCEDURAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURAL, 0); + } + public KW_HANDLER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_HANDLER, 0); + } + public any_name(): Any_nameContext[]; + public any_name(i: number): Any_nameContext | null; + public any_name(i?: number): Any_nameContext[] | Any_nameContext | null { if (i === undefined) { - return this.getRuleContexts(Procedure_with_argtypesContext); + return this.getRuleContexts(Any_nameContext); } - return this.getRuleContext(i, Procedure_with_argtypesContext); + return this.getRuleContext(i, Any_nameContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_INLINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INLINE, 0); + } + public KW_VALIDATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALIDATOR, 0); + } + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_procedure_with_argtypes_list; + return PostgreSqlParser.RULE_createplangstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterProcedure_with_argtypes_list) { - listener.enterProcedure_with_argtypes_list(this); + if(listener.enterCreateplangstmt) { + listener.enterCreateplangstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitProcedure_with_argtypes_list) { - listener.exitProcedure_with_argtypes_list(this); + if(listener.exitCreateplangstmt) { + listener.exitCreateplangstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitProcedure_with_argtypes_list) { - return visitor.visitProcedure_with_argtypes_list(this); + if (visitor.visitCreateplangstmt) { + return visitor.visitCreateplangstmt(this); } else { return visitor.visitChildren(this); } @@ -90015,41 +64715,47 @@ export class Procedure_with_argtypes_listContext extends antlr.ParserRuleContext } -export class Procedure_with_argtypesContext extends antlr.ParserRuleContext { +export class CreatetablespacestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public procedure_name(): Procedure_nameContext | null { - return this.getRuleContext(0, Procedure_nameContext); + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public func_args(): Func_argsContext | null { - return this.getRuleContext(0, Func_argsContext); + public opttablespace(): OpttablespaceContext { + return this.getRuleContext(0, OpttablespaceContext)!; } - public type_func_name_keyword(): Type_func_name_keywordContext | null { - return this.getRuleContext(0, Type_func_name_keywordContext); + public KW_LOCATION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_LOCATION, 0)!; } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); + public sconst(): SconstContext { + return this.getRuleContext(0, SconstContext)!; } - public indirection(): IndirectionContext | null { - return this.getRuleContext(0, IndirectionContext); + public KW_OWNER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OWNER, 0); + } + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); + } + public opt_reloptions(): Opt_reloptionsContext | null { + return this.getRuleContext(0, Opt_reloptionsContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_procedure_with_argtypes; + return PostgreSqlParser.RULE_createtablespacestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterProcedure_with_argtypes) { - listener.enterProcedure_with_argtypes(this); + if(listener.enterCreatetablespacestmt) { + listener.enterCreatetablespacestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitProcedure_with_argtypes) { - listener.exitProcedure_with_argtypes(this); + if(listener.exitCreatetablespacestmt) { + listener.exitCreatetablespacestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitProcedure_with_argtypes) { - return visitor.visitProcedure_with_argtypes(this); + if (visitor.visitCreatetablespacestmt) { + return visitor.visitCreatetablespacestmt(this); } else { return visitor.visitChildren(this); } @@ -90057,44 +64763,95 @@ export class Procedure_with_argtypesContext extends antlr.ParserRuleContext { } -export class Function_with_argtypes_listContext extends antlr.ParserRuleContext { +export class CreateextensionstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public function_with_argtypes(): Function_with_argtypesContext[]; - public function_with_argtypes(i: number): Function_with_argtypesContext | null; - public function_with_argtypes(i?: number): Function_with_argtypesContext[] | Function_with_argtypesContext | null { + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + } + public KW_EXTENSION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EXTENSION, 0)!; + } + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; + } + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); + } + public KW_SCHEMA(): antlr.TerminalNode[]; + public KW_SCHEMA(i: number): antlr.TerminalNode | null; + public KW_SCHEMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_SCHEMA); + } else { + return this.getToken(PostgreSqlParser.KW_SCHEMA, i); + } + } + public schema_name(): Schema_nameContext[]; + public schema_name(i: number): Schema_nameContext | null; + public schema_name(i?: number): Schema_nameContext[] | Schema_nameContext | null { if (i === undefined) { - return this.getRuleContexts(Function_with_argtypesContext); + return this.getRuleContexts(Schema_nameContext); } - return this.getRuleContext(i, Function_with_argtypesContext); + return this.getRuleContext(i, Schema_nameContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext[]; + public nonreservedword_or_sconst(i: number): Nonreservedword_or_sconstContext | null; + public nonreservedword_or_sconst(i?: number): Nonreservedword_or_sconstContext[] | Nonreservedword_or_sconstContext | null { + if (i === undefined) { + return this.getRuleContexts(Nonreservedword_or_sconstContext); + } + + return this.getRuleContext(i, Nonreservedword_or_sconstContext); + } + public KW_CASCADE(): antlr.TerminalNode[]; + public KW_CASCADE(i: number): antlr.TerminalNode | null; + public KW_CASCADE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); + return this.getTokens(PostgreSqlParser.KW_CASCADE); } else { - return this.getToken(PostgreSqlParser.COMMA, i); + return this.getToken(PostgreSqlParser.KW_CASCADE, i); + } + } + public KW_VERSION(): antlr.TerminalNode[]; + public KW_VERSION(i: number): antlr.TerminalNode | null; + public KW_VERSION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_VERSION); + } else { + return this.getToken(PostgreSqlParser.KW_VERSION, i); + } + } + public KW_FROM(): antlr.TerminalNode[]; + public KW_FROM(i: number): antlr.TerminalNode | null; + public KW_FROM(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_FROM); + } else { + return this.getToken(PostgreSqlParser.KW_FROM, i); } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_function_with_argtypes_list; + return PostgreSqlParser.RULE_createextensionstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunction_with_argtypes_list) { - listener.enterFunction_with_argtypes_list(this); + if(listener.enterCreateextensionstmt) { + listener.enterCreateextensionstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunction_with_argtypes_list) { - listener.exitFunction_with_argtypes_list(this); + if(listener.exitCreateextensionstmt) { + listener.exitCreateextensionstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunction_with_argtypes_list) { - return visitor.visitFunction_with_argtypes_list(this); + if (visitor.visitCreateextensionstmt) { + return visitor.visitCreateextensionstmt(this); } else { return visitor.visitChildren(this); } @@ -90102,41 +64859,56 @@ export class Function_with_argtypes_listContext extends antlr.ParserRuleContext } -export class Function_with_argtypesContext extends antlr.ParserRuleContext { +export class AlterextensionstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public function_name(): Function_nameContext | null { - return this.getRuleContext(0, Function_nameContext); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public func_args(): Func_argsContext | null { - return this.getRuleContext(0, Func_argsContext); + public KW_EXTENSION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EXTENSION, 0)!; } - public type_func_name_keyword(): Type_func_name_keywordContext | null { - return this.getRuleContext(0, Type_func_name_keywordContext); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); + public KW_UPDATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_UPDATE, 0)!; } - public indirection(): IndirectionContext | null { - return this.getRuleContext(0, IndirectionContext); + public KW_TO(): antlr.TerminalNode[]; + public KW_TO(i: number): antlr.TerminalNode | null; + public KW_TO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_TO); + } else { + return this.getToken(PostgreSqlParser.KW_TO, i); + } + } + public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext[]; + public nonreservedword_or_sconst(i: number): Nonreservedword_or_sconstContext | null; + public nonreservedword_or_sconst(i?: number): Nonreservedword_or_sconstContext[] | Nonreservedword_or_sconstContext | null { + if (i === undefined) { + return this.getRuleContexts(Nonreservedword_or_sconstContext); + } + + return this.getRuleContext(i, Nonreservedword_or_sconstContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_function_with_argtypes; + return PostgreSqlParser.RULE_alterextensionstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunction_with_argtypes) { - listener.enterFunction_with_argtypes(this); + if(listener.enterAlterextensionstmt) { + listener.enterAlterextensionstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunction_with_argtypes) { - listener.exitFunction_with_argtypes(this); + if(listener.exitAlterextensionstmt) { + listener.exitAlterextensionstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunction_with_argtypes) { - return visitor.visitFunction_with_argtypes(this); + if (visitor.visitAlterextensionstmt) { + return visitor.visitAlterextensionstmt(this); } else { return visitor.visitChildren(this); } @@ -90144,80 +64916,131 @@ export class Function_with_argtypesContext extends antlr.ParserRuleContext { } -export class Func_args_with_defaultsContext extends antlr.ParserRuleContext { +export class AlterextensioncontentsstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public func_args_with_defaults_list(): Func_args_with_defaults_listContext | null { - return this.getRuleContext(0, Func_args_with_defaults_listContext); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_func_args_with_defaults; + public KW_EXTENSION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EXTENSION, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunc_args_with_defaults) { - listener.enterFunc_args_with_defaults(this); + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { + if (i === undefined) { + return this.getRuleContexts(ColidContext); } + + return this.getRuleContext(i, ColidContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunc_args_with_defaults) { - listener.exitFunc_args_with_defaults(this); - } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADD, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunc_args_with_defaults) { - return visitor.visitFunc_args_with_defaults(this); - } else { - return visitor.visitChildren(this); - } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); } -} - - -export class Func_args_with_defaults_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_TRANSFORM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0); } - public func_arg_with_default(): Func_arg_with_defaultContext[]; - public func_arg_with_default(i: number): Func_arg_with_defaultContext | null; - public func_arg_with_default(i?: number): Func_arg_with_defaultContext[] | Func_arg_with_defaultContext | null { + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); + } + public typename(): TypenameContext[]; + public typename(i: number): TypenameContext | null; + public typename(i?: number): TypenameContext[] | TypenameContext | null { if (i === undefined) { - return this.getRuleContexts(Func_arg_with_defaultContext); + return this.getRuleContexts(TypenameContext); } - return this.getRuleContext(i, Func_arg_with_defaultContext); + return this.getRuleContext(i, TypenameContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_LANGUAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); + } + public KW_ROUTINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); + } + public routine_with_argtypes(): Routine_with_argtypesContext | null { + return this.getRuleContext(0, Routine_with_argtypesContext); + } + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + } + public procedure_with_argtypes(): Procedure_with_argtypesContext | null { + return this.getRuleContext(0, Procedure_with_argtypesContext); + } + public KW_OPERATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); + } + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); + } + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); + } + public operator_with_argtypes(): Operator_with_argtypesContext | null { + return this.getRuleContext(0, Operator_with_argtypesContext); + } + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + } + public function_with_argtypes(): Function_with_argtypesContext | null { + return this.getRuleContext(0, Function_with_argtypesContext); + } + public KW_CAST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CAST, 0); + } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + } + public KW_AGGREGATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); + } + public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { + return this.getRuleContext(0, Aggregate_with_argtypesContext); + } + public object_type_name(): Object_type_nameContext | null { + return this.getRuleContext(0, Object_type_nameContext); + } + public object_type_any_name(): Object_type_any_nameContext | null { + return this.getRuleContext(0, Object_type_any_nameContext); + } + public KW_CLASS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CLASS, 0); + } + public KW_FAMILY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FAMILY, 0); + } + public KW_DOMAIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); + } + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_func_args_with_defaults_list; + return PostgreSqlParser.RULE_alterextensioncontentsstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunc_args_with_defaults_list) { - listener.enterFunc_args_with_defaults_list(this); + if(listener.enterAlterextensioncontentsstmt) { + listener.enterAlterextensioncontentsstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunc_args_with_defaults_list) { - listener.exitFunc_args_with_defaults_list(this); + if(listener.exitAlterextensioncontentsstmt) { + listener.exitAlterextensioncontentsstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunc_args_with_defaults_list) { - return visitor.visitFunc_args_with_defaults_list(this); + if (visitor.visitAlterextensioncontentsstmt) { + return visitor.visitAlterextensioncontentsstmt(this); } else { return visitor.visitChildren(this); } @@ -90225,35 +65048,53 @@ export class Func_args_with_defaults_listContext extends antlr.ParserRuleContext } -export class Func_argContext extends antlr.ParserRuleContext { +export class CreatefdwstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public arg_class(): Arg_classContext | null { - return this.getRuleContext(0, Arg_classContext); + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public func_type(): Func_typeContext { - return this.getRuleContext(0, Func_typeContext)!; + public KW_FOREIGN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; } - public param_name(): Param_nameContext | null { - return this.getRuleContext(0, Param_nameContext); + public KW_DATA(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DATA, 0)!; + } + public KW_WRAPPER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WRAPPER, 0)!; + } + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; + } + public create_generic_options(): Create_generic_optionsContext | null { + return this.getRuleContext(0, Create_generic_optionsContext); + } + public fdw_option(): Fdw_optionContext[]; + public fdw_option(i: number): Fdw_optionContext | null; + public fdw_option(i?: number): Fdw_optionContext[] | Fdw_optionContext | null { + if (i === undefined) { + return this.getRuleContexts(Fdw_optionContext); + } + + return this.getRuleContext(i, Fdw_optionContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_func_arg; + return PostgreSqlParser.RULE_createfdwstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunc_arg) { - listener.enterFunc_arg(this); + if(listener.enterCreatefdwstmt) { + listener.enterCreatefdwstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunc_arg) { - listener.exitFunc_arg(this); + if(listener.exitCreatefdwstmt) { + listener.exitCreatefdwstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunc_arg) { - return visitor.visitFunc_arg(this); + if (visitor.visitCreatefdwstmt) { + return visitor.visitCreatefdwstmt(this); } else { return visitor.visitChildren(this); } @@ -90261,38 +65102,38 @@ export class Func_argContext extends antlr.ParserRuleContext { } -export class Arg_classContext extends antlr.ParserRuleContext { +export class Fdw_optionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); + public KW_HANDLER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_HANDLER, 0); } - public KW_OUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OUT, 0); + public KW_VALIDATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALIDATOR, 0); } - public KW_INOUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INOUT, 0); + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); } - public KW_VARIADIC(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VARIADIC, 0); + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_arg_class; + return PostgreSqlParser.RULE_fdw_option; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterArg_class) { - listener.enterArg_class(this); + if(listener.enterFdw_option) { + listener.enterFdw_option(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitArg_class) { - listener.exitArg_class(this); + if(listener.exitFdw_option) { + listener.exitFdw_option(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitArg_class) { - return visitor.visitArg_class(this); + if (visitor.visitFdw_option) { + return visitor.visitFdw_option(this); } else { return visitor.visitChildren(this); } @@ -90300,29 +65141,53 @@ export class Arg_classContext extends antlr.ParserRuleContext { } -export class Param_nameContext extends antlr.ParserRuleContext { +export class AlterfdwstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public type_function_name(): Type_function_nameContext { - return this.getRuleContext(0, Type_function_nameContext)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public KW_FOREIGN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; + } + public KW_DATA(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DATA, 0)!; + } + public KW_WRAPPER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WRAPPER, 0)!; + } + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; + } + public alter_generic_options(): Alter_generic_optionsContext | null { + return this.getRuleContext(0, Alter_generic_optionsContext); + } + public fdw_option(): Fdw_optionContext[]; + public fdw_option(i: number): Fdw_optionContext | null; + public fdw_option(i?: number): Fdw_optionContext[] | Fdw_optionContext | null { + if (i === undefined) { + return this.getRuleContexts(Fdw_optionContext); + } + + return this.getRuleContext(i, Fdw_optionContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_param_name; + return PostgreSqlParser.RULE_alterfdwstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterParam_name) { - listener.enterParam_name(this); + if(listener.enterAlterfdwstmt) { + listener.enterAlterfdwstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitParam_name) { - listener.exitParam_name(this); + if(listener.exitAlterfdwstmt) { + listener.exitAlterfdwstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitParam_name) { - return visitor.visitParam_name(this); + if (visitor.visitAlterfdwstmt) { + return visitor.visitAlterfdwstmt(this); } else { return visitor.visitChildren(this); } @@ -90330,29 +65195,53 @@ export class Param_nameContext extends antlr.ParserRuleContext { } -export class Func_returnContext extends antlr.ParserRuleContext { +export class Create_generic_optionsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public func_type(): Func_typeContext { - return this.getRuleContext(0, Func_typeContext)!; + public KW_OPTIONS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_OPTIONS, 0)!; + } + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + } + public generic_option_elem(): Generic_option_elemContext[]; + public generic_option_elem(i: number): Generic_option_elemContext | null; + public generic_option_elem(i?: number): Generic_option_elemContext[] | Generic_option_elemContext | null { + if (i === undefined) { + return this.getRuleContexts(Generic_option_elemContext); + } + + return this.getRuleContext(i, Generic_option_elemContext); + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_func_return; + return PostgreSqlParser.RULE_create_generic_options; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunc_return) { - listener.enterFunc_return(this); + if(listener.enterCreate_generic_options) { + listener.enterCreate_generic_options(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunc_return) { - listener.exitFunc_return(this); + if(listener.exitCreate_generic_options) { + listener.exitCreate_generic_options(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunc_return) { - return visitor.visitFunc_return(this); + if (visitor.visitCreate_generic_options) { + return visitor.visitCreate_generic_options(this); } else { return visitor.visitChildren(this); } @@ -90360,44 +65249,53 @@ export class Func_returnContext extends antlr.ParserRuleContext { } -export class Func_typeContext extends antlr.ParserRuleContext { +export class Alter_generic_optionsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public typename(): TypenameContext | null { - return this.getRuleContext(0, TypenameContext); - } - public type_function_name(): Type_function_nameContext | null { - return this.getRuleContext(0, Type_function_nameContext); + public KW_OPTIONS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_OPTIONS, 0)!; } - public attrs(): AttrsContext | null { - return this.getRuleContext(0, AttrsContext); + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public PERCENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.PERCENT, 0); + public alter_generic_option_elem(): Alter_generic_option_elemContext[]; + public alter_generic_option_elem(i: number): Alter_generic_option_elemContext | null; + public alter_generic_option_elem(i?: number): Alter_generic_option_elemContext[] | Alter_generic_option_elemContext | null { + if (i === undefined) { + return this.getRuleContexts(Alter_generic_option_elemContext); + } + + return this.getRuleContext(i, Alter_generic_option_elemContext); } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public KW_SETOF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SETOF, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_func_type; + return PostgreSqlParser.RULE_alter_generic_options; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunc_type) { - listener.enterFunc_type(this); + if(listener.enterAlter_generic_options) { + listener.enterAlter_generic_options(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunc_type) { - listener.exitFunc_type(this); + if(listener.exitAlter_generic_options) { + listener.exitAlter_generic_options(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunc_type) { - return visitor.visitFunc_type(this); + if (visitor.visitAlter_generic_options) { + return visitor.visitAlter_generic_options(this); } else { return visitor.visitChildren(this); } @@ -90405,38 +65303,38 @@ export class Func_typeContext extends antlr.ParserRuleContext { } -export class Func_arg_with_defaultContext extends antlr.ParserRuleContext { +export class Alter_generic_option_elemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public func_arg(): Func_argContext { - return this.getRuleContext(0, Func_argContext)!; + public generic_option_elem(): Generic_option_elemContext { + return this.getRuleContext(0, Generic_option_elemContext)!; } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADD, 0); } - public EQUAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.EQUAL, 0); + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_func_arg_with_default; + return PostgreSqlParser.RULE_alter_generic_option_elem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunc_arg_with_default) { - listener.enterFunc_arg_with_default(this); + if(listener.enterAlter_generic_option_elem) { + listener.enterAlter_generic_option_elem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunc_arg_with_default) { - listener.exitFunc_arg_with_default(this); + if(listener.exitAlter_generic_option_elem) { + listener.exitAlter_generic_option_elem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunc_arg_with_default) { - return visitor.visitFunc_arg_with_default(this); + if (visitor.visitAlter_generic_option_elem) { + return visitor.visitAlter_generic_option_elem(this); } else { return visitor.visitChildren(this); } @@ -90444,29 +65342,32 @@ export class Func_arg_with_defaultContext extends antlr.ParserRuleContext { } -export class Aggr_argContext extends antlr.ParserRuleContext { +export class Generic_option_elemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public func_arg(): Func_argContext { - return this.getRuleContext(0, Func_argContext)!; + public collabel(): CollabelContext { + return this.getRuleContext(0, CollabelContext)!; + } + public sconst(): SconstContext { + return this.getRuleContext(0, SconstContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_aggr_arg; + return PostgreSqlParser.RULE_generic_option_elem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAggr_arg) { - listener.enterAggr_arg(this); + if(listener.enterGeneric_option_elem) { + listener.enterGeneric_option_elem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAggr_arg) { - listener.exitAggr_arg(this); + if(listener.exitGeneric_option_elem) { + listener.exitGeneric_option_elem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAggr_arg) { - return visitor.visitAggr_arg(this); + if (visitor.visitGeneric_option_elem) { + return visitor.visitGeneric_option_elem(this); } else { return visitor.visitChildren(this); } @@ -90474,95 +65375,65 @@ export class Aggr_argContext extends antlr.ParserRuleContext { } -export class Aggr_argsContext extends antlr.ParserRuleContext { +export class CreateforeignserverstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public STAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.STAR, 0); + public KW_SERVER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; } - public aggr_args_list(): Aggr_args_listContext[]; - public aggr_args_list(i: number): Aggr_args_listContext | null; - public aggr_args_list(i?: number): Aggr_args_listContext[] | Aggr_args_listContext | null { + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { if (i === undefined) { - return this.getRuleContexts(Aggr_args_listContext); + return this.getRuleContexts(ColidContext); } - return this.getRuleContext(i, Aggr_args_listContext); - } - public KW_ORDER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ORDER, 0); + return this.getRuleContext(i, ColidContext); } - public KW_BY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BY, 0); + public KW_FOREIGN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_aggr_args; + public KW_DATA(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DATA, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAggr_args) { - listener.enterAggr_args(this); - } + public KW_WRAPPER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WRAPPER, 0)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAggr_args) { - listener.exitAggr_args(this); - } + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAggr_args) { - return visitor.visitAggr_args(this); - } else { - return visitor.visitChildren(this); - } + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); } -} - - -export class Aggr_args_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } - public aggr_arg(): Aggr_argContext[]; - public aggr_arg(i: number): Aggr_argContext | null; - public aggr_arg(i?: number): Aggr_argContext[] | Aggr_argContext | null { - if (i === undefined) { - return this.getRuleContexts(Aggr_argContext); - } - - return this.getRuleContext(i, Aggr_argContext); + public foreign_server_version(): Foreign_server_versionContext | null { + return this.getRuleContext(0, Foreign_server_versionContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public create_generic_options(): Create_generic_optionsContext | null { + return this.getRuleContext(0, Create_generic_optionsContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_aggr_args_list; + return PostgreSqlParser.RULE_createforeignserverstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAggr_args_list) { - listener.enterAggr_args_list(this); + if(listener.enterCreateforeignserverstmt) { + listener.enterCreateforeignserverstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAggr_args_list) { - listener.exitAggr_args_list(this); + if(listener.exitCreateforeignserverstmt) { + listener.exitCreateforeignserverstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAggr_args_list) { - return visitor.visitAggr_args_list(this); + if (visitor.visitCreateforeignserverstmt) { + return visitor.visitCreateforeignserverstmt(this); } else { return visitor.visitChildren(this); } @@ -90570,32 +65441,35 @@ export class Aggr_args_listContext extends antlr.ParserRuleContext { } -export class Aggregate_with_argtypesContext extends antlr.ParserRuleContext { +export class Foreign_server_versionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public function_name(): Function_nameContext { - return this.getRuleContext(0, Function_nameContext)!; + public KW_VERSION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_VERSION, 0)!; } - public aggr_args(): Aggr_argsContext { - return this.getRuleContext(0, Aggr_argsContext)!; + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULL, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_aggregate_with_argtypes; + return PostgreSqlParser.RULE_foreign_server_version; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAggregate_with_argtypes) { - listener.enterAggregate_with_argtypes(this); + if(listener.enterForeign_server_version) { + listener.enterForeign_server_version(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAggregate_with_argtypes) { - listener.exitAggregate_with_argtypes(this); + if(listener.exitForeign_server_version) { + listener.exitForeign_server_version(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAggregate_with_argtypes) { - return visitor.visitAggregate_with_argtypes(this); + if (visitor.visitForeign_server_version) { + return visitor.visitForeign_server_version(this); } else { return visitor.visitChildren(this); } @@ -90603,44 +65477,41 @@ export class Aggregate_with_argtypesContext extends antlr.ParserRuleContext { } -export class Aggregate_with_argtypes_listContext extends antlr.ParserRuleContext { +export class AlterforeignserverstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public aggregate_with_argtypes(): Aggregate_with_argtypesContext[]; - public aggregate_with_argtypes(i: number): Aggregate_with_argtypesContext | null; - public aggregate_with_argtypes(i?: number): Aggregate_with_argtypesContext[] | Aggregate_with_argtypesContext | null { - if (i === undefined) { - return this.getRuleContexts(Aggregate_with_argtypesContext); - } - - return this.getRuleContext(i, Aggregate_with_argtypesContext); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_SERVER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; + } + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; + } + public alter_generic_options(): Alter_generic_optionsContext | null { + return this.getRuleContext(0, Alter_generic_optionsContext); + } + public foreign_server_version(): Foreign_server_versionContext | null { + return this.getRuleContext(0, Foreign_server_versionContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_aggregate_with_argtypes_list; + return PostgreSqlParser.RULE_alterforeignserverstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAggregate_with_argtypes_list) { - listener.enterAggregate_with_argtypes_list(this); + if(listener.enterAlterforeignserverstmt) { + listener.enterAlterforeignserverstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAggregate_with_argtypes_list) { - listener.exitAggregate_with_argtypes_list(this); + if(listener.exitAlterforeignserverstmt) { + listener.exitAlterforeignserverstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAggregate_with_argtypes_list) { - return visitor.visitAggregate_with_argtypes_list(this); + if (visitor.visitAlterforeignserverstmt) { + return visitor.visitAlterforeignserverstmt(this); } else { return visitor.visitChildren(this); } @@ -90648,137 +65519,133 @@ export class Aggregate_with_argtypes_listContext extends antlr.ParserRuleContext } -export class Createfunc_opt_listContext extends antlr.ParserRuleContext { +export class CreateforeigntablestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public createfunc_opt_item(): Createfunc_opt_itemContext[]; - public createfunc_opt_item(i: number): Createfunc_opt_itemContext | null; - public createfunc_opt_item(i?: number): Createfunc_opt_itemContext[] | Createfunc_opt_itemContext | null { - if (i === undefined) { - return this.getRuleContexts(Createfunc_opt_itemContext); - } - - return this.getRuleContext(i, Createfunc_opt_itemContext); - } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createfunc_opt_list; + return PostgreSqlParser.RULE_createforeigntablestmt; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatefunc_opt_list) { - listener.enterCreatefunc_opt_list(this); - } + public override copyFrom(ctx: CreateforeigntablestmtContext): void { + super.copyFrom(ctx); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatefunc_opt_list) { - listener.exitCreatefunc_opt_list(this); - } +} +export class CreateForeignTableContext extends CreateforeigntablestmtContext { + public constructor(ctx: CreateforeigntablestmtContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatefunc_opt_list) { - return visitor.visitCreatefunc_opt_list(this); - } else { - return visitor.visitChildren(this); - } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } -} - - -export class Common_func_opt_itemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_FOREIGN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; } - public KW_CALLED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CALLED, 0); + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TABLE, 0)!; } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); + public table_name_create(): Table_name_createContext { + return this.getRuleContext(0, Table_name_createContext)!; } - public KW_NULL(): antlr.TerminalNode[]; - public KW_NULL(i: number): antlr.TerminalNode | null; - public KW_NULL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_NULL); - } else { - return this.getToken(PostgreSqlParser.KW_NULL, i); - } + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public KW_INPUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INPUT, 0); + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public KW_RETURNS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RETURNS, 0); + public KW_SERVER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; } - public KW_STRICT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STRICT, 0); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public KW_IMMUTABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IMMUTABLE, 0); + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); } - public KW_STABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STABLE, 0); + public tableelementlist(): TableelementlistContext | null { + return this.getRuleContext(0, TableelementlistContext); } - public KW_VOLATILE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VOLATILE, 0); + public optinherit(): OptinheritContext | null { + return this.getRuleContext(0, OptinheritContext); } - public KW_EXTERNAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXTERNAL, 0); + public create_generic_options(): Create_generic_optionsContext | null { + return this.getRuleContext(0, Create_generic_optionsContext); } - public KW_SECURITY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SECURITY, 0); + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterCreateForeignTable) { + listener.enterCreateForeignTable(this); + } } - public KW_DEFINER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFINER, 0); + public override exitRule(listener: PostgreSqlParserListener): void { + if(listener.exitCreateForeignTable) { + listener.exitCreateForeignTable(this); + } } - public KW_INVOKER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INVOKER, 0); + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitCreateForeignTable) { + return visitor.visitCreateForeignTable(this); + } else { + return visitor.visitChildren(this); + } } - public KW_LEAKPROOF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LEAKPROOF, 0); +} +export class CreatePartitionForeignTableContext extends CreateforeigntablestmtContext { + public constructor(ctx: CreateforeigntablestmtContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public KW_COST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COST, 0); + public KW_FOREIGN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); + public KW_TABLE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TABLE, 0)!; } - public KW_ROWS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROWS, 0); + public table_name_create(): Table_name_createContext { + return this.getRuleContext(0, Table_name_createContext)!; } - public KW_SUPPORT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SUPPORT, 0); + public KW_PARTITION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_PARTITION, 0)!; } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); + public KW_OF(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_OF, 0)!; } - public functionsetresetclause(): FunctionsetresetclauseContext | null { - return this.getRuleContext(0, FunctionsetresetclauseContext); + public table_name(): Table_nameContext { + return this.getRuleContext(0, Table_nameContext)!; } - public KW_PARALLEL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARALLEL, 0); + public partitionboundspec(): PartitionboundspecContext { + return this.getRuleContext(0, PartitionboundspecContext)!; } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); + public KW_SERVER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_common_func_opt_item; + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; + } + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); + } + public opttypedtableelementlist(): OpttypedtableelementlistContext | null { + return this.getRuleContext(0, OpttypedtableelementlistContext); + } + public create_generic_options(): Create_generic_optionsContext | null { + return this.getRuleContext(0, Create_generic_optionsContext); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCommon_func_opt_item) { - listener.enterCommon_func_opt_item(this); + if(listener.enterCreatePartitionForeignTable) { + listener.enterCreatePartitionForeignTable(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCommon_func_opt_item) { - listener.exitCommon_func_opt_item(this); + if(listener.exitCreatePartitionForeignTable) { + listener.exitCreatePartitionForeignTable(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCommon_func_opt_item) { - return visitor.visitCommon_func_opt_item(this); + if (visitor.visitCreatePartitionForeignTable) { + return visitor.visitCreatePartitionForeignTable(this); } else { return visitor.visitChildren(this); } @@ -90786,42 +65653,27 @@ export class Common_func_opt_itemContext extends antlr.ParserRuleContext { } -export class Createfunc_opt_itemContext extends antlr.ParserRuleContext { +export class ImportforeignschemastmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); - } - public sconst(): SconstContext[]; - public sconst(i: number): SconstContext | null; - public sconst(i?: number): SconstContext[] | SconstContext | null { - if (i === undefined) { - return this.getRuleContexts(SconstContext); - } - - return this.getRuleContext(i, SconstContext); - } - public COMMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.COMMA, 0); - } - public KW_LANGUAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); + public KW_IMPORT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_IMPORT, 0)!; } - public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | null { - return this.getRuleContext(0, Nonreservedword_or_sconstContext); + public KW_FOREIGN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0)!; } - public KW_TRANSFORM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0); + public KW_SCHEMA(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0)!; } - public transform_type_list(): Transform_type_listContext | null { - return this.getRuleContext(0, Transform_type_listContext); + public schema_name(): Schema_nameContext { + return this.getRuleContext(0, Schema_nameContext)!; } - public KW_WINDOW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WINDOW, 0); + public KW_FROM(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FROM, 0)!; } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); + public KW_SERVER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; } public colid(): ColidContext[]; public colid(i: number): ColidContext | null; @@ -90832,40 +65684,46 @@ export class Createfunc_opt_itemContext extends antlr.ParserRuleContext { return this.getRuleContext(i, ColidContext); } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); + public KW_INTO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_INTO, 0)!; } - public EQUAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.EQUAL, 0); + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); + public relation_expr_list(): Relation_expr_listContext | null { + return this.getRuleContext(0, Relation_expr_listContext); } - public KW_CURRENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT, 0); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public stmt(): StmtContext | null { - return this.getRuleContext(0, StmtContext); + public create_generic_options(): Create_generic_optionsContext | null { + return this.getRuleContext(0, Create_generic_optionsContext); } - public common_func_opt_item(): Common_func_opt_itemContext | null { - return this.getRuleContext(0, Common_func_opt_itemContext); + public KW_LIMIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LIMIT, 0); + } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); + } + public KW_EXCEPT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXCEPT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createfunc_opt_item; + return PostgreSqlParser.RULE_importforeignschemastmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatefunc_opt_item) { - listener.enterCreatefunc_opt_item(this); + if(listener.enterImportforeignschemastmt) { + listener.enterImportforeignschemastmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatefunc_opt_item) { - listener.exitCreatefunc_opt_item(this); + if(listener.exitImportforeignschemastmt) { + listener.exitImportforeignschemastmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatefunc_opt_item) { - return visitor.visitCreatefunc_opt_item(this); + if (visitor.visitImportforeignschemastmt) { + return visitor.visitImportforeignschemastmt(this); } else { return visitor.visitChildren(this); } @@ -90873,62 +65731,59 @@ export class Createfunc_opt_itemContext extends antlr.ParserRuleContext { } -export class Transform_type_listContext extends antlr.ParserRuleContext { +export class CreateusermappingstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FOR(): antlr.TerminalNode[]; - public KW_FOR(i: number): antlr.TerminalNode | null; - public KW_FOR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_FOR); - } else { - return this.getToken(PostgreSqlParser.KW_FOR, i); - } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public KW_TYPE(): antlr.TerminalNode[]; - public KW_TYPE(i: number): antlr.TerminalNode | null; - public KW_TYPE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public KW_USER(): antlr.TerminalNode[]; + public KW_USER(i: number): antlr.TerminalNode | null; + public KW_USER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_TYPE); + return this.getTokens(PostgreSqlParser.KW_USER); } else { - return this.getToken(PostgreSqlParser.KW_TYPE, i); + return this.getToken(PostgreSqlParser.KW_USER, i); } } - public typename(): TypenameContext[]; - public typename(i: number): TypenameContext | null; - public typename(i?: number): TypenameContext[] | TypenameContext | null { - if (i === undefined) { - return this.getRuleContexts(TypenameContext); - } - - return this.getRuleContext(i, TypenameContext); + public KW_MAPPING(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_MAPPING, 0)!; } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_FOR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOR, 0)!; + } + public KW_SERVER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; + } + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; + } + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); + } + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); + } + public create_generic_options(): Create_generic_optionsContext | null { + return this.getRuleContext(0, Create_generic_optionsContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_transform_type_list; + return PostgreSqlParser.RULE_createusermappingstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTransform_type_list) { - listener.enterTransform_type_list(this); + if(listener.enterCreateusermappingstmt) { + listener.enterCreateusermappingstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTransform_type_list) { - listener.exitTransform_type_list(this); + if(listener.exitCreateusermappingstmt) { + listener.exitCreateusermappingstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTransform_type_list) { - return visitor.visitTransform_type_list(this); + if (visitor.visitCreateusermappingstmt) { + return visitor.visitCreateusermappingstmt(this); } else { return visitor.visitChildren(this); } @@ -90936,32 +65791,56 @@ export class Transform_type_listContext extends antlr.ParserRuleContext { } -export class Opt_definitionContext extends antlr.ParserRuleContext { +export class AlterusermappingstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public definition(): DefinitionContext { - return this.getRuleContext(0, DefinitionContext)!; + public KW_USER(): antlr.TerminalNode[]; + public KW_USER(i: number): antlr.TerminalNode | null; + public KW_USER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_USER); + } else { + return this.getToken(PostgreSqlParser.KW_USER, i); + } + } + public KW_MAPPING(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_MAPPING, 0)!; + } + public KW_FOR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOR, 0)!; + } + public KW_SERVER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SERVER, 0)!; + } + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; + } + public alter_generic_options(): Alter_generic_optionsContext { + return this.getRuleContext(0, Alter_generic_optionsContext)!; + } + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_definition; + return PostgreSqlParser.RULE_alterusermappingstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_definition) { - listener.enterOpt_definition(this); + if(listener.enterAlterusermappingstmt) { + listener.enterAlterusermappingstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_definition) { - listener.exitOpt_definition(this); + if(listener.exitAlterusermappingstmt) { + listener.exitAlterusermappingstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_definition) { - return visitor.visitOpt_definition(this); + if (visitor.visitAlterusermappingstmt) { + return visitor.visitAlterusermappingstmt(this); } else { return visitor.visitChildren(this); } @@ -90969,116 +65848,83 @@ export class Opt_definitionContext extends antlr.ParserRuleContext { } -export class Table_func_columnContext extends antlr.ParserRuleContext { +export class CreatepolicystmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public column_name(): Column_nameContext { - return this.getRuleContext(0, Column_nameContext)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public func_type(): Func_typeContext { - return this.getRuleContext(0, Func_typeContext)!; + public KW_POLICY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_POLICY, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_table_func_column; + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTable_func_column) { - listener.enterTable_func_column(this); - } + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTable_func_column) { - listener.exitTable_func_column(this); - } + public qualified_name(): Qualified_nameContext { + return this.getRuleContext(0, Qualified_nameContext)!; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTable_func_column) { - return visitor.visitTable_func_column(this); - } else { - return visitor.visitChildren(this); - } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } -} - - -export class Table_func_column_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } - public table_func_column(): Table_func_columnContext[]; - public table_func_column(i: number): Table_func_columnContext | null; - public table_func_column(i?: number): Table_func_columnContext[] | Table_func_columnContext | null { - if (i === undefined) { - return this.getRuleContexts(Table_func_columnContext); - } - - return this.getRuleContext(i, Table_func_columnContext); + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public role_list(): Role_listContext | null { + return this.getRuleContext(0, Role_listContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_table_func_column_list; + public rowsecurityoptionalexpr(): RowsecurityoptionalexprContext | null { + return this.getRuleContext(0, RowsecurityoptionalexprContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTable_func_column_list) { - listener.enterTable_func_column_list(this); - } + public rowsecurityoptionalwithcheck(): RowsecurityoptionalwithcheckContext | null { + return this.getRuleContext(0, RowsecurityoptionalwithcheckContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTable_func_column_list) { - listener.exitTable_func_column_list(this); - } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTable_func_column_list) { - return visitor.visitTable_func_column_list(this); - } else { - return visitor.visitChildren(this); - } + public KW_SELECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SELECT, 0); } -} - - -export class AlterfunctionstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_INSERT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INSERT, 0); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + public KW_UPDATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UPDATE, 0); + } + public KW_DELETE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DELETE, 0); } - public alterFunctionTypeClause(): AlterFunctionTypeClauseContext { - return this.getRuleContext(0, AlterFunctionTypeClauseContext)!; + public KW_PERMISSIVE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PERMISSIVE, 0); } - public alterfunc_opt_list(): Alterfunc_opt_listContext { - return this.getRuleContext(0, Alterfunc_opt_listContext)!; + public KW_RESTRICTIVE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESTRICTIVE, 0); } - public opt_restrict(): Opt_restrictContext | null { - return this.getRuleContext(0, Opt_restrictContext); + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterfunctionstmt; + return PostgreSqlParser.RULE_createpolicystmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterfunctionstmt) { - listener.enterAlterfunctionstmt(this); + if(listener.enterCreatepolicystmt) { + listener.enterCreatepolicystmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterfunctionstmt) { - listener.exitAlterfunctionstmt(this); + if(listener.exitCreatepolicystmt) { + listener.exitCreatepolicystmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterfunctionstmt) { - return visitor.visitAlterfunctionstmt(this); + if (visitor.visitCreatepolicystmt) { + return visitor.visitCreatepolicystmt(this); } else { return visitor.visitChildren(this); } @@ -91086,44 +65932,53 @@ export class AlterfunctionstmtContext extends antlr.ParserRuleContext { } -export class AlterFunctionTypeClauseContext extends antlr.ParserRuleContext { +export class AlterpolicystmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public function_with_argtypes(): Function_with_argtypesContext | null { - return this.getRuleContext(0, Function_with_argtypesContext); + public KW_POLICY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_POLICY, 0)!; } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public procedure_with_argtypes(): Procedure_with_argtypesContext | null { - return this.getRuleContext(0, Procedure_with_argtypesContext); + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; } - public KW_ROUTINE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); + public qualified_name(): Qualified_nameContext { + return this.getRuleContext(0, Qualified_nameContext)!; } - public routine_with_argtypes(): Routine_with_argtypesContext | null { - return this.getRuleContext(0, Routine_with_argtypesContext); + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); + } + public role_list(): Role_listContext | null { + return this.getRuleContext(0, Role_listContext); + } + public rowsecurityoptionalexpr(): RowsecurityoptionalexprContext | null { + return this.getRuleContext(0, RowsecurityoptionalexprContext); + } + public rowsecurityoptionalwithcheck(): RowsecurityoptionalwithcheckContext | null { + return this.getRuleContext(0, RowsecurityoptionalwithcheckContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterFunctionTypeClause; + return PostgreSqlParser.RULE_alterpolicystmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterFunctionTypeClause) { - listener.enterAlterFunctionTypeClause(this); + if(listener.enterAlterpolicystmt) { + listener.enterAlterpolicystmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterFunctionTypeClause) { - listener.exitAlterFunctionTypeClause(this); + if(listener.exitAlterpolicystmt) { + listener.exitAlterpolicystmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterFunctionTypeClause) { - return visitor.visitAlterFunctionTypeClause(this); + if (visitor.visitAlterpolicystmt) { + return visitor.visitAlterpolicystmt(this); } else { return visitor.visitChildren(this); } @@ -91131,65 +65986,89 @@ export class AlterFunctionTypeClauseContext extends antlr.ParserRuleContext { } -export class Alterfunc_opt_listContext extends antlr.ParserRuleContext { +export class AlterprocedurestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public common_func_opt_item(): Common_func_opt_itemContext[]; - public common_func_opt_item(i: number): Common_func_opt_itemContext | null; - public common_func_opt_item(i?: number): Common_func_opt_itemContext[] | Common_func_opt_itemContext | null { + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public KW_PROCEDURE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0)!; + } + public procedure_name(): Procedure_nameContext { + return this.getRuleContext(0, Procedure_nameContext)!; + } + public procedure_action(): Procedure_actionContext[]; + public procedure_action(i: number): Procedure_actionContext | null; + public procedure_action(i?: number): Procedure_actionContext[] | Procedure_actionContext | null { if (i === undefined) { - return this.getRuleContexts(Common_func_opt_itemContext); + return this.getRuleContexts(Procedure_actionContext); } - return this.getRuleContext(i, Common_func_opt_itemContext); + return this.getRuleContext(i, Procedure_actionContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterfunc_opt_list; + public KW_RENAME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RENAME, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterfunc_opt_list) { - listener.enterAlterfunc_opt_list(this); - } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterfunc_opt_list) { - listener.exitAlterfunc_opt_list(this); - } + public procedure_name_create(): Procedure_name_createContext | null { + return this.getRuleContext(0, Procedure_name_createContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterfunc_opt_list) { - return visitor.visitAlterfunc_opt_list(this); - } else { - return visitor.visitChildren(this); - } + public KW_OWNER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OWNER, 0); } -} - - -export class Opt_restrictContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); + } + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); + } + public schema_name_create(): Schema_name_createContext | null { + return this.getRuleContext(0, Schema_name_createContext); + } + public KW_DEPENDS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEPENDS, 0); + } + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ON, 0); + } + public KW_EXTENSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXTENSION, 0); + } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public KW_RESTRICT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_RESTRICT, 0)!; + public func_args(): Func_argsContext | null { + return this.getRuleContext(0, Func_argsContext); + } + public KW_RESTRICT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESTRICT, 0); + } + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_restrict; + return PostgreSqlParser.RULE_alterprocedurestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_restrict) { - listener.enterOpt_restrict(this); + if(listener.enterAlterprocedurestmt) { + listener.enterAlterprocedurestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_restrict) { - listener.exitOpt_restrict(this); + if(listener.exitAlterprocedurestmt) { + listener.exitAlterprocedurestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_restrict) { - return visitor.visitOpt_restrict(this); + if (visitor.visitAlterprocedurestmt) { + return visitor.visitAlterprocedurestmt(this); } else { return visitor.visitChildren(this); } @@ -91197,53 +66076,71 @@ export class Opt_restrictContext extends antlr.ParserRuleContext { } -export class RemovefuncstmtContext extends antlr.ParserRuleContext { +export class Procedure_actionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_DROP(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DROP, 0)!; + public KW_SECURITY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SECURITY, 0); } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + public KW_INVOKER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INVOKER, 0); } - public function_with_argtypes_list(): Function_with_argtypes_listContext | null { - return this.getRuleContext(0, Function_with_argtypes_listContext); + public KW_DEFINER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFINER, 0); } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); + public KW_EXTERNAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXTERNAL, 0); } - public opt_drop_behavior(): Opt_drop_behaviorContext | null { - return this.getRuleContext(0, Opt_drop_behaviorContext); + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { + if (i === undefined) { + return this.getRuleContexts(ColidContext); + } + + return this.getRuleContext(i, ColidContext); } - public procedure_with_argtypes_list(): Procedure_with_argtypes_listContext | null { - return this.getRuleContext(0, Procedure_with_argtypes_listContext); + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } - public KW_ROUTINE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); + public STAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.STAR, 0); } - public routine_with_argtypes_list(): Routine_with_argtypes_listContext | null { - return this.getRuleContext(0, Routine_with_argtypes_listContext); + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); + } + public KW_CURRENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT, 0); + } + public KW_RESET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESET, 0); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_removefuncstmt; + return PostgreSqlParser.RULE_procedure_action; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRemovefuncstmt) { - listener.enterRemovefuncstmt(this); + if(listener.enterProcedure_action) { + listener.enterProcedure_action(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRemovefuncstmt) { - listener.exitRemovefuncstmt(this); + if(listener.exitProcedure_action) { + listener.exitProcedure_action(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRemovefuncstmt) { - return visitor.visitRemovefuncstmt(this); + if (visitor.visitProcedure_action) { + return visitor.visitProcedure_action(this); } else { return visitor.visitChildren(this); } @@ -91251,41 +66148,38 @@ export class RemovefuncstmtContext extends antlr.ParserRuleContext { } -export class RemoveaggrstmtContext extends antlr.ParserRuleContext { +export class RowsecurityoptionalexprContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_DROP(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DROP, 0)!; - } - public KW_AGGREGATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0)!; + public KW_USING(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_USING, 0)!; } - public aggregate_with_argtypes_list(): Aggregate_with_argtypes_listContext { - return this.getRuleContext(0, Aggregate_with_argtypes_listContext)!; + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; } - public opt_drop_behavior(): Opt_drop_behaviorContext | null { - return this.getRuleContext(0, Opt_drop_behaviorContext); + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_removeaggrstmt; + return PostgreSqlParser.RULE_rowsecurityoptionalexpr; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRemoveaggrstmt) { - listener.enterRemoveaggrstmt(this); + if(listener.enterRowsecurityoptionalexpr) { + listener.enterRowsecurityoptionalexpr(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRemoveaggrstmt) { - listener.exitRemoveaggrstmt(this); + if(listener.exitRowsecurityoptionalexpr) { + listener.exitRowsecurityoptionalexpr(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRemoveaggrstmt) { - return visitor.visitRemoveaggrstmt(this); + if (visitor.visitRowsecurityoptionalexpr) { + return visitor.visitRowsecurityoptionalexpr(this); } else { return visitor.visitChildren(this); } @@ -91293,41 +66187,41 @@ export class RemoveaggrstmtContext extends antlr.ParserRuleContext { } -export class RemoveoperstmtContext extends antlr.ParserRuleContext { +export class RowsecurityoptionalwithcheckContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_DROP(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DROP, 0)!; + public KW_WITH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WITH, 0)!; } - public KW_OPERATOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0)!; + public KW_CHECK(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CHECK, 0)!; } - public operator_with_argtypes_list(): Operator_with_argtypes_listContext { - return this.getRuleContext(0, Operator_with_argtypes_listContext)!; + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; } - public opt_drop_behavior(): Opt_drop_behaviorContext | null { - return this.getRuleContext(0, Opt_drop_behaviorContext); + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_removeoperstmt; + return PostgreSqlParser.RULE_rowsecurityoptionalwithcheck; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRemoveoperstmt) { - listener.enterRemoveoperstmt(this); + if(listener.enterRowsecurityoptionalwithcheck) { + listener.enterRowsecurityoptionalwithcheck(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRemoveoperstmt) { - listener.exitRemoveoperstmt(this); + if(listener.exitRowsecurityoptionalwithcheck) { + listener.exitRowsecurityoptionalwithcheck(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRemoveoperstmt) { - return visitor.visitRemoveoperstmt(this); + if (visitor.visitRowsecurityoptionalwithcheck) { + return visitor.visitRowsecurityoptionalwithcheck(this); } else { return visitor.visitChildren(this); } @@ -91335,47 +66229,53 @@ export class RemoveoperstmtContext extends antlr.ParserRuleContext { } -export class Oper_argtypesContext extends antlr.ParserRuleContext { +export class CreateamstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public typename(): TypenameContext[]; - public typename(i: number): TypenameContext | null; - public typename(i?: number): TypenameContext[] | TypenameContext | null { - if (i === undefined) { - return this.getRuleContexts(TypenameContext); - } - - return this.getRuleContext(i, TypenameContext); + public KW_ACCESS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ACCESS, 0)!; + } + public KW_METHOD(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_METHOD, 0)!; + } + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; + } + public KW_TYPE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TYPE, 0)!; + } + public KW_HANDLER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_HANDLER, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; } - public COMMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.COMMA, 0); + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INDEX, 0); } - public KW_NONE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NONE, 0); + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_oper_argtypes; + return PostgreSqlParser.RULE_createamstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOper_argtypes) { - listener.enterOper_argtypes(this); + if(listener.enterCreateamstmt) { + listener.enterCreateamstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOper_argtypes) { - listener.exitOper_argtypes(this); + if(listener.exitCreateamstmt) { + listener.exitCreateamstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOper_argtypes) { - return visitor.visitOper_argtypes(this); + if (visitor.visitCreateamstmt) { + return visitor.visitCreateamstmt(this); } else { return visitor.visitChildren(this); } @@ -91383,12 +66283,15 @@ export class Oper_argtypesContext extends antlr.ParserRuleContext { } -export class Any_operatorContext extends antlr.ParserRuleContext { +export class CreatetrigstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public all_op(): All_opContext { - return this.getRuleContext(0, All_opContext)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + } + public KW_TRIGGER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TRIGGER, 0)!; } public colid(): ColidContext[]; public colid(i: number): ColidContext | null; @@ -91399,109 +66302,130 @@ export class Any_operatorContext extends antlr.ParserRuleContext { return this.getRuleContext(i, ColidContext); } - public DOT(): antlr.TerminalNode[]; - public DOT(i: number): antlr.TerminalNode | null; - public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public triggeractiontime(): TriggeractiontimeContext { + return this.getRuleContext(0, TriggeractiontimeContext)!; + } + public triggerevents(): TriggereventsContext { + return this.getRuleContext(0, TriggereventsContext)!; + } + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; + } + public table_name(): Table_nameContext { + return this.getRuleContext(0, Table_nameContext)!; + } + public KW_EXECUTE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EXECUTE, 0)!; + } + public function_or_procedure(): Function_or_procedureContext { + return this.getRuleContext(0, Function_or_procedureContext)!; + } + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + } + public triggerfuncargs(): TriggerfuncargsContext { + return this.getRuleContext(0, TriggerfuncargsContext)!; + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + } + public opt_or_replace(): Opt_or_replaceContext | null { + return this.getRuleContext(0, Opt_or_replaceContext); + } + public KW_REFERENCING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REFERENCING, 0); + } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); + } + public triggerwhen(): TriggerwhenContext | null { + return this.getRuleContext(0, TriggerwhenContext); + } + public KW_ROW(): antlr.TerminalNode[]; + public KW_ROW(i: number): antlr.TerminalNode | null; + public KW_ROW(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.DOT); + return this.getTokens(PostgreSqlParser.KW_ROW); } else { - return this.getToken(PostgreSqlParser.DOT, i); + return this.getToken(PostgreSqlParser.KW_ROW, i); } } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_any_operator; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAny_operator) { - listener.enterAny_operator(this); - } + public KW_STATEMENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STATEMENT, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAny_operator) { - listener.exitAny_operator(this); - } + public KW_EACH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EACH, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAny_operator) { - return visitor.visitAny_operator(this); - } else { - return visitor.visitChildren(this); - } + public KW_NEW(): antlr.TerminalNode[]; + public KW_NEW(i: number): antlr.TerminalNode | null; + public KW_NEW(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_NEW); + } else { + return this.getToken(PostgreSqlParser.KW_NEW, i); + } } -} - - -export class Operator_with_argtypes_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_OLD(): antlr.TerminalNode[]; + public KW_OLD(i: number): antlr.TerminalNode | null; + public KW_OLD(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_OLD); + } else { + return this.getToken(PostgreSqlParser.KW_OLD, i); + } } - public operator_with_argtypes(): Operator_with_argtypesContext[]; - public operator_with_argtypes(i: number): Operator_with_argtypesContext | null; - public operator_with_argtypes(i?: number): Operator_with_argtypesContext[] | Operator_with_argtypesContext | null { - if (i === undefined) { - return this.getRuleContexts(Operator_with_argtypesContext); - } - - return this.getRuleContext(i, Operator_with_argtypesContext); + public KW_TABLE(): antlr.TerminalNode[]; + public KW_TABLE(i: number): antlr.TerminalNode | null; + public KW_TABLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_TABLE); + } else { + return this.getToken(PostgreSqlParser.KW_TABLE, i); + } } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public KW_AS(): antlr.TerminalNode[]; + public KW_AS(i: number): antlr.TerminalNode | null; + public KW_AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); + return this.getTokens(PostgreSqlParser.KW_AS); } else { - return this.getToken(PostgreSqlParser.COMMA, i); + return this.getToken(PostgreSqlParser.KW_AS, i); } } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_operator_with_argtypes_list; + public KW_CONSTRAINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOperator_with_argtypes_list) { - listener.enterOperator_with_argtypes_list(this); - } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOperator_with_argtypes_list) { - listener.exitOperator_with_argtypes_list(this); - } + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOperator_with_argtypes_list) { - return visitor.visitOperator_with_argtypes_list(this); - } else { - return visitor.visitChildren(this); + public constraintattributeElem(): ConstraintattributeElemContext[]; + public constraintattributeElem(i: number): ConstraintattributeElemContext | null; + public constraintattributeElem(i?: number): ConstraintattributeElemContext[] | ConstraintattributeElemContext | null { + if (i === undefined) { + return this.getRuleContexts(ConstraintattributeElemContext); } - } -} - -export class Operator_with_argtypesContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public any_operator(): Any_operatorContext { - return this.getRuleContext(0, Any_operatorContext)!; - } - public oper_argtypes(): Oper_argtypesContext { - return this.getRuleContext(0, Oper_argtypesContext)!; + return this.getRuleContext(i, ConstraintattributeElemContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_operator_with_argtypes; + return PostgreSqlParser.RULE_createtrigstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOperator_with_argtypes) { - listener.enterOperator_with_argtypes(this); + if(listener.enterCreatetrigstmt) { + listener.enterCreatetrigstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOperator_with_argtypes) { - listener.exitOperator_with_argtypes(this); + if(listener.exitCreatetrigstmt) { + listener.exitCreatetrigstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOperator_with_argtypes) { - return visitor.visitOperator_with_argtypes(this); + if (visitor.visitCreatetrigstmt) { + return visitor.visitCreatetrigstmt(this); } else { return visitor.visitChildren(this); } @@ -91509,32 +66433,38 @@ export class Operator_with_argtypesContext extends antlr.ParserRuleContext { } -export class DostmtContext extends antlr.ParserRuleContext { +export class TriggeractiontimeContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_DO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DO, 0)!; + public KW_BEFORE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BEFORE, 0); + } + public KW_AFTER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AFTER, 0); + } + public KW_INSTEAD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INSTEAD, 0); } - public dostmt_opt_list(): Dostmt_opt_listContext { - return this.getRuleContext(0, Dostmt_opt_listContext)!; + public KW_OF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OF, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_dostmt; + return PostgreSqlParser.RULE_triggeractiontime; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDostmt) { - listener.enterDostmt(this); + if(listener.enterTriggeractiontime) { + listener.enterTriggeractiontime(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDostmt) { - listener.exitDostmt(this); + if(listener.exitTriggeractiontime) { + listener.exitTriggeractiontime(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDostmt) { - return visitor.visitDostmt(this); + if (visitor.visitTriggeractiontime) { + return visitor.visitTriggeractiontime(this); } else { return visitor.visitChildren(this); } @@ -91542,35 +66472,44 @@ export class DostmtContext extends antlr.ParserRuleContext { } -export class Dostmt_opt_listContext extends antlr.ParserRuleContext { +export class TriggereventsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public dostmt_opt_item(): Dostmt_opt_itemContext[]; - public dostmt_opt_item(i: number): Dostmt_opt_itemContext | null; - public dostmt_opt_item(i?: number): Dostmt_opt_itemContext[] | Dostmt_opt_itemContext | null { + public triggeroneevent(): TriggeroneeventContext[]; + public triggeroneevent(i: number): TriggeroneeventContext | null; + public triggeroneevent(i?: number): TriggeroneeventContext[] | TriggeroneeventContext | null { if (i === undefined) { - return this.getRuleContexts(Dostmt_opt_itemContext); + return this.getRuleContexts(TriggeroneeventContext); } - return this.getRuleContext(i, Dostmt_opt_itemContext); + return this.getRuleContext(i, TriggeroneeventContext); + } + public KW_OR(): antlr.TerminalNode[]; + public KW_OR(i: number): antlr.TerminalNode | null; + public KW_OR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_OR); + } else { + return this.getToken(PostgreSqlParser.KW_OR, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_dostmt_opt_list; + return PostgreSqlParser.RULE_triggerevents; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDostmt_opt_list) { - listener.enterDostmt_opt_list(this); + if(listener.enterTriggerevents) { + listener.enterTriggerevents(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDostmt_opt_list) { - listener.exitDostmt_opt_list(this); + if(listener.exitTriggerevents) { + listener.exitTriggerevents(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDostmt_opt_list) { - return visitor.visitDostmt_opt_list(this); + if (visitor.visitTriggerevents) { + return visitor.visitTriggerevents(this); } else { return visitor.visitChildren(this); } @@ -91578,35 +66517,44 @@ export class Dostmt_opt_listContext extends antlr.ParserRuleContext { } -export class Dostmt_opt_itemContext extends antlr.ParserRuleContext { +export class TriggeroneeventContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); + public KW_INSERT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INSERT, 0); } - public KW_LANGUAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); + public KW_DELETE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DELETE, 0); } - public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | null { - return this.getRuleContext(0, Nonreservedword_or_sconstContext); + public KW_UPDATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UPDATE, 0); + } + public KW_OF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OF, 0); + } + public column_list(): Column_listContext | null { + return this.getRuleContext(0, Column_listContext); + } + public KW_TRUNCATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRUNCATE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_dostmt_opt_item; + return PostgreSqlParser.RULE_triggeroneevent; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDostmt_opt_item) { - listener.enterDostmt_opt_item(this); + if(listener.enterTriggeroneevent) { + listener.enterTriggeroneevent(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDostmt_opt_item) { - listener.exitDostmt_opt_item(this); + if(listener.exitTriggeroneevent) { + listener.exitTriggeroneevent(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDostmt_opt_item) { - return visitor.visitDostmt_opt_item(this); + if (visitor.visitTriggeroneevent) { + return visitor.visitTriggeroneevent(this); } else { return visitor.visitChildren(this); } @@ -91614,68 +66562,38 @@ export class Dostmt_opt_itemContext extends antlr.ParserRuleContext { } -export class CreatecaststmtContext extends antlr.ParserRuleContext { +export class TriggerwhenContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_CAST(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CAST, 0)!; + public KW_WHEN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WHEN, 0)!; } public OPEN_PAREN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public typename(): TypenameContext[]; - public typename(i: number): TypenameContext | null; - public typename(i?: number): TypenameContext[] | TypenameContext | null { - if (i === undefined) { - return this.getRuleContexts(TypenameContext); - } - - return this.getRuleContext(i, TypenameContext); - } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; } public CLOSE_PAREN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); - } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); - } - public function_with_argtypes(): Function_with_argtypesContext | null { - return this.getRuleContext(0, Function_with_argtypesContext); - } - public cast_context(): Cast_contextContext | null { - return this.getRuleContext(0, Cast_contextContext); - } - public KW_WITHOUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); - } - public KW_INOUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INOUT, 0); - } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createcaststmt; + return PostgreSqlParser.RULE_triggerwhen; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatecaststmt) { - listener.enterCreatecaststmt(this); + if(listener.enterTriggerwhen) { + listener.enterTriggerwhen(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatecaststmt) { - listener.exitCreatecaststmt(this); + if(listener.exitTriggerwhen) { + listener.exitTriggerwhen(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatecaststmt) { - return visitor.visitCreatecaststmt(this); + if (visitor.visitTriggerwhen) { + return visitor.visitTriggerwhen(this); } else { return visitor.visitChildren(this); } @@ -91683,35 +66601,38 @@ export class CreatecaststmtContext extends antlr.ParserRuleContext { } -export class Cast_contextContext extends antlr.ParserRuleContext { +export class Function_or_procedureContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); } - public KW_IMPLICIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IMPLICIT, 0); + public function_name(): Function_nameContext | null { + return this.getRuleContext(0, Function_nameContext); } - public KW_ASSIGNMENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ASSIGNMENT, 0); + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + } + public procedure_name(): Procedure_nameContext | null { + return this.getRuleContext(0, Procedure_nameContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_cast_context; + return PostgreSqlParser.RULE_function_or_procedure; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCast_context) { - listener.enterCast_context(this); + if(listener.enterFunction_or_procedure) { + listener.enterFunction_or_procedure(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCast_context) { - listener.exitCast_context(this); + if(listener.exitFunction_or_procedure) { + listener.exitFunction_or_procedure(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCast_context) { - return visitor.visitCast_context(this); + if (visitor.visitFunction_or_procedure) { + return visitor.visitFunction_or_procedure(this); } else { return visitor.visitChildren(this); } @@ -91719,32 +66640,44 @@ export class Cast_contextContext extends antlr.ParserRuleContext { } -export class Opt_if_existsContext extends antlr.ParserRuleContext { +export class TriggerfuncargsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_IF(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_IF, 0)!; + public triggerfuncarg(): TriggerfuncargContext[]; + public triggerfuncarg(i: number): TriggerfuncargContext | null; + public triggerfuncarg(i?: number): TriggerfuncargContext[] | TriggerfuncargContext | null { + if (i === undefined) { + return this.getRuleContexts(TriggerfuncargContext); + } + + return this.getRuleContext(i, TriggerfuncargContext); } - public KW_EXISTS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXISTS, 0)!; + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_if_exists; + return PostgreSqlParser.RULE_triggerfuncargs; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_if_exists) { - listener.enterOpt_if_exists(this); + if(listener.enterTriggerfuncargs) { + listener.enterTriggerfuncargs(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_if_exists) { - listener.exitOpt_if_exists(this); + if(listener.exitTriggerfuncargs) { + listener.exitTriggerfuncargs(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_if_exists) { - return visitor.visitOpt_if_exists(this); + if (visitor.visitTriggerfuncargs) { + return visitor.visitTriggerfuncargs(this); } else { return visitor.visitChildren(this); } @@ -91752,56 +66685,38 @@ export class Opt_if_existsContext extends antlr.ParserRuleContext { } -export class CreatetransformstmtContext extends antlr.ParserRuleContext { +export class TriggerfuncargContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_TRANSFORM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0)!; - } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; - } - public typename(): TypenameContext { - return this.getRuleContext(0, TypenameContext)!; - } - public KW_LANGUAGE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public Integral(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.Integral, 0); } - public transform_element_list(): Transform_element_listContext { - return this.getRuleContext(0, Transform_element_listContext)!; + public Numeric(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.Numeric, 0); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } - public opt_or_replace(): Opt_or_replaceContext | null { - return this.getRuleContext(0, Opt_or_replaceContext); + public collabel(): CollabelContext | null { + return this.getRuleContext(0, CollabelContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createtransformstmt; + return PostgreSqlParser.RULE_triggerfuncarg; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatetransformstmt) { - listener.enterCreatetransformstmt(this); + if(listener.enterTriggerfuncarg) { + listener.enterTriggerfuncarg(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatetransformstmt) { - listener.exitCreatetransformstmt(this); + if(listener.exitTriggerfuncarg) { + listener.exitTriggerfuncarg(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatetransformstmt) { - return visitor.visitCreatetransformstmt(this); + if (visitor.visitTriggerfuncarg) { + return visitor.visitTriggerfuncarg(this); } else { return visitor.visitChildren(this); } @@ -91809,71 +66724,50 @@ export class CreatetransformstmtContext extends antlr.ParserRuleContext { } -export class Transform_element_listContext extends antlr.ParserRuleContext { +export class ConstraintattributeElemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); + public KW_DEFERRABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFERRABLE, 0); } - public KW_SQL(): antlr.TerminalNode[]; - public KW_SQL(i: number): antlr.TerminalNode | null; - public KW_SQL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_SQL); - } else { - return this.getToken(PostgreSqlParser.KW_SQL, i); - } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } - public KW_WITH(): antlr.TerminalNode[]; - public KW_WITH(i: number): antlr.TerminalNode | null; - public KW_WITH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_WITH); - } else { - return this.getToken(PostgreSqlParser.KW_WITH, i); - } + public KW_INITIALLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INITIALLY, 0); } - public KW_FUNCTION(): antlr.TerminalNode[]; - public KW_FUNCTION(i: number): antlr.TerminalNode | null; - public KW_FUNCTION(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_FUNCTION); - } else { - return this.getToken(PostgreSqlParser.KW_FUNCTION, i); - } + public KW_IMMEDIATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IMMEDIATE, 0); } - public function_with_argtypes(): Function_with_argtypesContext[]; - public function_with_argtypes(i: number): Function_with_argtypesContext | null; - public function_with_argtypes(i?: number): Function_with_argtypesContext[] | Function_with_argtypesContext | null { - if (i === undefined) { - return this.getRuleContexts(Function_with_argtypesContext); - } - - return this.getRuleContext(i, Function_with_argtypesContext); + public KW_DEFERRED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFERRED, 0); } - public COMMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.COMMA, 0); + public KW_VALID(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALID, 0); } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); + } + public KW_INHERIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INHERIT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_transform_element_list; + return PostgreSqlParser.RULE_constraintattributeElem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTransform_element_list) { - listener.enterTransform_element_list(this); + if(listener.enterConstraintattributeElem) { + listener.enterConstraintattributeElem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTransform_element_list) { - listener.exitTransform_element_list(this); + if(listener.exitConstraintattributeElem) { + listener.exitConstraintattributeElem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTransform_element_list) { - return visitor.visitTransform_element_list(this); + if (visitor.visitConstraintattributeElem) { + return visitor.visitConstraintattributeElem(this); } else { return visitor.visitChildren(this); } @@ -91881,86 +66775,77 @@ export class Transform_element_listContext extends antlr.ParserRuleContext { } -export class ReindexstmtContext extends antlr.ParserRuleContext { +export class CreateeventtrigstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_REINDEX(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_REINDEX, 0)!; - } - public reindex_target_type(): Reindex_target_typeContext | null { - return this.getRuleContext(0, Reindex_target_typeContext); - } - public reindex_target_multitable(): Reindex_target_multitableContext | null { - return this.getRuleContext(0, Reindex_target_multitableContext); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public reindex_option_list(): Reindex_option_listContext | null { - return this.getRuleContext(0, Reindex_option_listContext); + public KW_EVENT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EVENT, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_TRIGGER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TRIGGER, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_reindexstmt; + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReindexstmt) { - listener.enterReindexstmt(this); - } + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReindexstmt) { - listener.exitReindexstmt(this); - } + public collabel(): CollabelContext { + return this.getRuleContext(0, CollabelContext)!; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReindexstmt) { - return visitor.visitReindexstmt(this); - } else { - return visitor.visitChildren(this); - } + public KW_EXECUTE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EXECUTE, 0)!; } -} - - -export class Reindex_target_typeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public function_or_procedure(): Function_or_procedureContext { + return this.getRuleContext(0, Function_or_procedureContext)!; } - public KW_INDEX(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INDEX, 0); + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public qualified_name(): Qualified_nameContext | null { - return this.getRuleContext(0, Qualified_nameContext); + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public opt_concurrently(): Opt_concurrentlyContext | null { - return this.getRuleContext(0, Opt_concurrentlyContext); + public KW_WHEN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WHEN, 0); } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); + public event_trigger_when_item(): Event_trigger_when_itemContext[]; + public event_trigger_when_item(i: number): Event_trigger_when_itemContext | null; + public event_trigger_when_item(i?: number): Event_trigger_when_itemContext[] | Event_trigger_when_itemContext | null { + if (i === undefined) { + return this.getRuleContexts(Event_trigger_when_itemContext); + } + + return this.getRuleContext(i, Event_trigger_when_itemContext); } - public table_name(): Table_nameContext | null { - return this.getRuleContext(0, Table_nameContext); + public KW_AND(): antlr.TerminalNode[]; + public KW_AND(i: number): antlr.TerminalNode | null; + public KW_AND(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_AND); + } else { + return this.getToken(PostgreSqlParser.KW_AND, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_reindex_target_type; + return PostgreSqlParser.RULE_createeventtrigstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReindex_target_type) { - listener.enterReindex_target_type(this); + if(listener.enterCreateeventtrigstmt) { + listener.enterCreateeventtrigstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReindex_target_type) { - listener.exitReindex_target_type(this); + if(listener.exitCreateeventtrigstmt) { + listener.exitCreateeventtrigstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReindex_target_type) { - return visitor.visitReindex_target_type(this); + if (visitor.visitCreateeventtrigstmt) { + return visitor.visitCreateeventtrigstmt(this); } else { return visitor.visitChildren(this); } @@ -91968,47 +66853,50 @@ export class Reindex_target_typeContext extends antlr.ParserRuleContext { } -export class Reindex_target_multitableContext extends antlr.ParserRuleContext { +export class Event_trigger_when_itemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); - } - public schema_name(): Schema_nameContext | null { - return this.getRuleContext(0, Schema_nameContext); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public opt_concurrently(): Opt_concurrentlyContext | null { - return this.getRuleContext(0, Opt_concurrentlyContext); + public KW_IN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_IN, 0)!; } - public KW_SYSTEM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SYSTEM, 0); + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); + public sconst(): SconstContext { + return this.getRuleContext(0, SconstContext)!; } - public KW_DATABASE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATABASE, 0); + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public database_name(): Database_nameContext | null { - return this.getRuleContext(0, Database_nameContext); + public notify_payload(): Notify_payloadContext[]; + public notify_payload(i: number): Notify_payloadContext | null; + public notify_payload(i?: number): Notify_payloadContext[] | Notify_payloadContext | null { + if (i === undefined) { + return this.getRuleContexts(Notify_payloadContext); + } + + return this.getRuleContext(i, Notify_payloadContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_reindex_target_multitable; + return PostgreSqlParser.RULE_event_trigger_when_item; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReindex_target_multitable) { - listener.enterReindex_target_multitable(this); + if(listener.enterEvent_trigger_when_item) { + listener.enterEvent_trigger_when_item(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReindex_target_multitable) { - listener.exitReindex_target_multitable(this); + if(listener.exitEvent_trigger_when_item) { + listener.exitEvent_trigger_when_item(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReindex_target_multitable) { - return visitor.visitReindex_target_multitable(this); + if (visitor.visitEvent_trigger_when_item) { + return visitor.visitEvent_trigger_when_item(this); } else { return visitor.visitChildren(this); } @@ -92016,74 +66904,50 @@ export class Reindex_target_multitableContext extends antlr.ParserRuleContext { } -export class Reindex_option_listContext extends antlr.ParserRuleContext { +export class AltereventtrigstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public reindex_option_elem(): Reindex_option_elemContext[]; - public reindex_option_elem(i: number): Reindex_option_elemContext | null; - public reindex_option_elem(i?: number): Reindex_option_elemContext[] | Reindex_option_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Reindex_option_elemContext); - } - - return this.getRuleContext(i, Reindex_option_elemContext); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_EVENT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EVENT, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_reindex_option_list; + public KW_TRIGGER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TRIGGER, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReindex_option_list) { - listener.enterReindex_option_list(this); - } + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReindex_option_list) { - listener.exitReindex_option_list(this); - } + public KW_ENABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ENABLE, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReindex_option_list) { - return visitor.visitReindex_option_list(this); - } else { - return visitor.visitChildren(this); - } + public KW_DISABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DISABLE, 0); } -} - - -export class Reindex_option_elemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_REPLICA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REPLICA, 0); } - public KW_VERBOSE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VERBOSE, 0)!; + public KW_ALWAYS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALWAYS, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_reindex_option_elem; + return PostgreSqlParser.RULE_altereventtrigstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReindex_option_elem) { - listener.enterReindex_option_elem(this); + if(listener.enterAltereventtrigstmt) { + listener.enterAltereventtrigstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReindex_option_elem) { - listener.exitReindex_option_elem(this); + if(listener.exitAltereventtrigstmt) { + listener.exitAltereventtrigstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReindex_option_elem) { - return visitor.visitReindex_option_elem(this); + if (visitor.visitAltereventtrigstmt) { + return visitor.visitAltereventtrigstmt(this); } else { return visitor.visitChildren(this); } @@ -92091,44 +66955,56 @@ export class Reindex_option_elemContext extends antlr.ParserRuleContext { } -export class AltertblspcstmtContext extends antlr.ParserRuleContext { +export class CreateassertionstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public KW_TABLESPACE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0)!; + public KW_ASSERTION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ASSERTION, 0)!; } - public tablespace_name(): Tablespace_nameContext { - return this.getRuleContext(0, Tablespace_nameContext)!; + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); + public KW_CHECK(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CHECK, 0)!; } - public reloptions(): ReloptionsContext { - return this.getRuleContext(0, ReloptionsContext)!; + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public KW_RESET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESET, 0); + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + } + public constraintattributeElem(): ConstraintattributeElemContext[]; + public constraintattributeElem(i: number): ConstraintattributeElemContext | null; + public constraintattributeElem(i?: number): ConstraintattributeElemContext[] | ConstraintattributeElemContext | null { + if (i === undefined) { + return this.getRuleContexts(ConstraintattributeElemContext); + } + + return this.getRuleContext(i, ConstraintattributeElemContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_altertblspcstmt; + return PostgreSqlParser.RULE_createassertionstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAltertblspcstmt) { - listener.enterAltertblspcstmt(this); + if(listener.enterCreateassertionstmt) { + listener.enterCreateassertionstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAltertblspcstmt) { - listener.exitAltertblspcstmt(this); + if(listener.exitCreateassertionstmt) { + listener.exitCreateassertionstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAltertblspcstmt) { - return visitor.visitAltertblspcstmt(this); + if (visitor.visitCreateassertionstmt) { + return visitor.visitCreateassertionstmt(this); } else { return visitor.visitChildren(this); } @@ -92136,257 +67012,269 @@ export class AltertblspcstmtContext extends antlr.ParserRuleContext { } -export class RenamestmtContext extends antlr.ParserRuleContext { +export class DefinestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } public KW_AGGREGATE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); } - public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { - return this.getRuleContext(0, Aggregate_with_argtypesContext); - } - public KW_RENAME(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_RENAME, 0)!; + public function_name(): Function_nameContext | null { + return this.getRuleContext(0, Function_nameContext); } - public KW_TO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TO, 0)!; + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public name(): NameContext[]; - public name(i: number): NameContext | null; - public name(i?: number): NameContext[] | NameContext | null { + public old_aggr_elem(): Old_aggr_elemContext[]; + public old_aggr_elem(i: number): Old_aggr_elemContext | null; + public old_aggr_elem(i?: number): Old_aggr_elemContext[] | Old_aggr_elemContext | null { if (i === undefined) { - return this.getRuleContexts(NameContext); + return this.getRuleContexts(Old_aggr_elemContext); } - return this.getRuleContext(i, NameContext); - } - public KW_COLLATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLLATION, 0); - } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); - } - public KW_CONVERSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONVERSION, 0); - } - public KW_DATABASE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATABASE, 0); - } - public database_name(): Database_nameContext | null { - return this.getRuleContext(0, Database_nameContext); - } - public database_name_create(): Database_name_createContext | null { - return this.getRuleContext(0, Database_name_createContext); - } - public KW_DOMAIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); + return this.getRuleContext(i, Old_aggr_elemContext); } - public KW_CONSTRAINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public KW_FOREIGN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); + public opt_or_replace(): Opt_or_replaceContext | null { + return this.getRuleContext(0, Opt_or_replaceContext); } - public KW_DATA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATA, 0); + public aggr_args(): Aggr_argsContext | null { + return this.getRuleContext(0, Aggr_argsContext); } - public KW_WRAPPER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); + public definition(): DefinitionContext | null { + return this.getRuleContext(0, DefinitionContext); } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } - public function_with_argtypes(): Function_with_argtypesContext | null { - return this.getRuleContext(0, Function_with_argtypesContext); + public KW_OPERATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); } - public function_name_create(): Function_name_createContext | null { - return this.getRuleContext(0, Function_name_createContext); + public any_operator(): Any_operatorContext | null { + return this.getRuleContext(0, Any_operatorContext); } - public KW_GROUP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GROUP, 0); + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); } - public roleid(): RoleidContext[]; - public roleid(i: number): RoleidContext | null; - public roleid(i?: number): RoleidContext[] | RoleidContext | null { + public any_name(): Any_nameContext[]; + public any_name(i: number): Any_nameContext | null; + public any_name(i?: number): Any_nameContext[] | Any_nameContext | null { if (i === undefined) { - return this.getRuleContexts(RoleidContext); + return this.getRuleContexts(Any_nameContext); } - return this.getRuleContext(i, RoleidContext); - } - public KW_LANGUAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); - } - public opt_procedural(): Opt_proceduralContext | null { - return this.getRuleContext(0, Opt_proceduralContext); - } - public KW_OPERATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); - } - public KW_CLASS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CLASS, 0); - } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); - } - public KW_FAMILY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FAMILY, 0); - } - public KW_POLICY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_POLICY, 0); - } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); + return this.getRuleContext(i, Any_nameContext); } - public qualified_name(): Qualified_nameContext | null { - return this.getRuleContext(0, Qualified_nameContext); + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); + public KW_ENUM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ENUM, 0); } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + public tablefuncelementlist(): TablefuncelementlistContext | null { + return this.getRuleContext(0, TablefuncelementlistContext); } - public procedure_with_argtypes(): Procedure_with_argtypesContext | null { - return this.getRuleContext(0, Procedure_with_argtypesContext); + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } - public procedure_name_create(): Procedure_name_createContext | null { - return this.getRuleContext(0, Procedure_name_createContext); + public notify_payload(): Notify_payloadContext[]; + public notify_payload(i: number): Notify_payloadContext | null; + public notify_payload(i?: number): Notify_payloadContext[] | Notify_payloadContext | null { + if (i === undefined) { + return this.getRuleContexts(Notify_payloadContext); + } + + return this.getRuleContext(i, Notify_payloadContext); } - public KW_PUBLICATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); + public KW_RANGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RANGE, 0); } - public KW_ROUTINE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); + public KW_TEXT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEXT, 0); } - public routine_with_argtypes(): Routine_with_argtypesContext | null { - return this.getRuleContext(0, Routine_with_argtypesContext); + public KW_SEARCH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEARCH, 0); } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); + public KW_PARSER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARSER, 0); } - public schema_name(): Schema_nameContext | null { - return this.getRuleContext(0, Schema_nameContext); + public KW_DICTIONARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); } - public schema_name_create(): Schema_name_createContext | null { - return this.getRuleContext(0, Schema_name_createContext); + public KW_TEMPLATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); } - public KW_SERVER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SERVER, 0); + public KW_CONFIGURATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); } - public KW_SUBSCRIPTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0); + public KW_COLLATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLLATION, 0); } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); } - public relation_expr(): Relation_exprContext | null { - return this.getRuleContext(0, Relation_exprContext); + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); } - public table_name_create(): Table_name_createContext | null { - return this.getRuleContext(0, Table_name_createContext); + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_definestmt; } - public KW_SEQUENCE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterDefinestmt) { + listener.enterDefinestmt(this); + } } - public KW_VIEW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VIEW, 0); + public override exitRule(listener: PostgreSqlParserListener): void { + if(listener.exitDefinestmt) { + listener.exitDefinestmt(this); + } } - public view_name(): View_nameContext | null { - return this.getRuleContext(0, View_nameContext); + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitDefinestmt) { + return visitor.visitDefinestmt(this); + } else { + return visitor.visitChildren(this); + } } - public view_name_create(): View_name_createContext | null { - return this.getRuleContext(0, View_name_createContext); +} + + +export class DefinitionContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); } - public KW_MATERIALIZED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public KW_INDEX(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INDEX, 0); + public def_elem(): Def_elemContext[]; + public def_elem(i: number): Def_elemContext | null; + public def_elem(i?: number): Def_elemContext[] | Def_elemContext | null { + if (i === undefined) { + return this.getRuleContexts(Def_elemContext); + } + + return this.getRuleContext(i, Def_elemContext); } - public column_name(): Column_nameContext | null { - return this.getRuleContext(0, Column_nameContext); + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public column_name_create(): Column_name_createContext | null { - return this.getRuleContext(0, Column_name_createContext); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } - public KW_COLUMN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLUMN, 0); + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_definition; } - public KW_RULE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RULE, 0); + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterDefinition) { + listener.enterDefinition(this); + } } - public KW_TRIGGER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); + public override exitRule(listener: PostgreSqlParserListener): void { + if(listener.exitDefinition) { + listener.exitDefinition(this); + } } - public KW_EVENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EVENT, 0); + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitDefinition) { + return visitor.visitDefinition(this); + } else { + return visitor.visitChildren(this); + } } - public KW_ROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLE, 0); +} + + +export class Def_elemContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); } - public KW_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USER, 0); + public collabel(): CollabelContext { + return this.getRuleContext(0, CollabelContext)!; } - public KW_TABLESPACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); + public EQUAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.EQUAL, 0); } - public tablespace_name(): Tablespace_nameContext | null { - return this.getRuleContext(0, Tablespace_nameContext); + public def_arg(): Def_argContext | null { + return this.getRuleContext(0, Def_argContext); } - public tablespace_name_create(): Tablespace_name_createContext | null { - return this.getRuleContext(0, Tablespace_name_createContext); + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_def_elem; } - public KW_STATISTICS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterDef_elem) { + listener.enterDef_elem(this); + } } - public KW_TEXT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEXT, 0); + public override exitRule(listener: PostgreSqlParserListener): void { + if(listener.exitDef_elem) { + listener.exitDef_elem(this); + } } - public KW_SEARCH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEARCH, 0); + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitDef_elem) { + return visitor.visitDef_elem(this); + } else { + return visitor.visitChildren(this); + } } - public KW_PARSER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARSER, 0); +} + + +export class Def_argContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); } - public KW_DICTIONARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); + public func_type(): Func_typeContext | null { + return this.getRuleContext(0, Func_typeContext); } - public KW_TEMPLATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); + public reserved_keyword(): Reserved_keywordContext | null { + return this.getRuleContext(0, Reserved_keywordContext); } - public KW_CONFIGURATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); + public qual_all_op(): Qual_all_opContext | null { + return this.getRuleContext(0, Qual_all_opContext); } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); } - public KW_ATTRIBUTE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ATTRIBUTE, 0); + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } - public opt_drop_behavior(): Opt_drop_behaviorContext | null { - return this.getRuleContext(0, Opt_drop_behaviorContext); + public KW_NONE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NONE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_renamestmt; + return PostgreSqlParser.RULE_def_arg; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRenamestmt) { - listener.enterRenamestmt(this); + if(listener.enterDef_arg) { + listener.enterDef_arg(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRenamestmt) { - listener.exitRenamestmt(this); + if(listener.exitDef_arg) { + listener.exitDef_arg(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRenamestmt) { - return visitor.visitRenamestmt(this); + if (visitor.visitDef_arg) { + return visitor.visitDef_arg(this); } else { return visitor.visitChildren(this); } @@ -92394,32 +67282,35 @@ export class RenamestmtContext extends antlr.ParserRuleContext { } -export class Opt_set_dataContext extends antlr.ParserRuleContext { +export class Old_aggr_elemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_SET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SET, 0)!; + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext)!; } - public KW_DATA(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DATA, 0)!; + public EQUAL(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.EQUAL, 0)!; + } + public def_arg(): Def_argContext { + return this.getRuleContext(0, Def_argContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_set_data; + return PostgreSqlParser.RULE_old_aggr_elem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_set_data) { - listener.enterOpt_set_data(this); + if(listener.enterOld_aggr_elem) { + listener.enterOld_aggr_elem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_set_data) { - listener.exitOpt_set_data(this); + if(listener.exitOld_aggr_elem) { + listener.exitOld_aggr_elem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_set_data) { - return visitor.visitOpt_set_data(this); + if (visitor.visitOld_aggr_elem) { + return visitor.visitOld_aggr_elem(this); } else { return visitor.visitChildren(this); } @@ -92427,92 +67318,65 @@ export class Opt_set_dataContext extends antlr.ParserRuleContext { } -export class AlterobjectdependsstmtContext extends antlr.ParserRuleContext { +export class AlterenumstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } public KW_ALTER(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); - } - public function_with_argtypes(): Function_with_argtypesContext | null { - return this.getRuleContext(0, Function_with_argtypesContext); + public KW_TYPE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TYPE, 0)!; } - public KW_DEPENDS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DEPENDS, 0)!; + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; } - public KW_ON(): antlr.TerminalNode[]; - public KW_ON(i: number): antlr.TerminalNode | null; - public KW_ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_ON); - } else { - return this.getToken(PostgreSqlParser.KW_ON, i); - } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADD, 0); } - public KW_EXTENSION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXTENSION, 0)!; + public KW_VALUE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_VALUE, 0)!; } - public name(): NameContext[]; - public name(i: number): NameContext | null; - public name(i?: number): NameContext[] | NameContext | null { + public sconst(): SconstContext[]; + public sconst(i: number): SconstContext | null; + public sconst(i?: number): SconstContext[] | SconstContext | null { if (i === undefined) { - return this.getRuleContexts(NameContext); + return this.getRuleContexts(SconstContext); } - return this.getRuleContext(i, NameContext); - } - public opt_no(): Opt_noContext | null { - return this.getRuleContext(0, Opt_noContext); - } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); - } - public procedure_with_argtypes(): Procedure_with_argtypesContext | null { - return this.getRuleContext(0, Procedure_with_argtypesContext); - } - public KW_ROUTINE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); - } - public routine_with_argtypes(): Routine_with_argtypesContext | null { - return this.getRuleContext(0, Routine_with_argtypesContext); - } - public KW_TRIGGER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); + return this.getRuleContext(i, SconstContext); } - public qualified_name(): Qualified_nameContext | null { - return this.getRuleContext(0, Qualified_nameContext); + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); } - public KW_MATERIALIZED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); + public KW_BEFORE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BEFORE, 0); } - public KW_VIEW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VIEW, 0); + public KW_AFTER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AFTER, 0); } - public view_name(): View_nameContext | null { - return this.getRuleContext(0, View_nameContext); + public KW_RENAME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RENAME, 0); } - public KW_INDEX(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INDEX, 0); + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterobjectdependsstmt; + return PostgreSqlParser.RULE_alterenumstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterobjectdependsstmt) { - listener.enterAlterobjectdependsstmt(this); + if(listener.enterAlterenumstmt) { + listener.enterAlterenumstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterobjectdependsstmt) { - listener.exitAlterobjectdependsstmt(this); + if(listener.exitAlterenumstmt) { + listener.exitAlterenumstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterobjectdependsstmt) { - return visitor.visitAlterobjectdependsstmt(this); + if (visitor.visitAlterenumstmt) { + return visitor.visitAlterenumstmt(this); } else { return visitor.visitChildren(this); } @@ -92520,29 +67384,35 @@ export class AlterobjectdependsstmtContext extends antlr.ParserRuleContext { } -export class Opt_noContext extends antlr.ParserRuleContext { +export class Opt_if_not_existsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_NO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_NO, 0)!; + public KW_IF(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_IF, 0)!; + } + public KW_NOT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_NOT, 0)!; + } + public KW_EXISTS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EXISTS, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_no; + return PostgreSqlParser.RULE_opt_if_not_exists; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_no) { - listener.enterOpt_no(this); + if(listener.enterOpt_if_not_exists) { + listener.enterOpt_if_not_exists(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_no) { - listener.exitOpt_no(this); + if(listener.exitOpt_if_not_exists) { + listener.exitOpt_if_not_exists(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_no) { - return visitor.visitOpt_no(this); + if (visitor.visitOpt_if_not_exists) { + return visitor.visitOpt_if_not_exists(this); } else { return visitor.visitChildren(this); } @@ -92550,146 +67420,155 @@ export class Opt_noContext extends antlr.ParserRuleContext { } -export class AlterobjectschemastmtContext extends antlr.ParserRuleContext { +export class CreateopclassstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_AGGREGATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); - } - public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { - return this.getRuleContext(0, Aggregate_with_argtypesContext); - } - public KW_SET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SET, 0)!; - } - public KW_SCHEMA(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0)!; - } - public schema_name(): Schema_nameContext { - return this.getRuleContext(0, Schema_nameContext)!; - } - public KW_COLLATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLLATION, 0); - } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public KW_CONVERSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONVERSION, 0); + public KW_OPERATOR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0)!; } - public KW_DOMAIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); + public KW_CLASS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CLASS, 0)!; } - public KW_EXTENSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXTENSION, 0); + public any_name(): Any_nameContext[]; + public any_name(i: number): Any_nameContext | null; + public any_name(i?: number): Any_nameContext[] | Any_nameContext | null { + if (i === undefined) { + return this.getRuleContexts(Any_nameContext); + } + + return this.getRuleContext(i, Any_nameContext); } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); + public KW_FOR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOR, 0)!; } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + public KW_TYPE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TYPE, 0)!; } - public function_with_argtypes(): Function_with_argtypesContext | null { - return this.getRuleContext(0, Function_with_argtypesContext); + public typename(): TypenameContext { + return this.getRuleContext(0, TypenameContext)!; } - public KW_OPERATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); + public table_access_method_clause(): Table_access_method_clauseContext { + return this.getRuleContext(0, Table_access_method_clauseContext)!; } - public operator_with_argtypes(): Operator_with_argtypesContext | null { - return this.getRuleContext(0, Operator_with_argtypesContext); + public KW_AS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_AS, 0)!; } - public KW_CLASS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CLASS, 0); + public opclass_item(): Opclass_itemContext[]; + public opclass_item(i: number): Opclass_itemContext | null; + public opclass_item(i?: number): Opclass_itemContext[] | Opclass_itemContext | null { + if (i === undefined) { + return this.getRuleContexts(Opclass_itemContext); + } + + return this.getRuleContext(i, Opclass_itemContext); } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } public KW_FAMILY(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_FAMILY, 0); } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } - public procedure_with_argtypes(): Procedure_with_argtypesContext | null { - return this.getRuleContext(0, Procedure_with_argtypesContext); + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_createopclassstmt; } - public KW_ROUTINE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterCreateopclassstmt) { + listener.enterCreateopclassstmt(this); + } } - public routine_with_argtypes(): Routine_with_argtypesContext | null { - return this.getRuleContext(0, Routine_with_argtypesContext); + public override exitRule(listener: PostgreSqlParserListener): void { + if(listener.exitCreateopclassstmt) { + listener.exitCreateopclassstmt(this); + } } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitCreateopclassstmt) { + return visitor.visitCreateopclassstmt(this); + } else { + return visitor.visitChildren(this); + } } - public relation_expr(): Relation_exprContext | null { - return this.getRuleContext(0, Relation_exprContext); +} + + +export class Opclass_itemContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); + public KW_OPERATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); } - public KW_STATISTICS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); + public Integral(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.Integral, 0); } - public KW_TEXT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEXT, 0); + public any_operator(): Any_operatorContext | null { + return this.getRuleContext(0, Any_operatorContext); } - public KW_SEARCH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEARCH, 0); + public oper_argtypes(): Oper_argtypesContext | null { + return this.getRuleContext(0, Oper_argtypesContext); } - public KW_PARSER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARSER, 0); + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } - public KW_DICTIONARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); + public KW_RECHECK(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RECHECK, 0); } - public KW_TEMPLATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); + public KW_SEARCH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEARCH, 0); } - public KW_CONFIGURATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); + public KW_ORDER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ORDER, 0); } - public KW_SEQUENCE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BY, 0); } - public qualified_name(): Qualified_nameContext | null { - return this.getRuleContext(0, Qualified_nameContext); + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); } - public KW_VIEW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VIEW, 0); + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); } - public view_name(): View_nameContext | null { - return this.getRuleContext(0, View_nameContext); + public function_with_argtypes(): Function_with_argtypesContext | null { + return this.getRuleContext(0, Function_with_argtypesContext); } - public KW_MATERIALIZED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); + public prep_type_clause(): Prep_type_clauseContext | null { + return this.getRuleContext(0, Prep_type_clauseContext); } - public KW_FOREIGN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); + public KW_STORAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STORAGE, 0); } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); + public typename(): TypenameContext | null { + return this.getRuleContext(0, TypenameContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterobjectschemastmt; + return PostgreSqlParser.RULE_opclass_item; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterobjectschemastmt) { - listener.enterAlterobjectschemastmt(this); + if(listener.enterOpclass_item) { + listener.enterOpclass_item(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterobjectschemastmt) { - listener.exitAlterobjectschemastmt(this); + if(listener.exitOpclass_item) { + listener.exitOpclass_item(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterobjectschemastmt) { - return visitor.visitAlterobjectschemastmt(this); + if (visitor.visitOpclass_item) { + return visitor.visitOpclass_item(this); } else { return visitor.visitChildren(this); } @@ -92697,47 +67576,41 @@ export class AlterobjectschemastmtContext extends antlr.ParserRuleContext { } -export class AlteroperatorstmtContext extends antlr.ParserRuleContext { +export class CreateopfamilystmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } public KW_OPERATOR(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_OPERATOR, 0)!; } - public operator_with_argtypes(): Operator_with_argtypesContext { - return this.getRuleContext(0, Operator_with_argtypesContext)!; - } - public KW_SET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SET, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_FAMILY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FAMILY, 0)!; } - public operator_def_list(): Operator_def_listContext { - return this.getRuleContext(0, Operator_def_listContext)!; + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public table_access_method_clause(): Table_access_method_clauseContext { + return this.getRuleContext(0, Table_access_method_clauseContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alteroperatorstmt; + return PostgreSqlParser.RULE_createopfamilystmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlteroperatorstmt) { - listener.enterAlteroperatorstmt(this); + if(listener.enterCreateopfamilystmt) { + listener.enterCreateopfamilystmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlteroperatorstmt) { - listener.exitAlteroperatorstmt(this); + if(listener.exitCreateopfamilystmt) { + listener.exitCreateopfamilystmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlteroperatorstmt) { - return visitor.visitAlteroperatorstmt(this); + if (visitor.visitCreateopfamilystmt) { + return visitor.visitCreateopfamilystmt(this); } else { return visitor.visitChildren(this); } @@ -92745,18 +67618,48 @@ export class AlteroperatorstmtContext extends antlr.ParserRuleContext { } -export class Operator_def_listContext extends antlr.ParserRuleContext { +export class AlteropfamilystmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public operator_def_elem(): Operator_def_elemContext[]; - public operator_def_elem(i: number): Operator_def_elemContext | null; - public operator_def_elem(i?: number): Operator_def_elemContext[] | Operator_def_elemContext | null { + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public KW_OPERATOR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0)!; + } + public KW_FAMILY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FAMILY, 0)!; + } + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; + } + public table_access_method_clause(): Table_access_method_clauseContext { + return this.getRuleContext(0, Table_access_method_clauseContext)!; + } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADD, 0); + } + public opclass_item(): Opclass_itemContext[]; + public opclass_item(i: number): Opclass_itemContext | null; + public opclass_item(i?: number): Opclass_itemContext[] | Opclass_itemContext | null { if (i === undefined) { - return this.getRuleContexts(Operator_def_elemContext); + return this.getRuleContexts(Opclass_itemContext); } - return this.getRuleContext(i, Operator_def_elemContext); + return this.getRuleContext(i, Opclass_itemContext); + } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); + } + public opclass_drop(): Opclass_dropContext[]; + public opclass_drop(i: number): Opclass_dropContext | null; + public opclass_drop(i?: number): Opclass_dropContext[] | Opclass_dropContext | null { + if (i === undefined) { + return this.getRuleContexts(Opclass_dropContext); + } + + return this.getRuleContext(i, Opclass_dropContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -92768,21 +67671,21 @@ export class Operator_def_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_operator_def_list; + return PostgreSqlParser.RULE_alteropfamilystmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOperator_def_list) { - listener.enterOperator_def_list(this); + if(listener.enterAlteropfamilystmt) { + listener.enterAlteropfamilystmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOperator_def_list) { - listener.exitOperator_def_list(this); + if(listener.exitAlteropfamilystmt) { + listener.exitAlteropfamilystmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOperator_def_list) { - return visitor.visitOperator_def_list(this); + if (visitor.visitAlteropfamilystmt) { + return visitor.visitAlteropfamilystmt(this); } else { return visitor.visitChildren(this); } @@ -92790,38 +67693,38 @@ export class Operator_def_listContext extends antlr.ParserRuleContext { } -export class Operator_def_elemContext extends antlr.ParserRuleContext { +export class Opclass_dropContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public collabel(): CollabelContext { - return this.getRuleContext(0, CollabelContext)!; + public Integral(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.Integral, 0)!; } - public EQUAL(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.EQUAL, 0)!; + public prep_type_clause(): Prep_type_clauseContext { + return this.getRuleContext(0, Prep_type_clauseContext)!; } - public KW_NONE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NONE, 0); + public KW_OPERATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); } - public operator_def_arg(): Operator_def_argContext | null { - return this.getRuleContext(0, Operator_def_argContext); + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_operator_def_elem; + return PostgreSqlParser.RULE_opclass_drop; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOperator_def_elem) { - listener.enterOperator_def_elem(this); + if(listener.enterOpclass_drop) { + listener.enterOpclass_drop(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOperator_def_elem) { - listener.exitOperator_def_elem(this); + if(listener.exitOpclass_drop) { + listener.exitOpclass_drop(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOperator_def_elem) { - return visitor.visitOperator_def_elem(this); + if (visitor.visitOpclass_drop) { + return visitor.visitOpclass_drop(this); } else { return visitor.visitChildren(this); } @@ -92829,41 +67732,44 @@ export class Operator_def_elemContext extends antlr.ParserRuleContext { } -export class Operator_def_argContext extends antlr.ParserRuleContext { +export class ReassignownedstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public func_type(): Func_typeContext | null { - return this.getRuleContext(0, Func_typeContext); + public KW_REASSIGN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_REASSIGN, 0)!; } - public reserved_keyword(): Reserved_keywordContext | null { - return this.getRuleContext(0, Reserved_keywordContext); + public KW_OWNED(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_OWNED, 0)!; } - public qual_all_op(): Qual_all_opContext | null { - return this.getRuleContext(0, Qual_all_opContext); + public KW_BY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_BY, 0)!; } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); + public role_list(): Role_listContext { + return this.getRuleContext(0, Role_listContext)!; } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); + public KW_TO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TO, 0)!; + } + public rolespec(): RolespecContext { + return this.getRuleContext(0, RolespecContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_operator_def_arg; + return PostgreSqlParser.RULE_reassignownedstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOperator_def_arg) { - listener.enterOperator_def_arg(this); + if(listener.enterReassignownedstmt) { + listener.enterReassignownedstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOperator_def_arg) { - listener.exitOperator_def_arg(this); + if(listener.exitReassignownedstmt) { + listener.exitReassignownedstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOperator_def_arg) { - return visitor.visitOperator_def_arg(this); + if (visitor.visitReassignownedstmt) { + return visitor.visitReassignownedstmt(this); } else { return visitor.visitChildren(this); } @@ -92871,153 +67777,198 @@ export class Operator_def_argContext extends antlr.ParserRuleContext { } -export class AltertypestmtContext extends antlr.ParserRuleContext { +export class DropstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + public KW_DROP(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DROP, 0)!; } - public KW_TYPE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TYPE, 0)!; + public name_list(): Name_listContext | null { + return this.getRuleContext(0, Name_listContext); + } + public KW_SEQUENCE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); + } + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INDEX, 0); + } + public KW_COLLATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLLATION, 0); + } + public KW_CONVERSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONVERSION, 0); + } + public KW_STATISTICS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); + } + public KW_PUBLICATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); + } + public KW_SERVER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SERVER, 0); + } + public KW_ACCESS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ACCESS, 0); + } + public KW_METHOD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_METHOD, 0); + } + public KW_EVENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EVENT, 0); + } + public KW_TRIGGER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); + } + public KW_EXTENSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXTENSION, 0); + } + public KW_LANGUAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); + } + public KW_FOREIGN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); + } + public KW_DATA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATA, 0); + } + public KW_WRAPPER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); + } + public KW_TEXT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEXT, 0); + } + public KW_SEARCH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEARCH, 0); } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; + public KW_PARSER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARSER, 0); } - public KW_SET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SET, 0)!; + public KW_DICTIONARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_TEMPLATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); } - public operator_def_list(): Operator_def_listContext { - return this.getRuleContext(0, Operator_def_listContext)!; + public KW_CONFIGURATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_altertypestmt; + public opt_drop_behavior(): Opt_drop_behaviorContext | null { + return this.getRuleContext(0, Opt_drop_behaviorContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAltertypestmt) { - listener.enterAltertypestmt(this); - } + public KW_PROCEDURAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURAL, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAltertypestmt) { - listener.exitAltertypestmt(this); - } + public KW_VIEW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VIEW, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAltertypestmt) { - return visitor.visitAltertypestmt(this); - } else { - return visitor.visitChildren(this); + public view_name(): View_nameContext[]; + public view_name(i: number): View_nameContext | null; + public view_name(i?: number): View_nameContext[] | View_nameContext | null { + if (i === undefined) { + return this.getRuleContexts(View_nameContext); } - } -} - -export class AlterownerstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, View_nameContext); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + public KW_MATERIALIZED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); } - public KW_AGGREGATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } - public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { - return this.getRuleContext(0, Aggregate_with_argtypesContext); + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } - public KW_OWNER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OWNER, 0)!; + public table_name_list(): Table_name_listContext | null { + return this.getRuleContext(0, Table_name_listContext); } - public KW_TO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TO, 0)!; + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); } - public rolespec(): RolespecContext { - return this.getRuleContext(0, RolespecContext)!; + public schema_name_list(): Schema_name_listContext | null { + return this.getRuleContext(0, Schema_name_listContext); } - public KW_COLLATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLLATION, 0); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); + } + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ON, 0); } public any_name(): Any_nameContext | null { return this.getRuleContext(0, Any_nameContext); } - public KW_CONVERSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONVERSION, 0); + public KW_POLICY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_POLICY, 0); } - public KW_DATABASE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATABASE, 0); + public KW_RULE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RULE, 0); } - public database_name(): Database_nameContext | null { - return this.getRuleContext(0, Database_nameContext); + public typename(): TypenameContext[]; + public typename(i: number): TypenameContext | null; + public typename(i?: number): TypenameContext[] | TypenameContext | null { + if (i === undefined) { + return this.getRuleContexts(TypenameContext); + } + + return this.getRuleContext(i, TypenameContext); + } + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); } public KW_DOMAIN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); } - public KW_FUNCTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); - } - public function_with_argtypes(): Function_with_argtypesContext | null { - return this.getRuleContext(0, Function_with_argtypesContext); - } - public KW_LANGUAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); + public KW_CONCURRENTLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONCURRENTLY, 0); } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); + public any_name_list(): Any_name_listContext | null { + return this.getRuleContext(0, Any_name_listContext); } - public opt_procedural(): Opt_proceduralContext | null { - return this.getRuleContext(0, Opt_proceduralContext); + public KW_CAST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CAST, 0); } - public KW_LARGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LARGE, 0); + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public KW_OBJECT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OBJECT, 0); + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public KW_OPERATOR(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); } - public operator_with_argtypes(): Operator_with_argtypesContext | null { - return this.getRuleContext(0, Operator_with_argtypesContext); + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); } public KW_CLASS(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_CLASS, 0); } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); - } public KW_FAMILY(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_FAMILY, 0); } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); - } - public procedure_with_argtypes(): Procedure_with_argtypesContext | null { - return this.getRuleContext(0, Procedure_with_argtypesContext); - } - public KW_ROUTINE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); - } - public routine_with_argtypes(): Routine_with_argtypesContext | null { - return this.getRuleContext(0, Routine_with_argtypesContext); + public KW_OWNED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OWNED, 0); } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BY, 0); } - public schema_name(): Schema_nameContext | null { - return this.getRuleContext(0, Schema_nameContext); + public role_list(): Role_listContext | null { + return this.getRuleContext(0, Role_listContext); } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); + public KW_SUBSCRIPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0); } public KW_TABLESPACE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); @@ -93025,61 +67976,67 @@ export class AlterownerstmtContext extends antlr.ParserRuleContext { public tablespace_name(): Tablespace_nameContext | null { return this.getRuleContext(0, Tablespace_nameContext); } - public KW_STATISTICS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); - } - public KW_TEXT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEXT, 0); - } - public KW_SEARCH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEARCH, 0); + public KW_TRANSFORM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0); } - public KW_DICTIONARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } - public KW_CONFIGURATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLE, 0); } - public KW_FOREIGN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); + public KW_USER(): antlr.TerminalNode[]; + public KW_USER(i: number): antlr.TerminalNode | null; + public KW_USER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_USER); + } else { + return this.getToken(PostgreSqlParser.KW_USER, i); + } } - public KW_DATA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DATA, 0); + public KW_GROUP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GROUP, 0); } - public KW_WRAPPER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); + public KW_MAPPING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MAPPING, 0); } - public KW_SERVER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SERVER, 0); + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); } - public KW_EVENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EVENT, 0); + public KW_DATABASE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATABASE, 0); } - public KW_TRIGGER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); + public database_name(): Database_nameContext | null { + return this.getRuleContext(0, Database_nameContext); } - public KW_PUBLICATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); + public KW_FORCE(): antlr.TerminalNode[]; + public KW_FORCE(i: number): antlr.TerminalNode | null; + public KW_FORCE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_FORCE); + } else { + return this.getToken(PostgreSqlParser.KW_FORCE, i); + } } - public KW_SUBSCRIPTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0); + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterownerstmt; + return PostgreSqlParser.RULE_dropstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterownerstmt) { - listener.enterAlterownerstmt(this); + if(listener.enterDropstmt) { + listener.enterDropstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterownerstmt) { - listener.exitAlterownerstmt(this); + if(listener.exitDropstmt) { + listener.exitDropstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterownerstmt) { - return visitor.visitAlterownerstmt(this); + if (visitor.visitDropstmt) { + return visitor.visitDropstmt(this); } else { return visitor.visitChildren(this); } @@ -93087,41 +68044,80 @@ export class AlterownerstmtContext extends antlr.ParserRuleContext { } -export class CreatepublicationstmtContext extends antlr.ParserRuleContext { +export class Object_type_any_nameContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } - public KW_PUBLICATION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0)!; + public table_name(): Table_nameContext | null { + return this.getRuleContext(0, Table_nameContext); + } + public KW_FOREIGN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public KW_VIEW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VIEW, 0); } - public opt_publication_for_tables(): Opt_publication_for_tablesContext | null { - return this.getRuleContext(0, Opt_publication_for_tablesContext); + public view_name(): View_nameContext | null { + return this.getRuleContext(0, View_nameContext); } - public opt_definition(): Opt_definitionContext | null { - return this.getRuleContext(0, Opt_definitionContext); + public KW_MATERIALIZED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); + } + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); + } + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INDEX, 0); + } + public KW_COLLATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLLATION, 0); + } + public KW_CONVERSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONVERSION, 0); + } + public KW_STATISTICS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); + } + public KW_SEQUENCE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); + } + public KW_TEXT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEXT, 0); + } + public KW_SEARCH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEARCH, 0); + } + public KW_PARSER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARSER, 0); + } + public KW_DICTIONARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); + } + public KW_TEMPLATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); + } + public KW_CONFIGURATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createpublicationstmt; + return PostgreSqlParser.RULE_object_type_any_name; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatepublicationstmt) { - listener.enterCreatepublicationstmt(this); + if(listener.enterObject_type_any_name) { + listener.enterObject_type_any_name(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatepublicationstmt) { - listener.exitCreatepublicationstmt(this); + if(listener.exitObject_type_any_name) { + listener.exitObject_type_any_name(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatepublicationstmt) { - return visitor.visitCreatepublicationstmt(this); + if (visitor.visitObject_type_any_name) { + return visitor.visitObject_type_any_name(this); } else { return visitor.visitChildren(this); } @@ -93129,29 +68125,86 @@ export class CreatepublicationstmtContext extends antlr.ParserRuleContext { } -export class Opt_publication_for_tablesContext extends antlr.ParserRuleContext { +export class Object_type_nameContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public publication_for_tables(): Publication_for_tablesContext { - return this.getRuleContext(0, Publication_for_tablesContext)!; + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); + } + public KW_EVENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EVENT, 0); + } + public KW_TRIGGER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); + } + public KW_ACCESS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ACCESS, 0); + } + public KW_METHOD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_METHOD, 0); + } + public KW_EXTENSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXTENSION, 0); + } + public KW_PUBLICATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); + } + public KW_SERVER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SERVER, 0); + } + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLE, 0); + } + public KW_SUBSCRIPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0); + } + public KW_FOREIGN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); + } + public KW_DATA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATA, 0); + } + public KW_WRAPPER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); + } + public KW_LANGUAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); + } + public KW_PROCEDURAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURAL, 0); + } + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); + } + public schema_name(): Schema_nameContext | null { + return this.getRuleContext(0, Schema_nameContext); + } + public KW_DATABASE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATABASE, 0); + } + public database_name(): Database_nameContext | null { + return this.getRuleContext(0, Database_nameContext); + } + public opttablespace(): OpttablespaceContext | null { + return this.getRuleContext(0, OpttablespaceContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_publication_for_tables; + return PostgreSqlParser.RULE_object_type_name; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_publication_for_tables) { - listener.enterOpt_publication_for_tables(this); + if(listener.enterObject_type_name) { + listener.enterObject_type_name(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_publication_for_tables) { - listener.exitOpt_publication_for_tables(this); + if(listener.exitObject_type_name) { + listener.exitObject_type_name(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_publication_for_tables) { - return visitor.visitOpt_publication_for_tables(this); + if (visitor.visitObject_type_name) { + return visitor.visitObject_type_name(this); } else { return visitor.visitChildren(this); } @@ -93159,41 +68212,44 @@ export class Opt_publication_for_tablesContext extends antlr.ParserRuleContext { } -export class Publication_for_tablesContext extends antlr.ParserRuleContext { +export class Any_name_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; - } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); - } - public relation_expr_list(): Relation_expr_listContext | null { - return this.getRuleContext(0, Relation_expr_listContext); - } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); + public any_name(): Any_nameContext[]; + public any_name(i: number): Any_nameContext | null; + public any_name(i?: number): Any_nameContext[] | Any_nameContext | null { + if (i === undefined) { + return this.getRuleContexts(Any_nameContext); + } + + return this.getRuleContext(i, Any_nameContext); } - public KW_TABLES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLES, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_publication_for_tables; + return PostgreSqlParser.RULE_any_name_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPublication_for_tables) { - listener.enterPublication_for_tables(this); + if(listener.enterAny_name_list) { + listener.enterAny_name_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPublication_for_tables) { - listener.exitPublication_for_tables(this); + if(listener.exitAny_name_list) { + listener.exitAny_name_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPublication_for_tables) { - return visitor.visitPublication_for_tables(this); + if (visitor.visitAny_name_list) { + return visitor.visitAny_name_list(this); } else { return visitor.visitChildren(this); } @@ -93201,68 +68257,32 @@ export class Publication_for_tablesContext extends antlr.ParserRuleContext { } -export class AlterpublicationstmtContext extends antlr.ParserRuleContext { +export class Any_nameContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_PUBLICATION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0)!; - } - public name(): NameContext[]; - public name(i: number): NameContext | null; - public name(i?: number): NameContext[] | NameContext | null { - if (i === undefined) { - return this.getRuleContexts(NameContext); - } - - return this.getRuleContext(i, NameContext); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public definition(): DefinitionContext | null { - return this.getRuleContext(0, DefinitionContext); - } - public KW_ADD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADD, 0); - } - public publication_relation_expr_list(): Publication_relation_expr_listContext | null { - return this.getRuleContext(0, Publication_relation_expr_listContext); - } - public KW_DROP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DROP, 0); - } - public KW_OWNER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OWNER, 0); - } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); - } - public rolespec(): RolespecContext | null { - return this.getRuleContext(0, RolespecContext); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public KW_RENAME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RENAME, 0); + public attrs(): AttrsContext | null { + return this.getRuleContext(0, AttrsContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterpublicationstmt; + return PostgreSqlParser.RULE_any_name; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterpublicationstmt) { - listener.enterAlterpublicationstmt(this); + if(listener.enterAny_name) { + listener.enterAny_name(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterpublicationstmt) { - listener.exitAlterpublicationstmt(this); + if(listener.exitAny_name) { + listener.exitAny_name(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterpublicationstmt) { - return visitor.visitAlterpublicationstmt(this); + if (visitor.visitAny_name) { + return visitor.visitAny_name(this); } else { return visitor.visitChildren(this); } @@ -93270,50 +68290,44 @@ export class AlterpublicationstmtContext extends antlr.ParserRuleContext { } -export class CreatesubscriptionstmtContext extends antlr.ParserRuleContext { +export class AttrsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_SUBSCRIPTION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public KW_CONNECTION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CONNECTION, 0)!; - } - public sconst(): SconstContext { - return this.getRuleContext(0, SconstContext)!; - } - public KW_PUBLICATION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0)!; - } - public publication_name_list(): Publication_name_listContext { - return this.getRuleContext(0, Publication_name_listContext)!; + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.DOT); + } else { + return this.getToken(PostgreSqlParser.DOT, i); + } } - public opt_definition(): Opt_definitionContext | null { - return this.getRuleContext(0, Opt_definitionContext); + public collabel(): CollabelContext[]; + public collabel(i: number): CollabelContext | null; + public collabel(i?: number): CollabelContext[] | CollabelContext | null { + if (i === undefined) { + return this.getRuleContexts(CollabelContext); + } + + return this.getRuleContext(i, CollabelContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createsubscriptionstmt; + return PostgreSqlParser.RULE_attrs; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatesubscriptionstmt) { - listener.enterCreatesubscriptionstmt(this); + if(listener.enterAttrs) { + listener.enterAttrs(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatesubscriptionstmt) { - listener.exitCreatesubscriptionstmt(this); + if(listener.exitAttrs) { + listener.exitAttrs(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatesubscriptionstmt) { - return visitor.visitCreatesubscriptionstmt(this); + if (visitor.visitAttrs) { + return visitor.visitAttrs(this); } else { return visitor.visitChildren(this); } @@ -93321,18 +68335,24 @@ export class CreatesubscriptionstmtContext extends antlr.ParserRuleContext { } -export class Publication_name_listContext extends antlr.ParserRuleContext { +export class TruncatestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public publication_name_item(): Publication_name_itemContext[]; - public publication_name_item(i: number): Publication_name_itemContext | null; - public publication_name_item(i?: number): Publication_name_itemContext[] | Publication_name_itemContext | null { + public KW_TRUNCATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TRUNCATE, 0)!; + } + public truncate_table(): Truncate_tableContext[]; + public truncate_table(i: number): Truncate_tableContext | null; + public truncate_table(i?: number): Truncate_tableContext[] | Truncate_tableContext | null { if (i === undefined) { - return this.getRuleContexts(Publication_name_itemContext); + return this.getRuleContexts(Truncate_tableContext); } - return this.getRuleContext(i, Publication_name_itemContext); + return this.getRuleContext(i, Truncate_tableContext); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -93343,22 +68363,34 @@ export class Publication_name_listContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.COMMA, i); } } + public KW_IDENTITY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IDENTITY, 0); + } + public opt_drop_behavior(): Opt_drop_behaviorContext | null { + return this.getRuleContext(0, Opt_drop_behaviorContext); + } + public KW_CONTINUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONTINUE, 0); + } + public KW_RESTART(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESTART, 0); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_publication_name_list; + return PostgreSqlParser.RULE_truncatestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPublication_name_list) { - listener.enterPublication_name_list(this); + if(listener.enterTruncatestmt) { + listener.enterTruncatestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPublication_name_list) { - listener.exitPublication_name_list(this); + if(listener.exitTruncatestmt) { + listener.exitTruncatestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPublication_name_list) { - return visitor.visitPublication_name_list(this); + if (visitor.visitTruncatestmt) { + return visitor.visitTruncatestmt(this); } else { return visitor.visitChildren(this); } @@ -93366,29 +68398,35 @@ export class Publication_name_listContext extends antlr.ParserRuleContext { } -export class Publication_name_itemContext extends antlr.ParserRuleContext { +export class Truncate_tableContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public collabel(): CollabelContext { - return this.getRuleContext(0, CollabelContext)!; + public table_name(): Table_nameContext { + return this.getRuleContext(0, Table_nameContext)!; + } + public KW_ONLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ONLY, 0); + } + public STAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.STAR, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_publication_name_item; + return PostgreSqlParser.RULE_truncate_table; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPublication_name_item) { - listener.enterPublication_name_item(this); + if(listener.enterTruncate_table) { + listener.enterTruncate_table(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPublication_name_item) { - listener.exitPublication_name_item(this); + if(listener.exitTruncate_table) { + listener.exitTruncate_table(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPublication_name_item) { - return visitor.visitPublication_name_item(this); + if (visitor.visitTruncate_table) { + return visitor.visitTruncate_table(this); } else { return visitor.visitChildren(this); } @@ -93396,92 +68434,170 @@ export class Publication_name_itemContext extends antlr.ParserRuleContext { } -export class AltersubscriptionstmtContext extends antlr.ParserRuleContext { +export class CommentstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + public KW_COMMENT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_COMMENT, 0)!; } - public KW_SUBSCRIPTION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0)!; + public KW_ON(): antlr.TerminalNode[]; + public KW_ON(i: number): antlr.TerminalNode | null; + public KW_ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_ON); + } else { + return this.getToken(PostgreSqlParser.KW_ON, i); + } } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public KW_IS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_IS, 0)!; } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); + public object_type_any_name(): Object_type_any_nameContext | null { + return this.getRuleContext(0, Object_type_any_nameContext); } - public definition(): DefinitionContext | null { - return this.getRuleContext(0, DefinitionContext); + public object_type_name(): Object_type_nameContext | null { + return this.getRuleContext(0, Object_type_nameContext); } - public KW_CONNECTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONNECTION, 0); + public KW_COLUMN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLUMN, 0); } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); + public DOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.DOT, 0); } - public KW_REFRESH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REFRESH, 0); + public column_name(): Column_nameContext | null { + return this.getRuleContext(0, Column_nameContext); } - public KW_PUBLICATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); + public typename(): TypenameContext[]; + public typename(i: number): TypenameContext | null; + public typename(i?: number): TypenameContext[] | TypenameContext | null { + if (i === undefined) { + return this.getRuleContexts(TypenameContext); + } + + return this.getRuleContext(i, TypenameContext); } - public opt_definition(): Opt_definitionContext | null { - return this.getRuleContext(0, Opt_definitionContext); + public KW_AGGREGATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); } - public publication_name_list(): Publication_name_listContext | null { - return this.getRuleContext(0, Publication_name_listContext); + public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { + return this.getRuleContext(0, Aggregate_with_argtypesContext); } - public KW_ADD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADD, 0); + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); } - public KW_DROP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DROP, 0); + public function_with_argtypes(): Function_with_argtypesContext | null { + return this.getRuleContext(0, Function_with_argtypesContext); } - public KW_ENABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ENABLE, 0); + public KW_OPERATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); } - public KW_DISABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DISABLE, 0); + public operator_with_argtypes(): Operator_with_argtypesContext | null { + return this.getRuleContext(0, Operator_with_argtypesContext); } - public KW_SKIP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SKIP, 0); + public KW_CONSTRAINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); + } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); + } + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); + } + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + } + public procedure_with_argtypes(): Procedure_with_argtypesContext | null { + return this.getRuleContext(0, Procedure_with_argtypesContext); + } + public KW_ROUTINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); + } + public routine_with_argtypes(): Routine_with_argtypesContext | null { + return this.getRuleContext(0, Routine_with_argtypesContext); + } + public KW_TRANSFORM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0); + } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); + } + public KW_LANGUAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); + } + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); + } + public KW_LARGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LARGE, 0); + } + public KW_OBJECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OBJECT, 0); + } + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); + } + public KW_CAST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CAST, 0); } public OPEN_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public old_aggr_elem(): Old_aggr_elemContext | null { - return this.getRuleContext(0, Old_aggr_elemContext); + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } public CLOSE_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public KW_OWNER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OWNER, 0); + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULL, 0); } - public rolespec(): RolespecContext | null { - return this.getRuleContext(0, RolespecContext); + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); + } + public KW_DOMAIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); + } + public KW_POLICY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_POLICY, 0); + } + public KW_RULE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RULE, 0); + } + public KW_TRIGGER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); + } + public KW_CLASS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CLASS, 0); + } + public KW_FAMILY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FAMILY, 0); + } + public table_name(): Table_nameContext | null { + return this.getRuleContext(0, Table_nameContext); + } + public attrs(): AttrsContext | null { + return this.getRuleContext(0, AttrsContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_altersubscriptionstmt; + return PostgreSqlParser.RULE_commentstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAltersubscriptionstmt) { - listener.enterAltersubscriptionstmt(this); + if(listener.enterCommentstmt) { + listener.enterCommentstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAltersubscriptionstmt) { - listener.exitAltersubscriptionstmt(this); + if(listener.exitCommentstmt) { + listener.exitCommentstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAltersubscriptionstmt) { - return visitor.visitAltersubscriptionstmt(this); + if (visitor.visitCommentstmt) { + return visitor.visitCommentstmt(this); } else { return visitor.visitChildren(this); } @@ -93489,65 +68605,140 @@ export class AltersubscriptionstmtContext extends antlr.ParserRuleContext { } -export class RulestmtContext extends antlr.ParserRuleContext { +export class SeclabelstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_RULE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_RULE, 0)!; - } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public KW_SECURITY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SECURITY, 0)!; } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; + public KW_LABEL(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_LABEL, 0)!; } public KW_ON(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_ON, 0)!; } - public event(): EventContext { - return this.getRuleContext(0, EventContext)!; + public KW_IS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_IS, 0)!; } - public KW_TO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TO, 0)!; + public typename(): TypenameContext | null { + return this.getRuleContext(0, TypenameContext); } - public qualified_name(): Qualified_nameContext { - return this.getRuleContext(0, Qualified_nameContext)!; + public KW_AGGREGATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); } - public KW_DO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DO, 0)!; + public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { + return this.getRuleContext(0, Aggregate_with_argtypesContext); } - public ruleactionlist(): RuleactionlistContext { - return this.getRuleContext(0, RuleactionlistContext)!; + public KW_COLUMN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLUMN, 0); } - public opt_or_replace(): Opt_or_replaceContext | null { - return this.getRuleContext(0, Opt_or_replaceContext); + public column_name(): Column_nameContext | null { + return this.getRuleContext(0, Column_nameContext); } - public where_clause(): Where_clauseContext | null { - return this.getRuleContext(0, Where_clauseContext); + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + } + public function_with_argtypes(): Function_with_argtypesContext | null { + return this.getRuleContext(0, Function_with_argtypesContext); + } + public KW_LARGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LARGE, 0); + } + public KW_OBJECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OBJECT, 0); + } + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); + } + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + } + public procedure_with_argtypes(): Procedure_with_argtypesContext | null { + return this.getRuleContext(0, Procedure_with_argtypesContext); + } + public KW_ROUTINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); + } + public routine_with_argtypes(): Routine_with_argtypesContext | null { + return this.getRuleContext(0, Routine_with_argtypesContext); + } + public object_type_any_name(): Object_type_any_nameContext | null { + return this.getRuleContext(0, Object_type_any_nameContext); + } + public object_type_name(): Object_type_nameContext | null { + return this.getRuleContext(0, Object_type_nameContext); } - public opt_instead(): Opt_insteadContext | null { - return this.getRuleContext(0, Opt_insteadContext); + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULL, 0); + } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); + } + public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | null { + return this.getRuleContext(0, Nonreservedword_or_sconstContext); + } + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); + } + public KW_DOMAIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_rulestmt; + return PostgreSqlParser.RULE_seclabelstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRulestmt) { - listener.enterRulestmt(this); + if(listener.enterSeclabelstmt) { + listener.enterSeclabelstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRulestmt) { - listener.exitRulestmt(this); + if(listener.exitSeclabelstmt) { + listener.exitSeclabelstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRulestmt) { - return visitor.visitRulestmt(this); + if (visitor.visitSeclabelstmt) { + return visitor.visitSeclabelstmt(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class FetchstmtContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public fetch_args(): Fetch_argsContext { + return this.getRuleContext(0, Fetch_argsContext)!; + } + public KW_FETCH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FETCH, 0); + } + public KW_MOVE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MOVE, 0); + } + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_fetchstmt; + } + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterFetchstmt) { + listener.enterFetchstmt(this); + } + } + public override exitRule(listener: PostgreSqlParserListener): void { + if(listener.exitFetchstmt) { + listener.exitFetchstmt(this); + } + } + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitFetchstmt) { + return visitor.visitFetchstmt(this); } else { return visitor.visitChildren(this); } @@ -93555,41 +68746,62 @@ export class RulestmtContext extends antlr.ParserRuleContext { } -export class RuleactionlistContext extends antlr.ParserRuleContext { +export class Fetch_argsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_NOTHING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOTHING, 0); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public ruleactionstmt(): RuleactionstmtContext | null { - return this.getRuleContext(0, RuleactionstmtContext); + public from_in(): From_inContext | null { + return this.getRuleContext(0, From_inContext); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_NEXT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NEXT, 0); + } + public KW_PRIOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRIOR, 0); } - public ruleactionmulti(): RuleactionmultiContext | null { - return this.getRuleContext(0, RuleactionmultiContext); + public KW_FIRST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FIRST, 0); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_LAST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LAST, 0); + } + public signediconst(): SignediconstContext | null { + return this.getRuleContext(0, SignediconstContext); + } + public KW_ABSOLUTE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ABSOLUTE, 0); + } + public KW_RELATIVE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RELATIVE, 0); + } + public KW_FORWARD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FORWARD, 0); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); + } + public KW_BACKWARD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BACKWARD, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_ruleactionlist; + return PostgreSqlParser.RULE_fetch_args; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRuleactionlist) { - listener.enterRuleactionlist(this); + if(listener.enterFetch_args) { + listener.enterFetch_args(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRuleactionlist) { - listener.exitRuleactionlist(this); + if(listener.exitFetch_args) { + listener.exitFetch_args(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRuleactionlist) { - return visitor.visitRuleactionlist(this); + if (visitor.visitFetch_args) { + return visitor.visitFetch_args(this); } else { return visitor.visitChildren(this); } @@ -93597,44 +68809,89 @@ export class RuleactionlistContext extends antlr.ParserRuleContext { } -export class RuleactionmultiContext extends antlr.ParserRuleContext { +export class From_inContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public ruleactionstmtOrEmpty(): RuleactionstmtOrEmptyContext[]; - public ruleactionstmtOrEmpty(i: number): RuleactionstmtOrEmptyContext | null; - public ruleactionstmtOrEmpty(i?: number): RuleactionstmtOrEmptyContext[] | RuleactionstmtOrEmptyContext | null { - if (i === undefined) { - return this.getRuleContexts(RuleactionstmtOrEmptyContext); + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); + } + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_from_in; + } + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterFrom_in) { + listener.enterFrom_in(this); + } + } + public override exitRule(listener: PostgreSqlParserListener): void { + if(listener.exitFrom_in) { + listener.exitFrom_in(this); + } + } + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitFrom_in) { + return visitor.visitFrom_in(this); + } else { + return visitor.visitChildren(this); } + } +} - return this.getRuleContext(i, RuleactionstmtOrEmptyContext); + +export class GrantstmtContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); } - public SEMI(): antlr.TerminalNode[]; - public SEMI(i: number): antlr.TerminalNode | null; - public SEMI(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public KW_GRANT(): antlr.TerminalNode[]; + public KW_GRANT(i: number): antlr.TerminalNode | null; + public KW_GRANT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.SEMI); + return this.getTokens(PostgreSqlParser.KW_GRANT); } else { - return this.getToken(PostgreSqlParser.SEMI, i); + return this.getToken(PostgreSqlParser.KW_GRANT, i); } } + public privileges(): PrivilegesContext { + return this.getRuleContext(0, PrivilegesContext)!; + } + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; + } + public privilege_target(): Privilege_targetContext { + return this.getRuleContext(0, Privilege_targetContext)!; + } + public KW_TO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TO, 0)!; + } + public grantee_list(): Grantee_listContext { + return this.getRuleContext(0, Grantee_listContext)!; + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); + } + public KW_OPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPTION, 0); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_ruleactionmulti; + return PostgreSqlParser.RULE_grantstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRuleactionmulti) { - listener.enterRuleactionmulti(this); + if(listener.enterGrantstmt) { + listener.enterGrantstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRuleactionmulti) { - listener.exitRuleactionmulti(this); + if(listener.exitGrantstmt) { + listener.exitGrantstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRuleactionmulti) { - return visitor.visitRuleactionmulti(this); + if (visitor.visitGrantstmt) { + return visitor.visitGrantstmt(this); } else { return visitor.visitChildren(this); } @@ -93642,41 +68899,56 @@ export class RuleactionmultiContext extends antlr.ParserRuleContext { } -export class RuleactionstmtContext extends antlr.ParserRuleContext { +export class RevokestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public selectstmt(): SelectstmtContext | null { - return this.getRuleContext(0, SelectstmtContext); + public KW_REVOKE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_REVOKE, 0)!; } - public insertstmt(): InsertstmtContext | null { - return this.getRuleContext(0, InsertstmtContext); + public privileges(): PrivilegesContext { + return this.getRuleContext(0, PrivilegesContext)!; } - public updatestmt(): UpdatestmtContext | null { - return this.getRuleContext(0, UpdatestmtContext); + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; } - public deletestmt(): DeletestmtContext | null { - return this.getRuleContext(0, DeletestmtContext); + public privilege_target(): Privilege_targetContext { + return this.getRuleContext(0, Privilege_targetContext)!; } - public notifystmt(): NotifystmtContext | null { - return this.getRuleContext(0, NotifystmtContext); + public KW_FROM(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FROM, 0)!; + } + public grantee_list(): Grantee_listContext { + return this.getRuleContext(0, Grantee_listContext)!; + } + public KW_GRANT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GRANT, 0); + } + public KW_OPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPTION, 0); + } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); + } + public opt_drop_behavior(): Opt_drop_behaviorContext | null { + return this.getRuleContext(0, Opt_drop_behaviorContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_ruleactionstmt; + return PostgreSqlParser.RULE_revokestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRuleactionstmt) { - listener.enterRuleactionstmt(this); + if(listener.enterRevokestmt) { + listener.enterRevokestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRuleactionstmt) { - listener.exitRuleactionstmt(this); + if(listener.exitRevokestmt) { + listener.exitRevokestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRuleactionstmt) { - return visitor.visitRuleactionstmt(this); + if (visitor.visitRevokestmt) { + return visitor.visitRevokestmt(this); } else { return visitor.visitChildren(this); } @@ -93684,29 +68956,62 @@ export class RuleactionstmtContext extends antlr.ParserRuleContext { } -export class RuleactionstmtOrEmptyContext extends antlr.ParserRuleContext { +export class PrivilegesContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public ruleactionstmt(): RuleactionstmtContext { - return this.getRuleContext(0, RuleactionstmtContext)!; + public privilege(): PrivilegeContext[]; + public privilege(i: number): PrivilegeContext | null; + public privilege(i?: number): PrivilegeContext[] | PrivilegeContext | null { + if (i === undefined) { + return this.getRuleContexts(PrivilegeContext); + } + + return this.getRuleContext(i, PrivilegeContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); + } + public KW_PRIVILEGES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRIVILEGES, 0); + } + public opt_column_list(): Opt_column_listContext | null { + return this.getRuleContext(0, Opt_column_listContext); + } + public beforeprivilegeselect(): BeforeprivilegeselectContext[]; + public beforeprivilegeselect(i: number): BeforeprivilegeselectContext | null; + public beforeprivilegeselect(i?: number): BeforeprivilegeselectContext[] | BeforeprivilegeselectContext | null { + if (i === undefined) { + return this.getRuleContexts(BeforeprivilegeselectContext); + } + + return this.getRuleContext(i, BeforeprivilegeselectContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_ruleactionstmtOrEmpty; + return PostgreSqlParser.RULE_privileges; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRuleactionstmtOrEmpty) { - listener.enterRuleactionstmtOrEmpty(this); + if(listener.enterPrivileges) { + listener.enterPrivileges(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRuleactionstmtOrEmpty) { - listener.exitRuleactionstmtOrEmpty(this); + if(listener.exitPrivileges) { + listener.exitPrivileges(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRuleactionstmtOrEmpty) { - return visitor.visitRuleactionstmtOrEmpty(this); + if (visitor.visitPrivileges) { + return visitor.visitPrivileges(this); } else { return visitor.visitChildren(this); } @@ -93714,71 +69019,65 @@ export class RuleactionstmtOrEmptyContext extends antlr.ParserRuleContext { } -export class EventContext extends antlr.ParserRuleContext { +export class BeforeprivilegeselectContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } public KW_SELECT(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_SELECT, 0); } + public KW_INSERT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INSERT, 0); + } public KW_UPDATE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_UPDATE, 0); } public KW_DELETE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_DELETE, 0); } - public KW_INSERT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INSERT, 0); + public KW_TRUNCATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRUNCATE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_event; + public KW_PEFERENCES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PEFERENCES, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterEvent) { - listener.enterEvent(this); - } + public KW_TRIGGER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitEvent) { - listener.exitEvent(this); - } + public KW_USAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USAGE, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitEvent) { - return visitor.visitEvent(this); - } else { - return visitor.visitChildren(this); - } + public KW_CREATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CREATE, 0); } -} - - -export class Opt_insteadContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_CONNECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONNECT, 0); } - public KW_INSTEAD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INSTEAD, 0); + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPORARY, 0); } - public KW_ALSO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALSO, 0); + public KW_TEMP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMP, 0); + } + public KW_EXECUTE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXECUTE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_instead; + return PostgreSqlParser.RULE_beforeprivilegeselect; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_instead) { - listener.enterOpt_instead(this); + if(listener.enterBeforeprivilegeselect) { + listener.enterBeforeprivilegeselect(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_instead) { - listener.exitOpt_instead(this); + if(listener.exitBeforeprivilegeselect) { + listener.exitBeforeprivilegeselect(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_instead) { - return visitor.visitOpt_instead(this); + if (visitor.visitBeforeprivilegeselect) { + return visitor.visitBeforeprivilegeselect(this); } else { return visitor.visitChildren(this); } @@ -93786,35 +69085,41 @@ export class Opt_insteadContext extends antlr.ParserRuleContext { } -export class NotifystmtContext extends antlr.ParserRuleContext { +export class PrivilegeContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_NOTIFY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_NOTIFY, 0)!; + public KW_SELECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SELECT, 0); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; + public KW_REFERENCES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REFERENCES, 0); } - public notify_payload(): Notify_payloadContext | null { - return this.getRuleContext(0, Notify_payloadContext); + public KW_CREATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CREATE, 0); + } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); + } + public opt_column_list(): Opt_column_listContext | null { + return this.getRuleContext(0, Opt_column_listContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_notifystmt; + return PostgreSqlParser.RULE_privilege; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterNotifystmt) { - listener.enterNotifystmt(this); + if(listener.enterPrivilege) { + listener.enterPrivilege(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitNotifystmt) { - listener.exitNotifystmt(this); + if(listener.exitPrivilege) { + listener.exitPrivilege(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitNotifystmt) { - return visitor.visitNotifystmt(this); + if (visitor.visitPrivilege) { + return visitor.visitPrivilege(this); } else { return visitor.visitChildren(this); } @@ -93822,179 +69127,146 @@ export class NotifystmtContext extends antlr.ParserRuleContext { } -export class Notify_payloadContext extends antlr.ParserRuleContext { +export class Privilege_targetContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public COMMA(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.COMMA, 0)!; - } - public sconst(): SconstContext { - return this.getRuleContext(0, SconstContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_notify_payload; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterNotify_payload) { - listener.enterNotify_payload(this); - } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitNotify_payload) { - listener.exitNotify_payload(this); - } + public table_name_list(): Table_name_listContext | null { + return this.getRuleContext(0, Table_name_listContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitNotify_payload) { - return visitor.visitNotify_payload(this); - } else { - return visitor.visitChildren(this); - } + public qualified_name_list(): Qualified_name_listContext | null { + return this.getRuleContext(0, Qualified_name_listContext); } -} - - -export class ListenstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_SEQUENCE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); } - public KW_LISTEN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_LISTEN, 0)!; + public name_list(): Name_listContext | null { + return this.getRuleContext(0, Name_listContext); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; + public KW_FOREIGN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_listenstmt; + public KW_LANGUAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterListenstmt) { - listener.enterListenstmt(this); - } + public KW_DATA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATA, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitListenstmt) { - listener.exitListenstmt(this); - } + public KW_WRAPPER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitListenstmt) { - return visitor.visitListenstmt(this); - } else { - return visitor.visitChildren(this); - } + public KW_SERVER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SERVER, 0); } -} - - -export class UnlistenstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); } - public KW_UNLISTEN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_UNLISTEN, 0)!; + public function_with_argtypes_list(): Function_with_argtypes_listContext | null { + return this.getRuleContext(0, Function_with_argtypes_listContext); } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); } - public STAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.STAR, 0); + public procedure_with_argtypes_list(): Procedure_with_argtypes_listContext | null { + return this.getRuleContext(0, Procedure_with_argtypes_listContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_unlistenstmt; + public KW_ROUTINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterUnlistenstmt) { - listener.enterUnlistenstmt(this); - } + public routine_with_argtypes_list(): Routine_with_argtypes_listContext | null { + return this.getRuleContext(0, Routine_with_argtypes_listContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitUnlistenstmt) { - listener.exitUnlistenstmt(this); - } + public KW_DATABASE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATABASE, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitUnlistenstmt) { - return visitor.visitUnlistenstmt(this); - } else { - return visitor.visitChildren(this); - } + public database_nameList(): Database_nameListContext | null { + return this.getRuleContext(0, Database_nameListContext); } -} - - -export class TransactionstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public any_name_list(): Any_name_listContext | null { + return this.getRuleContext(0, Any_name_listContext); } - public KW_ABORT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ABORT, 0); + public KW_DOMAIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); } - public opt_transaction(): Opt_transactionContext | null { - return this.getRuleContext(0, Opt_transactionContext); + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); } - public opt_transaction_chain(): Opt_transaction_chainContext | null { - return this.getRuleContext(0, Opt_transaction_chainContext); + public KW_LARGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LARGE, 0); } - public KW_BEGIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BEGIN, 0); + public KW_OBJECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OBJECT, 0); } - public transaction_mode_list_or_empty(): Transaction_mode_list_or_emptyContext | null { - return this.getRuleContext(0, Transaction_mode_list_or_emptyContext); + public numericonly(): NumericonlyContext[]; + public numericonly(i: number): NumericonlyContext | null; + public numericonly(i?: number): NumericonlyContext[] | NumericonlyContext | null { + if (i === undefined) { + return this.getRuleContexts(NumericonlyContext); + } + + return this.getRuleContext(i, NumericonlyContext); } - public KW_START(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_START, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } - public KW_TRANSACTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); } - public KW_END(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_END, 0); + public schema_name_list(): Schema_name_listContext | null { + return this.getRuleContext(0, Schema_name_listContext); } - public KW_SAVEPOINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SAVEPOINT, 0); + public KW_TABLESPACE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); + public tablespace_name_list(): Tablespace_name_listContext | null { + return this.getRuleContext(0, Tablespace_name_listContext); } - public KW_RELEASE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RELEASE, 0); + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public KW_PREPARE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PREPARE, 0); + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); + public KW_TABLES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLES, 0); } - public KW_COMMIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COMMIT, 0); + public KW_SEQUENCES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCES, 0); } - public KW_PREPARED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PREPARED, 0); + public KW_FUNCTIONS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTIONS, 0); } - public KW_ROLLBACK(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLLBACK, 0); + public KW_PROCEDURES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURES, 0); } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); + public KW_ROUTINES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINES, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_transactionstmt; + return PostgreSqlParser.RULE_privilege_target; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTransactionstmt) { - listener.enterTransactionstmt(this); + if(listener.enterPrivilege_target) { + listener.enterPrivilege_target(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTransactionstmt) { - listener.exitTransactionstmt(this); + if(listener.exitPrivilege_target) { + listener.exitPrivilege_target(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTransactionstmt) { - return visitor.visitTransactionstmt(this); + if (visitor.visitPrivilege_target) { + return visitor.visitPrivilege_target(this); } else { return visitor.visitChildren(this); } @@ -94002,32 +69274,53 @@ export class TransactionstmtContext extends antlr.ParserRuleContext { } -export class Opt_transactionContext extends antlr.ParserRuleContext { +export class Grantee_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WORK(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WORK, 0); + public rolespec(): RolespecContext[]; + public rolespec(i: number): RolespecContext | null; + public rolespec(i?: number): RolespecContext[] | RolespecContext | null { + if (i === undefined) { + return this.getRuleContexts(RolespecContext); + } + + return this.getRuleContext(i, RolespecContext); } - public KW_TRANSACTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } + } + public KW_GROUP(): antlr.TerminalNode[]; + public KW_GROUP(i: number): antlr.TerminalNode | null; + public KW_GROUP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_GROUP); + } else { + return this.getToken(PostgreSqlParser.KW_GROUP, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_transaction; + return PostgreSqlParser.RULE_grantee_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_transaction) { - listener.enterOpt_transaction(this); + if(listener.enterGrantee_list) { + listener.enterGrantee_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_transaction) { - listener.exitOpt_transaction(this); + if(listener.exitGrantee_list) { + listener.exitGrantee_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_transaction) { - return visitor.visitOpt_transaction(this); + if (visitor.visitGrantee_list) { + return visitor.visitGrantee_list(this); } else { return visitor.visitChildren(this); } @@ -94035,50 +69328,71 @@ export class Opt_transactionContext extends antlr.ParserRuleContext { } -export class Transaction_mode_itemContext extends antlr.ParserRuleContext { +export class GrantrolestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ISOLATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ISOLATION, 0); + public KW_GRANT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_GRANT, 0)!; } - public KW_LEVEL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LEVEL, 0); + public privilege(): PrivilegeContext[]; + public privilege(i: number): PrivilegeContext | null; + public privilege(i?: number): PrivilegeContext[] | PrivilegeContext | null { + if (i === undefined) { + return this.getRuleContexts(PrivilegeContext); + } + + return this.getRuleContext(i, PrivilegeContext); } - public iso_level(): Iso_levelContext | null { - return this.getRuleContext(0, Iso_levelContext); + public KW_TO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TO, 0)!; } - public KW_READ(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_READ, 0); + public role_list(): Role_listContext { + return this.getRuleContext(0, Role_listContext)!; } - public KW_ONLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ONLY, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } - public KW_WRITE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WRITE, 0); + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public KW_DEFERRABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFERRABLE, 0); + public KW_ADMIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADMIN, 0); } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); + public KW_OPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPTION, 0); + } + public KW_GRANTED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GRANTED, 0); + } + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BY, 0); + } + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_transaction_mode_item; + return PostgreSqlParser.RULE_grantrolestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTransaction_mode_item) { - listener.enterTransaction_mode_item(this); + if(listener.enterGrantrolestmt) { + listener.enterGrantrolestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTransaction_mode_item) { - listener.exitTransaction_mode_item(this); + if(listener.exitGrantrolestmt) { + listener.exitGrantrolestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTransaction_mode_item) { - return visitor.visitTransaction_mode_item(this); + if (visitor.visitGrantrolestmt) { + return visitor.visitGrantrolestmt(this); } else { return visitor.visitChildren(this); } @@ -94086,18 +69400,36 @@ export class Transaction_mode_itemContext extends antlr.ParserRuleContext { } -export class Transaction_mode_listContext extends antlr.ParserRuleContext { +export class RevokerolestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public transaction_mode_item(): Transaction_mode_itemContext[]; - public transaction_mode_item(i: number): Transaction_mode_itemContext | null; - public transaction_mode_item(i?: number): Transaction_mode_itemContext[] | Transaction_mode_itemContext | null { + public KW_REVOKE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_REVOKE, 0)!; + } + public privilege(): PrivilegeContext[]; + public privilege(i: number): PrivilegeContext | null; + public privilege(i?: number): PrivilegeContext[] | PrivilegeContext | null { if (i === undefined) { - return this.getRuleContexts(Transaction_mode_itemContext); + return this.getRuleContexts(PrivilegeContext); } - return this.getRuleContext(i, Transaction_mode_itemContext); + return this.getRuleContext(i, PrivilegeContext); + } + public KW_FROM(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FROM, 0)!; + } + public role_list(): Role_listContext { + return this.getRuleContext(0, Role_listContext)!; + } + public KW_ADMIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADMIN, 0); + } + public KW_OPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPTION, 0); + } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -94108,52 +69440,34 @@ export class Transaction_mode_listContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.COMMA, i); } } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_transaction_mode_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTransaction_mode_list) { - listener.enterTransaction_mode_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTransaction_mode_list) { - listener.exitTransaction_mode_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTransaction_mode_list) { - return visitor.visitTransaction_mode_list(this); - } else { - return visitor.visitChildren(this); - } + public KW_GRANTED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GRANTED, 0); } -} - - -export class Transaction_mode_list_or_emptyContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BY, 0); } - public transaction_mode_list(): Transaction_mode_listContext { - return this.getRuleContext(0, Transaction_mode_listContext)!; + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); + } + public opt_drop_behavior(): Opt_drop_behaviorContext | null { + return this.getRuleContext(0, Opt_drop_behaviorContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_transaction_mode_list_or_empty; + return PostgreSqlParser.RULE_revokerolestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTransaction_mode_list_or_empty) { - listener.enterTransaction_mode_list_or_empty(this); + if(listener.enterRevokerolestmt) { + listener.enterRevokerolestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTransaction_mode_list_or_empty) { - listener.exitTransaction_mode_list_or_empty(this); + if(listener.exitRevokerolestmt) { + listener.exitRevokerolestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTransaction_mode_list_or_empty) { - return visitor.visitTransaction_mode_list_or_empty(this); + if (visitor.visitRevokerolestmt) { + return visitor.visitRevokerolestmt(this); } else { return visitor.visitChildren(this); } @@ -94161,35 +69475,101 @@ export class Transaction_mode_list_or_emptyContext extends antlr.ParserRuleConte } -export class Opt_transaction_chainContext extends antlr.ParserRuleContext { +export class AlterdefaultprivilegesstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_AND(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AND, 0)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public KW_CHAIN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CHAIN, 0)!; + public KW_DEFAULT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0)!; } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); + public KW_PRIVILEGES(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_PRIVILEGES, 0)!; + } + public defaclaction(): DefaclactionContext { + return this.getRuleContext(0, DefaclactionContext)!; + } + public KW_IN(): antlr.TerminalNode[]; + public KW_IN(i: number): antlr.TerminalNode | null; + public KW_IN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_IN); + } else { + return this.getToken(PostgreSqlParser.KW_IN, i); + } + } + public KW_SCHEMA(): antlr.TerminalNode[]; + public KW_SCHEMA(i: number): antlr.TerminalNode | null; + public KW_SCHEMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_SCHEMA); + } else { + return this.getToken(PostgreSqlParser.KW_SCHEMA, i); + } + } + public schema_name_list(): Schema_name_listContext[]; + public schema_name_list(i: number): Schema_name_listContext | null; + public schema_name_list(i?: number): Schema_name_listContext[] | Schema_name_listContext | null { + if (i === undefined) { + return this.getRuleContexts(Schema_name_listContext); + } + + return this.getRuleContext(i, Schema_name_listContext); + } + public KW_FOR(): antlr.TerminalNode[]; + public KW_FOR(i: number): antlr.TerminalNode | null; + public KW_FOR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_FOR); + } else { + return this.getToken(PostgreSqlParser.KW_FOR, i); + } + } + public role_list(): Role_listContext[]; + public role_list(i: number): Role_listContext | null; + public role_list(i?: number): Role_listContext[] | Role_listContext | null { + if (i === undefined) { + return this.getRuleContexts(Role_listContext); + } + + return this.getRuleContext(i, Role_listContext); + } + public KW_ROLE(): antlr.TerminalNode[]; + public KW_ROLE(i: number): antlr.TerminalNode | null; + public KW_ROLE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_ROLE); + } else { + return this.getToken(PostgreSqlParser.KW_ROLE, i); + } + } + public KW_USER(): antlr.TerminalNode[]; + public KW_USER(i: number): antlr.TerminalNode | null; + public KW_USER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_USER); + } else { + return this.getToken(PostgreSqlParser.KW_USER, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_transaction_chain; + return PostgreSqlParser.RULE_alterdefaultprivilegesstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_transaction_chain) { - listener.enterOpt_transaction_chain(this); + if(listener.enterAlterdefaultprivilegesstmt) { + listener.enterAlterdefaultprivilegesstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_transaction_chain) { - listener.exitOpt_transaction_chain(this); + if(listener.exitAlterdefaultprivilegesstmt) { + listener.exitAlterdefaultprivilegesstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_transaction_chain) { - return visitor.visitOpt_transaction_chain(this); + if (visitor.visitAlterdefaultprivilegesstmt) { + return visitor.visitAlterdefaultprivilegesstmt(this); } else { return visitor.visitChildren(this); } @@ -94197,80 +69577,68 @@ export class Opt_transaction_chainContext extends antlr.ParserRuleContext { } -export class ViewstmtContext extends antlr.ParserRuleContext { +export class DefaclactionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_viewstmt; - } - public override copyFrom(ctx: ViewstmtContext): void { - super.copyFrom(ctx); - } -} -export class CreateViewContext extends ViewstmtContext { - public constructor(ctx: ViewstmtContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); - } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; - } - public selectstmt(): SelectstmtContext { - return this.getRuleContext(0, SelectstmtContext)!; + public KW_GRANT(): antlr.TerminalNode[]; + public KW_GRANT(i: number): antlr.TerminalNode | null; + public KW_GRANT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_GRANT); + } else { + return this.getToken(PostgreSqlParser.KW_GRANT, i); + } } - public KW_VIEW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VIEW, 0); + public privileges(): PrivilegesContext { + return this.getRuleContext(0, PrivilegesContext)!; } - public view_name_create(): View_name_createContext | null { - return this.getRuleContext(0, View_name_createContext); + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; } - public KW_RECURSIVE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RECURSIVE, 0); + public defacl_privilege_target(): Defacl_privilege_targetContext { + return this.getRuleContext(0, Defacl_privilege_targetContext)!; } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } - public column_list(): Column_listContext | null { - return this.getRuleContext(0, Column_listContext); + public grantee_list(): Grantee_listContext { + return this.getRuleContext(0, Grantee_listContext)!; } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public KW_OR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OR, 0); + public KW_OPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPTION, 0); } - public KW_REPLACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REPLACE, 0); + public KW_REVOKE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REVOKE, 0); } - public opttemp(): OpttempContext | null { - return this.getRuleContext(0, OpttempContext); + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); } - public opt_check_option(): Opt_check_optionContext | null { - return this.getRuleContext(0, Opt_check_optionContext); + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } - public opt_column_list_create(): Opt_column_list_createContext | null { - return this.getRuleContext(0, Opt_column_list_createContext); + public opt_drop_behavior(): Opt_drop_behaviorContext | null { + return this.getRuleContext(0, Opt_drop_behaviorContext); } - public opt_reloptions(): Opt_reloptionsContext | null { - return this.getRuleContext(0, Opt_reloptionsContext); + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_defaclaction; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateView) { - listener.enterCreateView(this); + if(listener.enterDefaclaction) { + listener.enterDefaclaction(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateView) { - listener.exitCreateView(this); + if(listener.exitDefaclaction) { + listener.exitDefaclaction(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateView) { - return visitor.visitCreateView(this); + if (visitor.visitDefaclaction) { + return visitor.visitDefaclaction(this); } else { return visitor.visitChildren(this); } @@ -94278,41 +69646,44 @@ export class CreateViewContext extends ViewstmtContext { } -export class Opt_check_optionContext extends antlr.ParserRuleContext { +export class Defacl_privilege_targetContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; + public KW_TABLES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLES, 0); } - public KW_CHECK(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CHECK, 0)!; + public KW_FUNCTIONS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTIONS, 0); + } + public KW_ROUTINES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINES, 0); } - public KW_OPTION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OPTION, 0)!; + public KW_SEQUENCES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCES, 0); } - public KW_CASCADED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CASCADED, 0); + public KW_TYPES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPES, 0); } - public KW_LOCAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LOCAL, 0); + public KW_SCHEMAS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMAS, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_check_option; + return PostgreSqlParser.RULE_defacl_privilege_target; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_check_option) { - listener.enterOpt_check_option(this); + if(listener.enterDefacl_privilege_target) { + listener.enterDefacl_privilege_target(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_check_option) { - listener.exitOpt_check_option(this); + if(listener.exitDefacl_privilege_target) { + listener.exitDefacl_privilege_target(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_check_option) { - return visitor.visitOpt_check_option(this); + if (visitor.visitDefacl_privilege_target) { + return visitor.visitDefacl_privilege_target(this); } else { return visitor.visitChildren(this); } @@ -94320,113 +69691,83 @@ export class Opt_check_optionContext extends antlr.ParserRuleContext { } -export class LoadstmtContext extends antlr.ParserRuleContext { +export class IndexstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_LOAD(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_LOAD, 0)!; - } - public file_name(): File_nameContext { - return this.getRuleContext(0, File_nameContext)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_loadstmt; + public KW_INDEX(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_INDEX, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterLoadstmt) { - listener.enterLoadstmt(this); - } + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitLoadstmt) { - listener.exitLoadstmt(this); - } + public relation_expr(): Relation_exprContext { + return this.getRuleContext(0, Relation_exprContext)!; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitLoadstmt) { - return visitor.visitLoadstmt(this); - } else { - return visitor.visitChildren(this); + public index_params(): Index_paramsContext[]; + public index_params(i: number): Index_paramsContext | null; + public index_params(i?: number): Index_paramsContext[] | Index_paramsContext | null { + if (i === undefined) { + return this.getRuleContexts(Index_paramsContext); } - } -} - -export class CreatedbstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createdbstmt; + return this.getRuleContext(i, Index_paramsContext); } - public override copyFrom(ctx: CreatedbstmtContext): void { - super.copyFrom(ctx); + public KW_UNIQUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNIQUE, 0); } -} -export class CreateDatabaseContext extends CreatedbstmtContext { - public constructor(ctx: CreatedbstmtContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); + public KW_CONCURRENTLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONCURRENTLY, 0); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); } - public KW_DATABASE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DATABASE, 0)!; + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public database_name_create(): Database_name_createContext { - return this.getRuleContext(0, Database_name_createContext)!; + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); } - public opt_with(): Opt_withContext | null { - return this.getRuleContext(0, Opt_withContext); + public KW_INCLUDE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INCLUDE, 0); } - public createdb_opt_list(): Createdb_opt_listContext | null { - return this.getRuleContext(0, Createdb_opt_listContext); + public KW_NULLS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULLS, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateDatabase) { - listener.enterCreateDatabase(this); - } + public KW_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DISTINCT, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateDatabase) { - listener.exitCreateDatabase(this); - } + public opt_reloptions(): Opt_reloptionsContext | null { + return this.getRuleContext(0, Opt_reloptionsContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateDatabase) { - return visitor.visitCreateDatabase(this); - } else { - return visitor.visitChildren(this); - } + public opttablespace(): OpttablespaceContext | null { + return this.getRuleContext(0, OpttablespaceContext); } -} - - -export class Createdb_opt_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public where_clause(): Where_clauseContext | null { + return this.getRuleContext(0, Where_clauseContext); } - public createdb_opt_items(): Createdb_opt_itemsContext { - return this.getRuleContext(0, Createdb_opt_itemsContext)!; + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createdb_opt_list; + return PostgreSqlParser.RULE_indexstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatedb_opt_list) { - listener.enterCreatedb_opt_list(this); + if(listener.enterIndexstmt) { + listener.enterIndexstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatedb_opt_list) { - listener.exitCreatedb_opt_list(this); + if(listener.exitIndexstmt) { + listener.exitIndexstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatedb_opt_list) { - return visitor.visitCreatedb_opt_list(this); + if (visitor.visitIndexstmt) { + return visitor.visitIndexstmt(this); } else { return visitor.visitChildren(this); } @@ -94434,35 +69775,50 @@ export class Createdb_opt_listContext extends antlr.ParserRuleContext { } -export class Createdb_opt_itemsContext extends antlr.ParserRuleContext { +export class Index_paramsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public createdb_opt_item(): Createdb_opt_itemContext[]; - public createdb_opt_item(i: number): Createdb_opt_itemContext | null; - public createdb_opt_item(i?: number): Createdb_opt_itemContext[] | Createdb_opt_itemContext | null { + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + } + public index_elem(): Index_elemContext[]; + public index_elem(i: number): Index_elemContext | null; + public index_elem(i?: number): Index_elemContext[] | Index_elemContext | null { if (i === undefined) { - return this.getRuleContexts(Createdb_opt_itemContext); + return this.getRuleContexts(Index_elemContext); } - return this.getRuleContext(i, Createdb_opt_itemContext); + return this.getRuleContext(i, Index_elemContext); + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createdb_opt_items; + return PostgreSqlParser.RULE_index_params; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatedb_opt_items) { - listener.enterCreatedb_opt_items(this); + if(listener.enterIndex_params) { + listener.enterIndex_params(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatedb_opt_items) { - listener.exitCreatedb_opt_items(this); + if(listener.exitIndex_params) { + listener.exitIndex_params(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatedb_opt_items) { - return visitor.visitCreatedb_opt_items(this); + if (visitor.visitIndex_params) { + return visitor.visitIndex_params(this); } else { return visitor.visitChildren(this); } @@ -94470,41 +69826,65 @@ export class Createdb_opt_itemsContext extends antlr.ParserRuleContext { } -export class Createdb_opt_itemContext extends antlr.ParserRuleContext { +export class Index_elemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public createdb_opt_name(): Createdb_opt_nameContext { - return this.getRuleContext(0, Createdb_opt_nameContext)!; + public column_name(): Column_nameContext | null { + return this.getRuleContext(0, Column_nameContext); } - public signediconst(): SignediconstContext | null { - return this.getRuleContext(0, SignediconstContext); + public func_expr_windowless(): Func_expr_windowlessContext | null { + return this.getRuleContext(0, Func_expr_windowlessContext); } - public opt_boolean_or_string(): Opt_boolean_or_stringContext | null { - return this.getRuleContext(0, Opt_boolean_or_stringContext); + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + } + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); + } + public reloptions(): ReloptionsContext | null { + return this.getRuleContext(0, ReloptionsContext); } - public opt_equal(): Opt_equalContext | null { - return this.getRuleContext(0, Opt_equalContext); + public opt_collate_clause(): Opt_collate_clauseContext | null { + return this.getRuleContext(0, Opt_collate_clauseContext); + } + public KW_NULLS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULLS, 0); + } + public KW_ASC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ASC, 0); + } + public KW_DESC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DESC, 0); + } + public KW_FIRST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FIRST, 0); + } + public KW_LAST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LAST, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createdb_opt_item; + return PostgreSqlParser.RULE_index_elem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatedb_opt_item) { - listener.enterCreatedb_opt_item(this); + if(listener.enterIndex_elem) { + listener.enterIndex_elem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatedb_opt_item) { - listener.exitCreatedb_opt_item(this); + if(listener.exitIndex_elem) { + listener.exitIndex_elem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatedb_opt_item) { - return visitor.visitCreatedb_opt_item(this); + if (visitor.visitIndex_elem) { + return visitor.visitIndex_elem(this); } else { return visitor.visitChildren(this); } @@ -94512,80 +69892,113 @@ export class Createdb_opt_itemContext extends antlr.ParserRuleContext { } -export class Createdb_opt_nameContext extends antlr.ParserRuleContext { +export class CreatefunctionstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CONNECTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONNECTION, 0); + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public KW_LIMIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LIMIT, 0); + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); } - public KW_ENCODING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ENCODING, 0); + public function_name_create(): Function_name_createContext | null { + return this.getRuleContext(0, Function_name_createContext); } - public KW_LOCATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LOCATION, 0); + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); } - public KW_OWNER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OWNER, 0); + public procedure_name_create(): Procedure_name_createContext | null { + return this.getRuleContext(0, Procedure_name_createContext); } - public KW_TABLESPACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); + public OPEN_PAREN(): antlr.TerminalNode[]; + public OPEN_PAREN(i: number): antlr.TerminalNode | null; + public OPEN_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.OPEN_PAREN); + } else { + return this.getToken(PostgreSqlParser.OPEN_PAREN, i); + } } - public KW_TEMPLATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); + public CLOSE_PAREN(): antlr.TerminalNode[]; + public CLOSE_PAREN(i: number): antlr.TerminalNode | null; + public CLOSE_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.CLOSE_PAREN); + } else { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, i); + } } - public identifier(): IdentifierContext | null { - return this.getRuleContext(0, IdentifierContext); + public opt_or_replace(): Opt_or_replaceContext | null { + return this.getRuleContext(0, Opt_or_replaceContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createdb_opt_name; + public KW_RETURNS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RETURNS, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatedb_opt_name) { - listener.enterCreatedb_opt_name(this); + public createfunc_opt_item(): Createfunc_opt_itemContext[]; + public createfunc_opt_item(i: number): Createfunc_opt_itemContext | null; + public createfunc_opt_item(i?: number): Createfunc_opt_itemContext[] | Createfunc_opt_itemContext | null { + if (i === undefined) { + return this.getRuleContexts(Createfunc_opt_itemContext); } + + return this.getRuleContext(i, Createfunc_opt_itemContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatedb_opt_name) { - listener.exitCreatedb_opt_name(this); - } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatedb_opt_name) { - return visitor.visitCreatedb_opt_name(this); - } else { - return visitor.visitChildren(this); - } + public name_list(): Name_listContext | null { + return this.getRuleContext(0, Name_listContext); } -} + public func_arg_with_default(): Func_arg_with_defaultContext[]; + public func_arg_with_default(i: number): Func_arg_with_defaultContext | null; + public func_arg_with_default(i?: number): Func_arg_with_defaultContext[] | Func_arg_with_defaultContext | null { + if (i === undefined) { + return this.getRuleContexts(Func_arg_with_defaultContext); + } + return this.getRuleContext(i, Func_arg_with_defaultContext); + } + public func_type(): Func_typeContext | null { + return this.getRuleContext(0, Func_typeContext); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); + } + public table_func_column(): Table_func_columnContext[]; + public table_func_column(i: number): Table_func_columnContext | null; + public table_func_column(i?: number): Table_func_columnContext[] | Table_func_columnContext | null { + if (i === undefined) { + return this.getRuleContexts(Table_func_columnContext); + } -export class Opt_equalContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, Table_func_columnContext); } - public EQUAL(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.EQUAL, 0)!; + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_equal; + return PostgreSqlParser.RULE_createfunctionstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_equal) { - listener.enterOpt_equal(this); + if(listener.enterCreatefunctionstmt) { + listener.enterCreatefunctionstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_equal) { - listener.exitOpt_equal(this); + if(listener.exitCreatefunctionstmt) { + listener.exitCreatefunctionstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_equal) { - return visitor.visitOpt_equal(this); + if (visitor.visitCreatefunctionstmt) { + return visitor.visitCreatefunctionstmt(this); } else { return visitor.visitChildren(this); } @@ -94593,50 +70006,32 @@ export class Opt_equalContext extends antlr.ParserRuleContext { } -export class AlterdatabasestmtContext extends antlr.ParserRuleContext { +export class Opt_or_replaceContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_DATABASE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DATABASE, 0)!; - } - public database_name(): Database_nameContext { - return this.getRuleContext(0, Database_nameContext)!; - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public KW_TABLESPACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); - } - public tablespace_name_create(): Tablespace_name_createContext | null { - return this.getRuleContext(0, Tablespace_name_createContext); - } - public createdb_opt_list(): Createdb_opt_listContext | null { - return this.getRuleContext(0, Createdb_opt_listContext); + public KW_OR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_OR, 0)!; } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); + public KW_REPLACE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_REPLACE, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterdatabasestmt; + return PostgreSqlParser.RULE_opt_or_replace; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterdatabasestmt) { - listener.enterAlterdatabasestmt(this); + if(listener.enterOpt_or_replace) { + listener.enterOpt_or_replace(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterdatabasestmt) { - listener.exitAlterdatabasestmt(this); + if(listener.exitOpt_or_replace) { + listener.exitOpt_or_replace(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterdatabasestmt) { - return visitor.visitAlterdatabasestmt(this); + if (visitor.visitOpt_or_replace) { + return visitor.visitOpt_or_replace(this); } else { return visitor.visitChildren(this); } @@ -94644,38 +70039,35 @@ export class AlterdatabasestmtContext extends antlr.ParserRuleContext { } -export class AlterdatabasesetstmtContext extends antlr.ParserRuleContext { +export class Func_argsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_DATABASE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DATABASE, 0)!; + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public database_name(): Database_nameContext { - return this.getRuleContext(0, Database_nameContext)!; + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public setresetclause(): SetresetclauseContext | null { - return this.getRuleContext(0, SetresetclauseContext); + public func_args_list(): Func_args_listContext | null { + return this.getRuleContext(0, Func_args_listContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterdatabasesetstmt; + return PostgreSqlParser.RULE_func_args; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterdatabasesetstmt) { - listener.enterAlterdatabasesetstmt(this); + if(listener.enterFunc_args) { + listener.enterFunc_args(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterdatabasesetstmt) { - listener.exitAlterdatabasesetstmt(this); + if(listener.exitFunc_args) { + listener.exitFunc_args(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterdatabasesetstmt) { - return visitor.visitAlterdatabasesetstmt(this); + if (visitor.visitFunc_args) { + return visitor.visitFunc_args(this); } else { return visitor.visitChildren(this); } @@ -94683,18 +70075,18 @@ export class AlterdatabasesetstmtContext extends antlr.ParserRuleContext { } -export class Drop_option_listContext extends antlr.ParserRuleContext { +export class Func_args_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public drop_option(): Drop_optionContext[]; - public drop_option(i: number): Drop_optionContext | null; - public drop_option(i?: number): Drop_optionContext[] | Drop_optionContext | null { + public func_arg(): Func_argContext[]; + public func_arg(i: number): Func_argContext | null; + public func_arg(i?: number): Func_argContext[] | Func_argContext | null { if (i === undefined) { - return this.getRuleContexts(Drop_optionContext); + return this.getRuleContexts(Func_argContext); } - return this.getRuleContext(i, Drop_optionContext); + return this.getRuleContext(i, Func_argContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -94706,21 +70098,21 @@ export class Drop_option_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_drop_option_list; + return PostgreSqlParser.RULE_func_args_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDrop_option_list) { - listener.enterDrop_option_list(this); + if(listener.enterFunc_args_list) { + listener.enterFunc_args_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDrop_option_list) { - listener.exitDrop_option_list(this); + if(listener.exitFunc_args_list) { + listener.exitFunc_args_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDrop_option_list) { - return visitor.visitDrop_option_list(this); + if (visitor.visitFunc_args_list) { + return visitor.visitFunc_args_list(this); } else { return visitor.visitChildren(this); } @@ -94728,71 +70120,44 @@ export class Drop_option_listContext extends antlr.ParserRuleContext { } -export class Drop_optionContext extends antlr.ParserRuleContext { +export class Routine_with_argtypes_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FORCE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FORCE, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_drop_option; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDrop_option) { - listener.enterDrop_option(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDrop_option) { - listener.exitDrop_option(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDrop_option) { - return visitor.visitDrop_option(this); - } else { - return visitor.visitChildren(this); + public routine_with_argtypes(): Routine_with_argtypesContext[]; + public routine_with_argtypes(i: number): Routine_with_argtypesContext | null; + public routine_with_argtypes(i?: number): Routine_with_argtypesContext[] | Routine_with_argtypesContext | null { + if (i === undefined) { + return this.getRuleContexts(Routine_with_argtypesContext); } - } -} - -export class AltercollationstmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_COLLATION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_COLLATION, 0)!; - } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; - } - public KW_REFRESH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_REFRESH, 0)!; + return this.getRuleContext(i, Routine_with_argtypesContext); } - public KW_VERSION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VERSION, 0)!; + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_altercollationstmt; + return PostgreSqlParser.RULE_routine_with_argtypes_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAltercollationstmt) { - listener.enterAltercollationstmt(this); + if(listener.enterRoutine_with_argtypes_list) { + listener.enterRoutine_with_argtypes_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAltercollationstmt) { - listener.exitAltercollationstmt(this); + if(listener.exitRoutine_with_argtypes_list) { + listener.exitRoutine_with_argtypes_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAltercollationstmt) { - return visitor.visitAltercollationstmt(this); + if (visitor.visitRoutine_with_argtypes_list) { + return visitor.visitRoutine_with_argtypes_list(this); } else { return visitor.visitChildren(this); } @@ -94800,41 +70165,38 @@ export class AltercollationstmtContext extends antlr.ParserRuleContext { } -export class AltersystemstmtContext extends antlr.ParserRuleContext { +export class Routine_with_argtypesContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_SYSTEM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SYSTEM, 0)!; + public routine_name(): Routine_nameContext | null { + return this.getRuleContext(0, Routine_nameContext); } - public generic_set(): Generic_setContext { - return this.getRuleContext(0, Generic_setContext)!; + public func_args(): Func_argsContext | null { + return this.getRuleContext(0, Func_argsContext); } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); + public type_func_name_keyword(): Type_func_name_keywordContext | null { + return this.getRuleContext(0, Type_func_name_keywordContext); } - public KW_RESET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESET, 0); + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_altersystemstmt; + return PostgreSqlParser.RULE_routine_with_argtypes; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAltersystemstmt) { - listener.enterAltersystemstmt(this); + if(listener.enterRoutine_with_argtypes) { + listener.enterRoutine_with_argtypes(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAltersystemstmt) { - listener.exitAltersystemstmt(this); + if(listener.exitRoutine_with_argtypes) { + listener.exitRoutine_with_argtypes(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAltersystemstmt) { - return visitor.visitAltersystemstmt(this); + if (visitor.visitRoutine_with_argtypes) { + return visitor.visitRoutine_with_argtypes(this); } else { return visitor.visitChildren(this); } @@ -94842,44 +70204,44 @@ export class AltersystemstmtContext extends antlr.ParserRuleContext { } -export class CreatedomainstmtContext extends antlr.ParserRuleContext { +export class Procedure_with_argtypes_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_DOMAIN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DOMAIN, 0)!; - } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; - } - public typename(): TypenameContext { - return this.getRuleContext(0, TypenameContext)!; - } - public colquallist(): ColquallistContext { - return this.getRuleContext(0, ColquallistContext)!; + public procedure_with_argtypes(): Procedure_with_argtypesContext[]; + public procedure_with_argtypes(i: number): Procedure_with_argtypesContext | null; + public procedure_with_argtypes(i?: number): Procedure_with_argtypesContext[] | Procedure_with_argtypesContext | null { + if (i === undefined) { + return this.getRuleContexts(Procedure_with_argtypesContext); + } + + return this.getRuleContext(i, Procedure_with_argtypesContext); } - public opt_as(): Opt_asContext | null { - return this.getRuleContext(0, Opt_asContext); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createdomainstmt; + return PostgreSqlParser.RULE_procedure_with_argtypes_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreatedomainstmt) { - listener.enterCreatedomainstmt(this); + if(listener.enterProcedure_with_argtypes_list) { + listener.enterProcedure_with_argtypes_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreatedomainstmt) { - listener.exitCreatedomainstmt(this); + if(listener.exitProcedure_with_argtypes_list) { + listener.exitProcedure_with_argtypes_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreatedomainstmt) { - return visitor.visitCreatedomainstmt(this); + if (visitor.visitProcedure_with_argtypes_list) { + return visitor.visitProcedure_with_argtypes_list(this); } else { return visitor.visitChildren(this); } @@ -94887,71 +70249,38 @@ export class CreatedomainstmtContext extends antlr.ParserRuleContext { } -export class AlterdomainstmtContext extends antlr.ParserRuleContext { +export class Procedure_with_argtypesContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_DOMAIN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DOMAIN, 0)!; - } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; - } - public alter_column_default(): Alter_column_defaultContext | null { - return this.getRuleContext(0, Alter_column_defaultContext); - } - public KW_DROP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DROP, 0); - } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); - } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public KW_ADD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADD, 0); - } - public tableconstraint(): TableconstraintContext | null { - return this.getRuleContext(0, TableconstraintContext); - } - public KW_CONSTRAINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); - } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); + public procedure_name(): Procedure_nameContext | null { + return this.getRuleContext(0, Procedure_nameContext); } - public KW_VALIDATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALIDATE, 0); + public func_args(): Func_argsContext | null { + return this.getRuleContext(0, Func_argsContext); } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); + public type_func_name_keyword(): Type_func_name_keywordContext | null { + return this.getRuleContext(0, Type_func_name_keywordContext); } - public opt_drop_behavior(): Opt_drop_behaviorContext | null { - return this.getRuleContext(0, Opt_drop_behaviorContext); + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alterdomainstmt; + return PostgreSqlParser.RULE_procedure_with_argtypes; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlterdomainstmt) { - listener.enterAlterdomainstmt(this); + if(listener.enterProcedure_with_argtypes) { + listener.enterProcedure_with_argtypes(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlterdomainstmt) { - listener.exitAlterdomainstmt(this); + if(listener.exitProcedure_with_argtypes) { + listener.exitProcedure_with_argtypes(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlterdomainstmt) { - return visitor.visitAlterdomainstmt(this); + if (visitor.visitProcedure_with_argtypes) { + return visitor.visitProcedure_with_argtypes(this); } else { return visitor.visitChildren(this); } @@ -94959,29 +70288,44 @@ export class AlterdomainstmtContext extends antlr.ParserRuleContext { } -export class Opt_asContext extends antlr.ParserRuleContext { +export class Function_with_argtypes_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; + public function_with_argtypes(): Function_with_argtypesContext[]; + public function_with_argtypes(i: number): Function_with_argtypesContext | null; + public function_with_argtypes(i?: number): Function_with_argtypesContext[] | Function_with_argtypesContext | null { + if (i === undefined) { + return this.getRuleContexts(Function_with_argtypesContext); + } + + return this.getRuleContext(i, Function_with_argtypesContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_as; + return PostgreSqlParser.RULE_function_with_argtypes_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_as) { - listener.enterOpt_as(this); + if(listener.enterFunction_with_argtypes_list) { + listener.enterFunction_with_argtypes_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_as) { - listener.exitOpt_as(this); + if(listener.exitFunction_with_argtypes_list) { + listener.exitFunction_with_argtypes_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_as) { - return visitor.visitOpt_as(this); + if (visitor.visitFunction_with_argtypes_list) { + return visitor.visitFunction_with_argtypes_list(this); } else { return visitor.visitChildren(this); } @@ -94989,44 +70333,38 @@ export class Opt_asContext extends antlr.ParserRuleContext { } -export class AltertsdictionarystmtContext extends antlr.ParserRuleContext { +export class Function_with_argtypesContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; - } - public KW_TEXT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TEXT, 0)!; - } - public KW_SEARCH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SEARCH, 0)!; + public function_name(): Function_nameContext | null { + return this.getRuleContext(0, Function_nameContext); } - public KW_DICTIONARY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0)!; + public func_args(): Func_argsContext | null { + return this.getRuleContext(0, Func_argsContext); } - public any_name(): Any_nameContext { - return this.getRuleContext(0, Any_nameContext)!; + public type_func_name_keyword(): Type_func_name_keywordContext | null { + return this.getRuleContext(0, Type_func_name_keywordContext); } - public definition(): DefinitionContext { - return this.getRuleContext(0, DefinitionContext)!; + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_altertsdictionarystmt; + return PostgreSqlParser.RULE_function_with_argtypes; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAltertsdictionarystmt) { - listener.enterAltertsdictionarystmt(this); + if(listener.enterFunction_with_argtypes) { + listener.enterFunction_with_argtypes(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAltertsdictionarystmt) { - listener.exitAltertsdictionarystmt(this); + if(listener.exitFunction_with_argtypes) { + listener.exitFunction_with_argtypes(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAltertsdictionarystmt) { - return visitor.visitAltertsdictionarystmt(this); + if (visitor.visitFunction_with_argtypes) { + return visitor.visitFunction_with_argtypes(this); } else { return visitor.visitChildren(this); } @@ -95034,80 +70372,35 @@ export class AltertsdictionarystmtContext extends antlr.ParserRuleContext { } -export class AltertsconfigurationstmtContext extends antlr.ParserRuleContext { +export class Func_argContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALTER(): antlr.TerminalNode[]; - public KW_ALTER(i: number): antlr.TerminalNode | null; - public KW_ALTER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_ALTER); - } else { - return this.getToken(PostgreSqlParser.KW_ALTER, i); - } - } - public KW_TEXT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TEXT, 0)!; - } - public KW_SEARCH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SEARCH, 0)!; - } - public KW_CONFIGURATION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0)!; - } - public any_name(): Any_nameContext[]; - public any_name(i: number): Any_nameContext | null; - public any_name(i?: number): Any_nameContext[] | Any_nameContext | null { - if (i === undefined) { - return this.getRuleContexts(Any_nameContext); - } - - return this.getRuleContext(i, Any_nameContext); - } - public KW_ADD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ADD, 0); - } - public KW_MAPPING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_MAPPING, 0)!; - } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); - } - public name_list(): Name_listContext | null { - return this.getRuleContext(0, Name_listContext); - } - public any_with(): Any_withContext | null { - return this.getRuleContext(0, Any_withContext); - } - public any_name_list(): Any_name_listContext | null { - return this.getRuleContext(0, Any_name_listContext); - } - public KW_REPLACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REPLACE, 0); + public func_type(): Func_typeContext { + return this.getRuleContext(0, Func_typeContext)!; } - public KW_DROP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DROP, 0); + public arg_class(): Arg_classContext | null { + return this.getRuleContext(0, Arg_classContext); } - public opt_if_exists(): Opt_if_existsContext | null { - return this.getRuleContext(0, Opt_if_existsContext); + public type_function_name(): Type_function_nameContext | null { + return this.getRuleContext(0, Type_function_nameContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_altertsconfigurationstmt; + return PostgreSqlParser.RULE_func_arg; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAltertsconfigurationstmt) { - listener.enterAltertsconfigurationstmt(this); + if(listener.enterFunc_arg) { + listener.enterFunc_arg(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAltertsconfigurationstmt) { - listener.exitAltertsconfigurationstmt(this); + if(listener.exitFunc_arg) { + listener.exitFunc_arg(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAltertsconfigurationstmt) { - return visitor.visitAltertsconfigurationstmt(this); + if (visitor.visitFunc_arg) { + return visitor.visitFunc_arg(this); } else { return visitor.visitChildren(this); } @@ -95115,29 +70408,38 @@ export class AltertsconfigurationstmtContext extends antlr.ParserRuleContext { } -export class Any_withContext extends antlr.ParserRuleContext { +export class Arg_classContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); + } + public KW_OUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OUT, 0); + } + public KW_INOUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INOUT, 0); + } + public KW_VARIADIC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VARIADIC, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_any_with; + return PostgreSqlParser.RULE_arg_class; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAny_with) { - listener.enterAny_with(this); + if(listener.enterArg_class) { + listener.enterArg_class(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAny_with) { - listener.exitAny_with(this); + if(listener.exitArg_class) { + listener.exitArg_class(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAny_with) { - return visitor.visitAny_with(this); + if (visitor.visitArg_class) { + return visitor.visitArg_class(this); } else { return visitor.visitChildren(this); } @@ -95145,62 +70447,44 @@ export class Any_withContext extends antlr.ParserRuleContext { } -export class CreateconversionstmtContext extends antlr.ParserRuleContext { +export class Func_typeContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CREATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; - } - public KW_CONVERSION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CONVERSION, 0)!; - } - public any_name(): Any_nameContext[]; - public any_name(i: number): Any_nameContext | null; - public any_name(i?: number): Any_nameContext[] | Any_nameContext | null { - if (i === undefined) { - return this.getRuleContexts(Any_nameContext); - } - - return this.getRuleContext(i, Any_nameContext); + public typename(): TypenameContext | null { + return this.getRuleContext(0, TypenameContext); } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; + public type_function_name(): Type_function_nameContext | null { + return this.getRuleContext(0, Type_function_nameContext); } - public sconst(): SconstContext[]; - public sconst(i: number): SconstContext | null; - public sconst(i?: number): SconstContext[] | SconstContext | null { - if (i === undefined) { - return this.getRuleContexts(SconstContext); - } - - return this.getRuleContext(i, SconstContext); + public attrs(): AttrsContext | null { + return this.getRuleContext(0, AttrsContext); } - public KW_TO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TO, 0)!; + public PERCENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.PERCENT, 0); } - public KW_FROM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FROM, 0)!; + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); } - public opt_default(): Opt_defaultContext | null { - return this.getRuleContext(0, Opt_defaultContext); + public KW_SETOF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SETOF, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_createconversionstmt; + return PostgreSqlParser.RULE_func_type; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCreateconversionstmt) { - listener.enterCreateconversionstmt(this); + if(listener.enterFunc_type) { + listener.enterFunc_type(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCreateconversionstmt) { - listener.exitCreateconversionstmt(this); + if(listener.exitFunc_type) { + listener.exitFunc_type(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCreateconversionstmt) { - return visitor.visitCreateconversionstmt(this); + if (visitor.visitFunc_type) { + return visitor.visitFunc_type(this); } else { return visitor.visitChildren(this); } @@ -95208,41 +70492,38 @@ export class CreateconversionstmtContext extends antlr.ParserRuleContext { } -export class ClusterstmtContext extends antlr.ParserRuleContext { +export class Func_arg_with_defaultContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CLUSTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CLUSTER, 0)!; - } - public table_name(): Table_nameContext | null { - return this.getRuleContext(0, Table_nameContext); + public func_arg(): Func_argContext { + return this.getRuleContext(0, Func_argContext)!; } - public opt_verbose(): Opt_verboseContext | null { - return this.getRuleContext(0, Opt_verboseContext); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } - public cluster_index_specification(): Cluster_index_specificationContext | null { - return this.getRuleContext(0, Cluster_index_specificationContext); + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } - public opt_verbose_list(): Opt_verbose_listContext | null { - return this.getRuleContext(0, Opt_verbose_listContext); + public EQUAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.EQUAL, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_clusterstmt; + return PostgreSqlParser.RULE_func_arg_with_default; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterClusterstmt) { - listener.enterClusterstmt(this); + if(listener.enterFunc_arg_with_default) { + listener.enterFunc_arg_with_default(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitClusterstmt) { - listener.exitClusterstmt(this); + if(listener.exitFunc_arg_with_default) { + listener.exitFunc_arg_with_default(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitClusterstmt) { - return visitor.visitClusterstmt(this); + if (visitor.visitFunc_arg_with_default) { + return visitor.visitFunc_arg_with_default(this); } else { return visitor.visitChildren(this); } @@ -95250,50 +70531,50 @@ export class ClusterstmtContext extends antlr.ParserRuleContext { } -export class Opt_verbose_listContext extends antlr.ParserRuleContext { +export class Aggr_argsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } public OPEN_PAREN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public opt_verbose(): Opt_verboseContext[]; - public opt_verbose(i: number): Opt_verboseContext | null; - public opt_verbose(i?: number): Opt_verboseContext[] | Opt_verboseContext | null { + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + } + public STAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.STAR, 0); + } + public func_args_list(): Func_args_listContext[]; + public func_args_list(i: number): Func_args_listContext | null; + public func_args_list(i?: number): Func_args_listContext[] | Func_args_listContext | null { if (i === undefined) { - return this.getRuleContexts(Opt_verboseContext); + return this.getRuleContexts(Func_args_listContext); } - return this.getRuleContext(i, Opt_verboseContext); - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + return this.getRuleContext(i, Func_args_listContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_ORDER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ORDER, 0); + } + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BY, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_verbose_list; + return PostgreSqlParser.RULE_aggr_args; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_verbose_list) { - listener.enterOpt_verbose_list(this); + if(listener.enterAggr_args) { + listener.enterAggr_args(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_verbose_list) { - listener.exitOpt_verbose_list(this); + if(listener.exitAggr_args) { + listener.exitAggr_args(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_verbose_list) { - return visitor.visitOpt_verbose_list(this); + if (visitor.visitAggr_args) { + return visitor.visitAggr_args(this); } else { return visitor.visitChildren(this); } @@ -95301,32 +70582,32 @@ export class Opt_verbose_listContext extends antlr.ParserRuleContext { } -export class Cluster_index_specificationContext extends antlr.ParserRuleContext { +export class Aggregate_with_argtypesContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; + public function_name(): Function_nameContext { + return this.getRuleContext(0, Function_nameContext)!; } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public aggr_args(): Aggr_argsContext { + return this.getRuleContext(0, Aggr_argsContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_cluster_index_specification; + return PostgreSqlParser.RULE_aggregate_with_argtypes; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCluster_index_specification) { - listener.enterCluster_index_specification(this); + if(listener.enterAggregate_with_argtypes) { + listener.enterAggregate_with_argtypes(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCluster_index_specification) { - listener.exitCluster_index_specification(this); + if(listener.exitAggregate_with_argtypes) { + listener.exitAggregate_with_argtypes(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCluster_index_specification) { - return visitor.visitCluster_index_specification(this); + if (visitor.visitAggregate_with_argtypes) { + return visitor.visitAggregate_with_argtypes(this); } else { return visitor.visitChildren(this); } @@ -95334,98 +70615,107 @@ export class Cluster_index_specificationContext extends antlr.ParserRuleContext } -export class VacuumstmtContext extends antlr.ParserRuleContext { +export class Common_func_opt_itemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_VACUUM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VACUUM, 0)!; + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ON, 0); } - public opt_full(): Opt_fullContext | null { - return this.getRuleContext(0, Opt_fullContext); + public KW_NULL(): antlr.TerminalNode[]; + public KW_NULL(i: number): antlr.TerminalNode | null; + public KW_NULL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_NULL); + } else { + return this.getToken(PostgreSqlParser.KW_NULL, i); + } } - public opt_freeze(): Opt_freezeContext | null { - return this.getRuleContext(0, Opt_freezeContext); + public KW_INPUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INPUT, 0); } - public opt_verbose(): Opt_verboseContext | null { - return this.getRuleContext(0, Opt_verboseContext); + public KW_RETURNS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RETURNS, 0); } - public opt_analyze(): Opt_analyzeContext | null { - return this.getRuleContext(0, Opt_analyzeContext); + public KW_CALLED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CALLED, 0); } - public opt_vacuum_relation_list(): Opt_vacuum_relation_listContext | null { - return this.getRuleContext(0, Opt_vacuum_relation_listContext); + public KW_STRICT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STRICT, 0); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_IMMUTABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IMMUTABLE, 0); } - public vac_analyze_option_list(): Vac_analyze_option_listContext | null { - return this.getRuleContext(0, Vac_analyze_option_listContext); + public KW_STABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STABLE, 0); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_VOLATILE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VOLATILE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_vacuumstmt; + public KW_SECURITY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SECURITY, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVacuumstmt) { - listener.enterVacuumstmt(this); - } + public KW_DEFINER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFINER, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVacuumstmt) { - listener.exitVacuumstmt(this); - } + public KW_INVOKER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INVOKER, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVacuumstmt) { - return visitor.visitVacuumstmt(this); - } else { - return visitor.visitChildren(this); - } + public KW_EXTERNAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXTERNAL, 0); } -} - - -export class AnalyzestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_LEAKPROOF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LEAKPROOF, 0); } - public analyze_keyword(): Analyze_keywordContext { - return this.getRuleContext(0, Analyze_keywordContext)!; + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } - public opt_verbose(): Opt_verboseContext | null { - return this.getRuleContext(0, Opt_verboseContext); + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); } - public opt_vacuum_relation_list(): Opt_vacuum_relation_listContext | null { - return this.getRuleContext(0, Opt_vacuum_relation_listContext); + public KW_COST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COST, 0); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_ROWS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROWS, 0); } - public analyze_options_list(): Analyze_options_listContext | null { - return this.getRuleContext(0, Analyze_options_listContext); + public KW_SUPPORT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SUPPORT, 0); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); + } + public set_rest_more(): Set_rest_moreContext | null { + return this.getRuleContext(0, Set_rest_moreContext); + } + public variableresetstmt(): VariableresetstmtContext | null { + return this.getRuleContext(0, VariableresetstmtContext); + } + public KW_PARALLEL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARALLEL, 0); + } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_analyzestmt; + return PostgreSqlParser.RULE_common_func_opt_item; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAnalyzestmt) { - listener.enterAnalyzestmt(this); + if(listener.enterCommon_func_opt_item) { + listener.enterCommon_func_opt_item(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAnalyzestmt) { - listener.exitAnalyzestmt(this); + if(listener.exitCommon_func_opt_item) { + listener.exitCommon_func_opt_item(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAnalyzestmt) { - return visitor.visitAnalyzestmt(this); + if (visitor.visitCommon_func_opt_item) { + return visitor.visitCommon_func_opt_item(this); } else { return visitor.visitChildren(this); } @@ -95433,18 +70723,54 @@ export class AnalyzestmtContext extends antlr.ParserRuleContext { } -export class Vac_analyze_option_listContext extends antlr.ParserRuleContext { +export class Createfunc_opt_itemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public vac_analyze_option_elem(): Vac_analyze_option_elemContext[]; - public vac_analyze_option_elem(i: number): Vac_analyze_option_elemContext | null; - public vac_analyze_option_elem(i?: number): Vac_analyze_option_elemContext[] | Vac_analyze_option_elemContext | null { + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); + } + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); + } + public notify_payload(): Notify_payloadContext | null { + return this.getRuleContext(0, Notify_payloadContext); + } + public KW_LANGUAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); + } + public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | null { + return this.getRuleContext(0, Nonreservedword_or_sconstContext); + } + public KW_TRANSFORM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0); + } + public KW_FOR(): antlr.TerminalNode[]; + public KW_FOR(i: number): antlr.TerminalNode | null; + public KW_FOR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_FOR); + } else { + return this.getToken(PostgreSqlParser.KW_FOR, i); + } + } + public KW_TYPE(): antlr.TerminalNode[]; + public KW_TYPE(i: number): antlr.TerminalNode | null; + public KW_TYPE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_TYPE); + } else { + return this.getToken(PostgreSqlParser.KW_TYPE, i); + } + } + public typename(): TypenameContext[]; + public typename(i: number): TypenameContext | null; + public typename(i?: number): TypenameContext[] | TypenameContext | null { if (i === undefined) { - return this.getRuleContexts(Vac_analyze_option_elemContext); + return this.getRuleContexts(TypenameContext); } - return this.getRuleContext(i, Vac_analyze_option_elemContext); + return this.getRuleContext(i, TypenameContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -95455,55 +70781,55 @@ export class Vac_analyze_option_listContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.COMMA, i); } } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_vac_analyze_option_list; + public KW_WINDOW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WINDOW, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVac_analyze_option_list) { - listener.enterVac_analyze_option_list(this); - } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVac_analyze_option_list) { - listener.exitVac_analyze_option_list(this); + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { + if (i === undefined) { + return this.getRuleContexts(ColidContext); } + + return this.getRuleContext(i, ColidContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVac_analyze_option_list) { - return visitor.visitVac_analyze_option_list(this); - } else { - return visitor.visitChildren(this); - } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } -} - - -export class Analyze_keywordContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public EQUAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.EQUAL, 0); } - public KW_ANALYZE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ANALYZE, 0); + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); } - public KW_ANALYSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ANALYSE, 0); + public KW_CURRENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT, 0); + } + public stmt(): StmtContext | null { + return this.getRuleContext(0, StmtContext); + } + public common_func_opt_item(): Common_func_opt_itemContext | null { + return this.getRuleContext(0, Common_func_opt_itemContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_analyze_keyword; + return PostgreSqlParser.RULE_createfunc_opt_item; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAnalyze_keyword) { - listener.enterAnalyze_keyword(this); + if(listener.enterCreatefunc_opt_item) { + listener.enterCreatefunc_opt_item(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAnalyze_keyword) { - listener.exitAnalyze_keyword(this); + if(listener.exitCreatefunc_opt_item) { + listener.exitCreatefunc_opt_item(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAnalyze_keyword) { - return visitor.visitAnalyze_keyword(this); + if (visitor.visitCreatefunc_opt_item) { + return visitor.visitCreatefunc_opt_item(this); } else { return visitor.visitChildren(this); } @@ -95511,32 +70837,32 @@ export class Analyze_keywordContext extends antlr.ParserRuleContext { } -export class Vac_analyze_option_elemContext extends antlr.ParserRuleContext { +export class Opt_definitionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public vac_analyze_option_name(): Vac_analyze_option_nameContext { - return this.getRuleContext(0, Vac_analyze_option_nameContext)!; + public KW_WITH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WITH, 0)!; } - public vac_analyze_option_arg(): Vac_analyze_option_argContext | null { - return this.getRuleContext(0, Vac_analyze_option_argContext); + public definition(): DefinitionContext { + return this.getRuleContext(0, DefinitionContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_vac_analyze_option_elem; + return PostgreSqlParser.RULE_opt_definition; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVac_analyze_option_elem) { - listener.enterVac_analyze_option_elem(this); + if(listener.enterOpt_definition) { + listener.enterOpt_definition(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVac_analyze_option_elem) { - listener.exitVac_analyze_option_elem(this); + if(listener.exitOpt_definition) { + listener.exitOpt_definition(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVac_analyze_option_elem) { - return visitor.visitVac_analyze_option_elem(this); + if (visitor.visitOpt_definition) { + return visitor.visitOpt_definition(this); } else { return visitor.visitChildren(this); } @@ -95544,32 +70870,32 @@ export class Vac_analyze_option_elemContext extends antlr.ParserRuleContext { } -export class Vac_analyze_option_nameContext extends antlr.ParserRuleContext { +export class Table_func_columnContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public nonreservedword(): NonreservedwordContext | null { - return this.getRuleContext(0, NonreservedwordContext); + public column_name(): Column_nameContext { + return this.getRuleContext(0, Column_nameContext)!; } - public analyze_keyword(): Analyze_keywordContext | null { - return this.getRuleContext(0, Analyze_keywordContext); + public func_type(): Func_typeContext { + return this.getRuleContext(0, Func_typeContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_vac_analyze_option_name; + return PostgreSqlParser.RULE_table_func_column; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVac_analyze_option_name) { - listener.enterVac_analyze_option_name(this); + if(listener.enterTable_func_column) { + listener.enterTable_func_column(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVac_analyze_option_name) { - listener.exitVac_analyze_option_name(this); + if(listener.exitTable_func_column) { + listener.exitTable_func_column(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVac_analyze_option_name) { - return visitor.visitVac_analyze_option_name(this); + if (visitor.visitTable_func_column) { + return visitor.visitTable_func_column(this); } else { return visitor.visitChildren(this); } @@ -95577,32 +70903,59 @@ export class Vac_analyze_option_nameContext extends antlr.ParserRuleContext { } -export class Vac_analyze_option_argContext extends antlr.ParserRuleContext { +export class AlterfunctionstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public opt_boolean_or_string(): Opt_boolean_or_stringContext | null { - return this.getRuleContext(0, Opt_boolean_or_stringContext); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + } + public function_with_argtypes(): Function_with_argtypesContext | null { + return this.getRuleContext(0, Function_with_argtypesContext); + } + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + } + public procedure_with_argtypes(): Procedure_with_argtypesContext | null { + return this.getRuleContext(0, Procedure_with_argtypesContext); + } + public KW_ROUTINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); + } + public routine_with_argtypes(): Routine_with_argtypesContext | null { + return this.getRuleContext(0, Routine_with_argtypesContext); + } + public common_func_opt_item(): Common_func_opt_itemContext[]; + public common_func_opt_item(i: number): Common_func_opt_itemContext | null; + public common_func_opt_item(i?: number): Common_func_opt_itemContext[] | Common_func_opt_itemContext | null { + if (i === undefined) { + return this.getRuleContexts(Common_func_opt_itemContext); + } + + return this.getRuleContext(i, Common_func_opt_itemContext); + } + public KW_RESTRICT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESTRICT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_vac_analyze_option_arg; + return PostgreSqlParser.RULE_alterfunctionstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVac_analyze_option_arg) { - listener.enterVac_analyze_option_arg(this); + if(listener.enterAlterfunctionstmt) { + listener.enterAlterfunctionstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVac_analyze_option_arg) { - listener.exitVac_analyze_option_arg(this); + if(listener.exitAlterfunctionstmt) { + listener.exitAlterfunctionstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVac_analyze_option_arg) { - return visitor.visitVac_analyze_option_arg(this); + if (visitor.visitAlterfunctionstmt) { + return visitor.visitAlterfunctionstmt(this); } else { return visitor.visitChildren(this); } @@ -95610,29 +70963,53 @@ export class Vac_analyze_option_argContext extends antlr.ParserRuleContext { } -export class Opt_analyzeContext extends antlr.ParserRuleContext { +export class RemovefuncstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public analyze_keyword(): Analyze_keywordContext { - return this.getRuleContext(0, Analyze_keywordContext)!; + public KW_DROP(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DROP, 0)!; + } + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + } + public function_with_argtypes_list(): Function_with_argtypes_listContext | null { + return this.getRuleContext(0, Function_with_argtypes_listContext); + } + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); + } + public procedure_with_argtypes_list(): Procedure_with_argtypes_listContext | null { + return this.getRuleContext(0, Procedure_with_argtypes_listContext); + } + public KW_ROUTINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); + } + public routine_with_argtypes_list(): Routine_with_argtypes_listContext | null { + return this.getRuleContext(0, Routine_with_argtypes_listContext); + } + public opt_drop_behavior(): Opt_drop_behaviorContext | null { + return this.getRuleContext(0, Opt_drop_behaviorContext); + } + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_analyze; + return PostgreSqlParser.RULE_removefuncstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_analyze) { - listener.enterOpt_analyze(this); + if(listener.enterRemovefuncstmt) { + listener.enterRemovefuncstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_analyze) { - listener.exitOpt_analyze(this); + if(listener.exitRemovefuncstmt) { + listener.exitRemovefuncstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_analyze) { - return visitor.visitOpt_analyze(this); + if (visitor.visitRemovefuncstmt) { + return visitor.visitRemovefuncstmt(this); } else { return visitor.visitChildren(this); } @@ -95640,18 +71017,30 @@ export class Opt_analyzeContext extends antlr.ParserRuleContext { } -export class Analyze_options_listContext extends antlr.ParserRuleContext { +export class RemoveaggrstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public analyze_option_elem(): Analyze_option_elemContext[]; - public analyze_option_elem(i: number): Analyze_option_elemContext | null; - public analyze_option_elem(i?: number): Analyze_option_elemContext[] | Analyze_option_elemContext | null { + public KW_DROP(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DROP, 0)!; + } + public KW_AGGREGATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0)!; + } + public aggregate_with_argtypes(): Aggregate_with_argtypesContext[]; + public aggregate_with_argtypes(i: number): Aggregate_with_argtypesContext | null; + public aggregate_with_argtypes(i?: number): Aggregate_with_argtypesContext[] | Aggregate_with_argtypesContext | null { if (i === undefined) { - return this.getRuleContexts(Analyze_option_elemContext); + return this.getRuleContexts(Aggregate_with_argtypesContext); } - return this.getRuleContext(i, Analyze_option_elemContext); + return this.getRuleContext(i, Aggregate_with_argtypesContext); + } + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); + } + public opt_drop_behavior(): Opt_drop_behaviorContext | null { + return this.getRuleContext(0, Opt_drop_behaviorContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -95663,21 +71052,21 @@ export class Analyze_options_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_analyze_options_list; + return PostgreSqlParser.RULE_removeaggrstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAnalyze_options_list) { - listener.enterAnalyze_options_list(this); + if(listener.enterRemoveaggrstmt) { + listener.enterRemoveaggrstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAnalyze_options_list) { - listener.exitAnalyze_options_list(this); + if(listener.exitRemoveaggrstmt) { + listener.exitRemoveaggrstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAnalyze_options_list) { - return visitor.visitAnalyze_options_list(this); + if (visitor.visitRemoveaggrstmt) { + return visitor.visitRemoveaggrstmt(this); } else { return visitor.visitChildren(this); } @@ -95685,71 +71074,56 @@ export class Analyze_options_listContext extends antlr.ParserRuleContext { } -export class Analyze_option_elemContext extends antlr.ParserRuleContext { +export class RemoveoperstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public opt_verbose(): Opt_verboseContext | null { - return this.getRuleContext(0, Opt_verboseContext); - } - public opt_skiplock(): Opt_skiplockContext | null { - return this.getRuleContext(0, Opt_skiplockContext); - } - public opt_buffer_usage_limit(): Opt_buffer_usage_limitContext | null { - return this.getRuleContext(0, Opt_buffer_usage_limitContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_analyze_option_elem; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAnalyze_option_elem) { - listener.enterAnalyze_option_elem(this); - } + public KW_DROP(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DROP, 0)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAnalyze_option_elem) { - listener.exitAnalyze_option_elem(this); - } + public KW_OPERATOR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0)!; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAnalyze_option_elem) { - return visitor.visitAnalyze_option_elem(this); - } else { - return visitor.visitChildren(this); + public operator_with_argtypes(): Operator_with_argtypesContext[]; + public operator_with_argtypes(i: number): Operator_with_argtypesContext | null; + public operator_with_argtypes(i?: number): Operator_with_argtypesContext[] | Operator_with_argtypesContext | null { + if (i === undefined) { + return this.getRuleContexts(Operator_with_argtypesContext); } - } -} - -export class Opt_verboseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, Operator_with_argtypesContext); } - public KW_VERBOSE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VERBOSE, 0)!; + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); } - public KW_FALSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FALSE, 0); + public opt_drop_behavior(): Opt_drop_behaviorContext | null { + return this.getRuleContext(0, Opt_drop_behaviorContext); } - public KW_TRUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRUE, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_verbose; + return PostgreSqlParser.RULE_removeoperstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_verbose) { - listener.enterOpt_verbose(this); + if(listener.enterRemoveoperstmt) { + listener.enterRemoveoperstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_verbose) { - listener.exitOpt_verbose(this); + if(listener.exitRemoveoperstmt) { + listener.exitRemoveoperstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_verbose) { - return visitor.visitOpt_verbose(this); + if (visitor.visitRemoveoperstmt) { + return visitor.visitRemoveoperstmt(this); } else { return visitor.visitChildren(this); } @@ -95757,35 +71131,47 @@ export class Opt_verboseContext extends antlr.ParserRuleContext { } -export class Opt_skiplockContext extends antlr.ParserRuleContext { +export class Oper_argtypesContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_SKIP_LOCKED(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SKIP_LOCKED, 0)!; + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public KW_FALSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FALSE, 0); + public typename(): TypenameContext[]; + public typename(i: number): TypenameContext | null; + public typename(i?: number): TypenameContext[] | TypenameContext | null { + if (i === undefined) { + return this.getRuleContexts(TypenameContext); + } + + return this.getRuleContext(i, TypenameContext); } - public KW_TRUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRUE, 0); + public KW_NONE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NONE, 0); + } + public COMMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.COMMA, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_skiplock; + return PostgreSqlParser.RULE_oper_argtypes; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_skiplock) { - listener.enterOpt_skiplock(this); + if(listener.enterOper_argtypes) { + listener.enterOper_argtypes(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_skiplock) { - listener.exitOpt_skiplock(this); + if(listener.exitOper_argtypes) { + listener.exitOper_argtypes(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_skiplock) { - return visitor.visitOpt_skiplock(this); + if (visitor.visitOper_argtypes) { + return visitor.visitOper_argtypes(this); } else { return visitor.visitChildren(this); } @@ -95793,35 +71179,47 @@ export class Opt_skiplockContext extends antlr.ParserRuleContext { } -export class Opt_buffer_usage_limitContext extends antlr.ParserRuleContext { +export class Any_operatorContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_BUFFER_USAGE_LIMIT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BUFFER_USAGE_LIMIT, 0)!; + public all_op(): All_opContext { + return this.getRuleContext(0, All_opContext)!; } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { + if (i === undefined) { + return this.getRuleContexts(ColidContext); + } + + return this.getRuleContext(i, ColidContext); } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); + public DOT(): antlr.TerminalNode[]; + public DOT(i: number): antlr.TerminalNode | null; + public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.DOT); + } else { + return this.getToken(PostgreSqlParser.DOT, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_buffer_usage_limit; + return PostgreSqlParser.RULE_any_operator; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_buffer_usage_limit) { - listener.enterOpt_buffer_usage_limit(this); + if(listener.enterAny_operator) { + listener.enterAny_operator(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_buffer_usage_limit) { - listener.exitOpt_buffer_usage_limit(this); + if(listener.exitAny_operator) { + listener.exitAny_operator(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_buffer_usage_limit) { - return visitor.visitOpt_buffer_usage_limit(this); + if (visitor.visitAny_operator) { + return visitor.visitAny_operator(this); } else { return visitor.visitChildren(this); } @@ -95829,29 +71227,32 @@ export class Opt_buffer_usage_limitContext extends antlr.ParserRuleContext { } -export class Opt_fullContext extends antlr.ParserRuleContext { +export class Operator_with_argtypesContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FULL(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FULL, 0)!; + public any_operator(): Any_operatorContext { + return this.getRuleContext(0, Any_operatorContext)!; + } + public oper_argtypes(): Oper_argtypesContext { + return this.getRuleContext(0, Oper_argtypesContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_full; + return PostgreSqlParser.RULE_operator_with_argtypes; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_full) { - listener.enterOpt_full(this); + if(listener.enterOperator_with_argtypes) { + listener.enterOperator_with_argtypes(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_full) { - listener.exitOpt_full(this); + if(listener.exitOperator_with_argtypes) { + listener.exitOperator_with_argtypes(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_full) { - return visitor.visitOpt_full(this); + if (visitor.visitOperator_with_argtypes) { + return visitor.visitOperator_with_argtypes(this); } else { return visitor.visitChildren(this); } @@ -95859,29 +71260,56 @@ export class Opt_fullContext extends antlr.ParserRuleContext { } -export class Opt_freezeContext extends antlr.ParserRuleContext { +export class DostmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FREEZE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FREEZE, 0)!; + public KW_DO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DO, 0)!; + } + public sconst(): SconstContext[]; + public sconst(i: number): SconstContext | null; + public sconst(i?: number): SconstContext[] | SconstContext | null { + if (i === undefined) { + return this.getRuleContexts(SconstContext); + } + + return this.getRuleContext(i, SconstContext); + } + public KW_LANGUAGE(): antlr.TerminalNode[]; + public KW_LANGUAGE(i: number): antlr.TerminalNode | null; + public KW_LANGUAGE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_LANGUAGE); + } else { + return this.getToken(PostgreSqlParser.KW_LANGUAGE, i); + } + } + public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext[]; + public nonreservedword_or_sconst(i: number): Nonreservedword_or_sconstContext | null; + public nonreservedword_or_sconst(i?: number): Nonreservedword_or_sconstContext[] | Nonreservedword_or_sconstContext | null { + if (i === undefined) { + return this.getRuleContexts(Nonreservedword_or_sconstContext); + } + + return this.getRuleContext(i, Nonreservedword_or_sconstContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_freeze; + return PostgreSqlParser.RULE_dostmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_freeze) { - listener.enterOpt_freeze(this); + if(listener.enterDostmt) { + listener.enterDostmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_freeze) { - listener.exitOpt_freeze(this); + if(listener.exitDostmt) { + listener.exitDostmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_freeze) { - return visitor.visitOpt_freeze(this); + if (visitor.visitDostmt) { + return visitor.visitDostmt(this); } else { return visitor.visitChildren(this); } @@ -95889,35 +71317,77 @@ export class Opt_freezeContext extends antlr.ParserRuleContext { } -export class Opt_name_listContext extends antlr.ParserRuleContext { +export class CreatecaststmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + } + public KW_CAST(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CAST, 0)!; + } public OPEN_PAREN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public column_list(): Column_listContext { - return this.getRuleContext(0, Column_listContext)!; + public typename(): TypenameContext[]; + public typename(i: number): TypenameContext | null; + public typename(i?: number): TypenameContext[] | TypenameContext | null { + if (i === undefined) { + return this.getRuleContexts(TypenameContext); + } + + return this.getRuleContext(i, TypenameContext); + } + public KW_AS(): antlr.TerminalNode[]; + public KW_AS(i: number): antlr.TerminalNode | null; + public KW_AS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_AS); + } else { + return this.getToken(PostgreSqlParser.KW_AS, i); + } } public CLOSE_PAREN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } + public KW_WITHOUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); + } + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); + } + public function_with_argtypes(): Function_with_argtypesContext | null { + return this.getRuleContext(0, Function_with_argtypesContext); + } + public KW_INOUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INOUT, 0); + } + public KW_ASSIGNMENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ASSIGNMENT, 0); + } + public KW_IMPLICIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IMPLICIT, 0); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_name_list; + return PostgreSqlParser.RULE_createcaststmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_name_list) { - listener.enterOpt_name_list(this); + if(listener.enterCreatecaststmt) { + listener.enterCreatecaststmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_name_list) { - listener.exitOpt_name_list(this); + if(listener.exitCreatecaststmt) { + listener.exitCreatecaststmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_name_list) { - return visitor.visitOpt_name_list(this); + if (visitor.visitCreatecaststmt) { + return visitor.visitCreatecaststmt(this); } else { return visitor.visitChildren(this); } @@ -95925,32 +71395,32 @@ export class Opt_name_listContext extends antlr.ParserRuleContext { } -export class Vacuum_relationContext extends antlr.ParserRuleContext { +export class Opt_if_existsContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public table_name(): Table_nameContext { - return this.getRuleContext(0, Table_nameContext)!; + public KW_IF(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_IF, 0)!; } - public opt_name_list(): Opt_name_listContext | null { - return this.getRuleContext(0, Opt_name_listContext); + public KW_EXISTS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EXISTS, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_vacuum_relation; + return PostgreSqlParser.RULE_opt_if_exists; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVacuum_relation) { - listener.enterVacuum_relation(this); + if(listener.enterOpt_if_exists) { + listener.enterOpt_if_exists(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVacuum_relation) { - listener.exitVacuum_relation(this); + if(listener.exitOpt_if_exists) { + listener.exitOpt_if_exists(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVacuum_relation) { - return visitor.visitVacuum_relation(this); + if (visitor.visitOpt_if_exists) { + return visitor.visitOpt_if_exists(this); } else { return visitor.visitChildren(this); } @@ -95958,74 +71428,71 @@ export class Vacuum_relationContext extends antlr.ParserRuleContext { } -export class Vacuum_relation_listContext extends antlr.ParserRuleContext { +export class CreatetransformstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public vacuum_relation(): Vacuum_relationContext[]; - public vacuum_relation(i: number): Vacuum_relationContext | null; - public vacuum_relation(i?: number): Vacuum_relationContext[] | Vacuum_relationContext | null { - if (i === undefined) { - return this.getRuleContexts(Vacuum_relationContext); - } - - return this.getRuleContext(i, Vacuum_relationContext); + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_TRANSFORM(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_vacuum_relation_list; + public KW_FOR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOR, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterVacuum_relation_list) { - listener.enterVacuum_relation_list(this); - } + public typename(): TypenameContext { + return this.getRuleContext(0, TypenameContext)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitVacuum_relation_list) { - listener.exitVacuum_relation_list(this); - } + public KW_LANGUAGE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0)!; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitVacuum_relation_list) { - return visitor.visitVacuum_relation_list(this); - } else { - return visitor.visitChildren(this); - } + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } -} - + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); + } + public sql_with_function(): Sql_with_functionContext[]; + public sql_with_function(i: number): Sql_with_functionContext | null; + public sql_with_function(i?: number): Sql_with_functionContext[] | Sql_with_functionContext | null { + if (i === undefined) { + return this.getRuleContexts(Sql_with_functionContext); + } -export class Opt_vacuum_relation_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, Sql_with_functionContext); } - public vacuum_relation_list(): Vacuum_relation_listContext { - return this.getRuleContext(0, Vacuum_relation_listContext)!; + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); + } + public opt_or_replace(): Opt_or_replaceContext | null { + return this.getRuleContext(0, Opt_or_replaceContext); + } + public COMMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.COMMA, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_vacuum_relation_list; + return PostgreSqlParser.RULE_createtransformstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_vacuum_relation_list) { - listener.enterOpt_vacuum_relation_list(this); + if(listener.enterCreatetransformstmt) { + listener.enterCreatetransformstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_vacuum_relation_list) { - listener.exitOpt_vacuum_relation_list(this); + if(listener.exitCreatetransformstmt) { + listener.exitCreatetransformstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_vacuum_relation_list) { - return visitor.visitOpt_vacuum_relation_list(this); + if (visitor.visitCreatetransformstmt) { + return visitor.visitCreatetransformstmt(this); } else { return visitor.visitChildren(this); } @@ -96033,50 +71500,38 @@ export class Opt_vacuum_relation_listContext extends antlr.ParserRuleContext { } -export class ExplainstmtContext extends antlr.ParserRuleContext { +export class Sql_with_functionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_EXPLAIN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXPLAIN, 0)!; - } - public explainablestmt(): ExplainablestmtContext { - return this.getRuleContext(0, ExplainablestmtContext)!; - } - public analyze_keyword(): Analyze_keywordContext | null { - return this.getRuleContext(0, Analyze_keywordContext); - } - public opt_verbose(): Opt_verboseContext | null { - return this.getRuleContext(0, Opt_verboseContext); - } - public KW_VERBOSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VERBOSE, 0); + public KW_SQL(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SQL, 0)!; } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_WITH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WITH, 0)!; } - public explain_option_list(): Explain_option_listContext | null { - return this.getRuleContext(0, Explain_option_listContext); + public KW_FUNCTION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public function_with_argtypes(): Function_with_argtypesContext { + return this.getRuleContext(0, Function_with_argtypesContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_explainstmt; + return PostgreSqlParser.RULE_sql_with_function; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExplainstmt) { - listener.enterExplainstmt(this); + if(listener.enterSql_with_function) { + listener.enterSql_with_function(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExplainstmt) { - listener.exitExplainstmt(this); + if(listener.exitSql_with_function) { + listener.exitSql_with_function(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExplainstmt) { - return visitor.visitExplainstmt(this); + if (visitor.visitSql_with_function) { + return visitor.visitSql_with_function(this); } else { return visitor.visitChildren(this); } @@ -96084,72 +71539,57 @@ export class ExplainstmtContext extends antlr.ParserRuleContext { } -export class ExplainablestmtContext extends antlr.ParserRuleContext { +export class ReindexstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public selectstmt(): SelectstmtContext | null { - return this.getRuleContext(0, SelectstmtContext); - } - public insertstmt(): InsertstmtContext | null { - return this.getRuleContext(0, InsertstmtContext); + public KW_REINDEX(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_REINDEX, 0)!; } - public updatestmt(): UpdatestmtContext | null { - return this.getRuleContext(0, UpdatestmtContext); + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public deletestmt(): DeletestmtContext | null { - return this.getRuleContext(0, DeletestmtContext); + public KW_VERBOSE(): antlr.TerminalNode[]; + public KW_VERBOSE(i: number): antlr.TerminalNode | null; + public KW_VERBOSE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_VERBOSE); + } else { + return this.getToken(PostgreSqlParser.KW_VERBOSE, i); + } } - public declarecursorstmt(): DeclarecursorstmtContext | null { - return this.getRuleContext(0, DeclarecursorstmtContext); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public createasstmt(): CreateasstmtContext | null { - return this.getRuleContext(0, CreateasstmtContext); + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INDEX, 0); } - public creatematviewstmt(): CreatematviewstmtContext | null { - return this.getRuleContext(0, CreatematviewstmtContext); + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } - public refreshmatviewstmt(): RefreshmatviewstmtContext | null { - return this.getRuleContext(0, RefreshmatviewstmtContext); + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } - public executestmt(): ExecutestmtContext | null { - return this.getRuleContext(0, ExecutestmtContext); + public table_name(): Table_nameContext | null { + return this.getRuleContext(0, Table_nameContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_explainablestmt; + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExplainablestmt) { - listener.enterExplainablestmt(this); - } + public schema_name(): Schema_nameContext | null { + return this.getRuleContext(0, Schema_nameContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExplainablestmt) { - listener.exitExplainablestmt(this); - } + public KW_SYSTEM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SYSTEM, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExplainablestmt) { - return visitor.visitExplainablestmt(this); - } else { - return visitor.visitChildren(this); - } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } -} - - -export class Explain_option_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_DATABASE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATABASE, 0); } - public explain_option_elem(): Explain_option_elemContext[]; - public explain_option_elem(i: number): Explain_option_elemContext | null; - public explain_option_elem(i?: number): Explain_option_elemContext[] | Explain_option_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Explain_option_elemContext); - } - - return this.getRuleContext(i, Explain_option_elemContext); + public database_name(): Database_nameContext | null { + return this.getRuleContext(0, Database_nameContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -96160,22 +71600,25 @@ export class Explain_option_listContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.COMMA, i); } } + public KW_CONCURRENTLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONCURRENTLY, 0); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_explain_option_list; + return PostgreSqlParser.RULE_reindexstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExplain_option_list) { - listener.enterExplain_option_list(this); + if(listener.enterReindexstmt) { + listener.enterReindexstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExplain_option_list) { - listener.exitExplain_option_list(this); + if(listener.exitReindexstmt) { + listener.exitReindexstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExplain_option_list) { - return visitor.visitExplain_option_list(this); + if (visitor.visitReindexstmt) { + return visitor.visitReindexstmt(this); } else { return visitor.visitChildren(this); } @@ -96183,32 +71626,41 @@ export class Explain_option_listContext extends antlr.ParserRuleContext { } -export class Explain_option_elemContext extends antlr.ParserRuleContext { +export class AltertblspcstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public explain_option_name(): Explain_option_nameContext { - return this.getRuleContext(0, Explain_option_nameContext)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public opttablespace(): OpttablespaceContext { + return this.getRuleContext(0, OpttablespaceContext)!; + } + public reloptions(): ReloptionsContext { + return this.getRuleContext(0, ReloptionsContext)!; + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public explain_option_arg(): Explain_option_argContext | null { - return this.getRuleContext(0, Explain_option_argContext); + public KW_RESET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESET, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_explain_option_elem; + return PostgreSqlParser.RULE_altertblspcstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExplain_option_elem) { - listener.enterExplain_option_elem(this); + if(listener.enterAltertblspcstmt) { + listener.enterAltertblspcstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExplain_option_elem) { - listener.exitExplain_option_elem(this); + if(listener.exitAltertblspcstmt) { + listener.exitAltertblspcstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExplain_option_elem) { - return visitor.visitExplain_option_elem(this); + if (visitor.visitAltertblspcstmt) { + return visitor.visitAltertblspcstmt(this); } else { return visitor.visitChildren(this); } @@ -96216,314 +71668,254 @@ export class Explain_option_elemContext extends antlr.ParserRuleContext { } -export class Explain_option_nameContext extends antlr.ParserRuleContext { +export class RenamestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public nonreservedword(): NonreservedwordContext | null { - return this.getRuleContext(0, NonreservedwordContext); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public analyze_keyword(): Analyze_keywordContext | null { - return this.getRuleContext(0, Analyze_keywordContext); + public KW_RENAME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RENAME, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_explain_option_name; + public KW_TO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TO, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExplain_option_name) { - listener.enterExplain_option_name(this); + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { + if (i === undefined) { + return this.getRuleContexts(ColidContext); } + + return this.getRuleContext(i, ColidContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExplain_option_name) { - listener.exitExplain_option_name(this); - } + public KW_AGGREGATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExplain_option_name) { - return visitor.visitExplain_option_name(this); - } else { - return visitor.visitChildren(this); - } + public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { + return this.getRuleContext(0, Aggregate_with_argtypesContext); } -} - - -export class Explain_option_argContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_ROUTINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); } - public opt_boolean_or_string(): Opt_boolean_or_stringContext | null { - return this.getRuleContext(0, Opt_boolean_or_stringContext); + public routine_with_argtypes(): Routine_with_argtypesContext | null { + return this.getRuleContext(0, Routine_with_argtypesContext); } - public numericonly(): NumericonlyContext | null { - return this.getRuleContext(0, NumericonlyContext); + public KW_DATABASE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATABASE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_explain_option_arg; + public database_name(): Database_nameContext | null { + return this.getRuleContext(0, Database_nameContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExplain_option_arg) { - listener.enterExplain_option_arg(this); - } + public database_name_create(): Database_name_createContext | null { + return this.getRuleContext(0, Database_name_createContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExplain_option_arg) { - listener.exitExplain_option_arg(this); - } + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExplain_option_arg) { - return visitor.visitExplain_option_arg(this); - } else { - return visitor.visitChildren(this); - } + public KW_DOMAIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); } -} - - -export class PreparestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_STATISTICS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); } - public KW_PREPARE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PREPARE, 0)!; + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public KW_CONVERSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONVERSION, 0); } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; + public KW_COLLATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLLATION, 0); } - public preparablestmt(): PreparablestmtContext { - return this.getRuleContext(0, PreparablestmtContext)!; + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); } - public prep_type_clause(): Prep_type_clauseContext | null { - return this.getRuleContext(0, Prep_type_clauseContext); + public function_with_argtypes(): Function_with_argtypesContext | null { + return this.getRuleContext(0, Function_with_argtypesContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_preparestmt; + public function_name_create(): Function_name_createContext | null { + return this.getRuleContext(0, Function_name_createContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPreparestmt) { - listener.enterPreparestmt(this); - } + public KW_OPERATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPreparestmt) { - listener.exitPreparestmt(this); - } + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPreparestmt) { - return visitor.visitPreparestmt(this); - } else { - return visitor.visitChildren(this); - } + public KW_CLASS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CLASS, 0); } -} - - -export class Prep_type_clauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_FAMILY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FAMILY, 0); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); } - public type_list(): Type_listContext { - return this.getRuleContext(0, Type_listContext)!; + public procedure_with_argtypes(): Procedure_with_argtypesContext | null { + return this.getRuleContext(0, Procedure_with_argtypesContext); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public procedure_name_create(): Procedure_name_createContext | null { + return this.getRuleContext(0, Procedure_name_createContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_prep_type_clause; + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPrep_type_clause) { - listener.enterPrep_type_clause(this); - } + public schema_name(): Schema_nameContext | null { + return this.getRuleContext(0, Schema_nameContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPrep_type_clause) { - listener.exitPrep_type_clause(this); - } + public schema_name_create(): Schema_name_createContext | null { + return this.getRuleContext(0, Schema_name_createContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPrep_type_clause) { - return visitor.visitPrep_type_clause(this); - } else { - return visitor.visitChildren(this); - } + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } -} - - -export class PreparablestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_SEQUENCE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); + } + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INDEX, 0); + } + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); + } + public KW_VIEW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VIEW, 0); + } + public view_name(): View_nameContext | null { + return this.getRuleContext(0, View_nameContext); } - public selectstmt(): SelectstmtContext | null { - return this.getRuleContext(0, SelectstmtContext); + public view_name_create(): View_name_createContext | null { + return this.getRuleContext(0, View_name_createContext); } - public insertstmt(): InsertstmtContext | null { - return this.getRuleContext(0, InsertstmtContext); + public KW_MATERIALIZED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); } - public updatestmt(): UpdatestmtContext | null { - return this.getRuleContext(0, UpdatestmtContext); + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } - public deletestmt(): DeletestmtContext | null { - return this.getRuleContext(0, DeletestmtContext); + public relation_expr(): Relation_exprContext | null { + return this.getRuleContext(0, Relation_exprContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_preparablestmt; + public table_name_create(): Table_name_createContext | null { + return this.getRuleContext(0, Table_name_createContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPreparablestmt) { - listener.enterPreparablestmt(this); - } + public KW_FOREIGN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPreparablestmt) { - listener.exitPreparablestmt(this); - } + public column_name(): Column_nameContext | null { + return this.getRuleContext(0, Column_nameContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPreparablestmt) { - return visitor.visitPreparablestmt(this); - } else { - return visitor.visitChildren(this); - } + public column_name_create(): Column_name_createContext | null { + return this.getRuleContext(0, Column_name_createContext); } -} - - -export class ExecutestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_COLUMN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLUMN, 0); } - public KW_EXECUTE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXECUTE, 0)!; + public KW_CONSTRAINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ON, 0); } - public execute_param_clause(): Execute_param_clauseContext | null { - return this.getRuleContext(0, Execute_param_clauseContext); + public KW_RULE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RULE, 0); } - public KW_CREATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CREATE, 0); + public KW_TRIGGER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); + public KW_POLICY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_POLICY, 0); } - public create_as_target(): Create_as_targetContext | null { - return this.getRuleContext(0, Create_as_targetContext); + public KW_DATA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATA, 0); } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); + public KW_WRAPPER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); } - public opttemp(): OpttempContext | null { - return this.getRuleContext(0, OpttempContext); + public KW_LANGUAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); } - public opt_if_not_exists(): Opt_if_not_existsContext | null { - return this.getRuleContext(0, Opt_if_not_existsContext); + public KW_PUBLICATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); } - public opt_with_data(): Opt_with_dataContext | null { - return this.getRuleContext(0, Opt_with_dataContext); + public KW_SERVER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SERVER, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_executestmt; + public KW_SUBSCRIPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExecutestmt) { - listener.enterExecutestmt(this); - } + public KW_EVENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EVENT, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExecutestmt) { - listener.exitExecutestmt(this); - } + public KW_PROCEDURAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURAL, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExecutestmt) { - return visitor.visitExecutestmt(this); - } else { - return visitor.visitChildren(this); + public rolespec(): RolespecContext[]; + public rolespec(i: number): RolespecContext | null; + public rolespec(i?: number): RolespecContext[] | RolespecContext | null { + if (i === undefined) { + return this.getRuleContexts(RolespecContext); } - } -} - -export class Execute_param_clauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, RolespecContext); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_USER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USER, 0); } - public expr_list(): Expr_listContext { - return this.getRuleContext(0, Expr_listContext)!; + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLE, 0); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public KW_GROUP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GROUP, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_execute_param_clause; + public opttablespace(): OpttablespaceContext | null { + return this.getRuleContext(0, OpttablespaceContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExecute_param_clause) { - listener.enterExecute_param_clause(this); - } + public tablespace_name_create(): Tablespace_name_createContext | null { + return this.getRuleContext(0, Tablespace_name_createContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExecute_param_clause) { - listener.exitExecute_param_clause(this); - } + public KW_TEXT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEXT, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExecute_param_clause) { - return visitor.visitExecute_param_clause(this); - } else { - return visitor.visitChildren(this); - } + public KW_SEARCH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEARCH, 0); } -} - - -export class DeallocatestmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_PARSER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARSER, 0); } - public KW_DEALLOCATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DEALLOCATE, 0)!; + public KW_DICTIONARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); + public KW_TEMPLATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); + public KW_CONFIGURATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); } - public KW_PREPARE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PREPARE, 0); + public KW_ATTRIBUTE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ATTRIBUTE, 0); + } + public opt_drop_behavior(): Opt_drop_behaviorContext | null { + return this.getRuleContext(0, Opt_drop_behaviorContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_deallocatestmt; + return PostgreSqlParser.RULE_renamestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDeallocatestmt) { - listener.enterDeallocatestmt(this); + if(listener.enterRenamestmt) { + listener.enterRenamestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDeallocatestmt) { - listener.exitDeallocatestmt(this); + if(listener.exitRenamestmt) { + listener.exitRenamestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDeallocatestmt) { - return visitor.visitDeallocatestmt(this); + if (visitor.visitRenamestmt) { + return visitor.visitRenamestmt(this); } else { return visitor.visitChildren(this); } @@ -96531,92 +71923,92 @@ export class DeallocatestmtContext extends antlr.ParserRuleContext { } -export class InsertstmtContext extends antlr.ParserRuleContext { +export class AlterobjectdependsstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_insertstmt; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public override copyFrom(ctx: InsertstmtContext): void { - super.copyFrom(ctx); + public KW_DEPENDS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DEPENDS, 0)!; } -} -export class InsertStatementContext extends InsertstmtContext { - public constructor(ctx: InsertstmtContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); + public KW_ON(): antlr.TerminalNode[]; + public KW_ON(i: number): antlr.TerminalNode | null; + public KW_ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_ON); + } else { + return this.getToken(PostgreSqlParser.KW_ON, i); + } } - public KW_INSERT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INSERT, 0)!; + public KW_EXTENSION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EXTENSION, 0)!; } - public KW_INTO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INTO, 0)!; + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { + if (i === undefined) { + return this.getRuleContexts(ColidContext); + } + + return this.getRuleContext(i, ColidContext); } - public insert_target(): Insert_targetContext { - return this.getRuleContext(0, Insert_targetContext)!; + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); } - public insert_rest(): Insert_restContext { - return this.getRuleContext(0, Insert_restContext)!; + public function_with_argtypes(): Function_with_argtypesContext | null { + return this.getRuleContext(0, Function_with_argtypesContext); } - public opt_with_clause(): Opt_with_clauseContext | null { - return this.getRuleContext(0, Opt_with_clauseContext); + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); } - public opt_on_conflict(): Opt_on_conflictContext | null { - return this.getRuleContext(0, Opt_on_conflictContext); + public procedure_with_argtypes(): Procedure_with_argtypesContext | null { + return this.getRuleContext(0, Procedure_with_argtypesContext); } - public returning_clause(): Returning_clauseContext | null { - return this.getRuleContext(0, Returning_clauseContext); + public KW_ROUTINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterInsertStatement) { - listener.enterInsertStatement(this); - } + public routine_with_argtypes(): Routine_with_argtypesContext | null { + return this.getRuleContext(0, Routine_with_argtypesContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitInsertStatement) { - listener.exitInsertStatement(this); - } + public KW_TRIGGER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitInsertStatement) { - return visitor.visitInsertStatement(this); - } else { - return visitor.visitChildren(this); - } + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } -} - - -export class Insert_targetContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_MATERIALIZED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); } - public table_name(): Table_nameContext { - return this.getRuleContext(0, Table_nameContext)!; + public KW_VIEW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VIEW, 0); } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); + public view_name(): View_nameContext | null { + return this.getRuleContext(0, View_nameContext); } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); + public KW_INDEX(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INDEX, 0); + } + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_insert_target; + return PostgreSqlParser.RULE_alterobjectdependsstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterInsert_target) { - listener.enterInsert_target(this); + if(listener.enterAlterobjectdependsstmt) { + listener.enterAlterobjectdependsstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitInsert_target) { - listener.exitInsert_target(this); + if(listener.exitAlterobjectdependsstmt) { + listener.exitAlterobjectdependsstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitInsert_target) { - return visitor.visitInsert_target(this); + if (visitor.visitAlterobjectdependsstmt) { + return visitor.visitAlterobjectdependsstmt(this); } else { return visitor.visitChildren(this); } @@ -96624,215 +72016,146 @@ export class Insert_targetContext extends antlr.ParserRuleContext { } -export class Insert_restContext extends antlr.ParserRuleContext { +export class AlterobjectschemastmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public default_values_or_values(): Default_values_or_valuesContext | null { - return this.getRuleContext(0, Default_values_or_valuesContext); - } - public selectstmt(): SelectstmtContext | null { - return this.getRuleContext(0, SelectstmtContext); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public insert_column_list(): Insert_column_listContext | null { - return this.getRuleContext(0, Insert_column_listContext); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_SET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SET, 0)!; } - public KW_OVERRIDING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OVERRIDING, 0); + public KW_SCHEMA(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0)!; } - public override_kind(): Override_kindContext | null { - return this.getRuleContext(0, Override_kindContext); + public schema_name(): Schema_nameContext { + return this.getRuleContext(0, Schema_nameContext)!; } - public KW_VALUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALUE, 0); + public KW_AGGREGATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_insert_rest; + public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { + return this.getRuleContext(0, Aggregate_with_argtypesContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterInsert_rest) { - listener.enterInsert_rest(this); - } + public KW_EXTENSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXTENSION, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitInsert_rest) { - listener.exitInsert_rest(this); - } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitInsert_rest) { - return visitor.visitInsert_rest(this); - } else { - return visitor.visitChildren(this); - } + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); } -} - - -export class Override_kindContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public function_with_argtypes(): Function_with_argtypesContext | null { + return this.getRuleContext(0, Function_with_argtypesContext); } - public KW_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USER, 0); + public KW_OPERATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); } - public KW_SYSTEM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SYSTEM, 0); + public operator_with_argtypes(): Operator_with_argtypesContext | null { + return this.getRuleContext(0, Operator_with_argtypesContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_override_kind; + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOverride_kind) { - listener.enterOverride_kind(this); - } + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOverride_kind) { - listener.exitOverride_kind(this); - } + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOverride_kind) { - return visitor.visitOverride_kind(this); - } else { - return visitor.visitChildren(this); - } + public procedure_with_argtypes(): Procedure_with_argtypesContext | null { + return this.getRuleContext(0, Procedure_with_argtypesContext); } -} - - -export class Insert_column_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_ROUTINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); } - public insert_column_item(): Insert_column_itemContext[]; - public insert_column_item(i: number): Insert_column_itemContext | null; - public insert_column_item(i?: number): Insert_column_itemContext[] | Insert_column_itemContext | null { - if (i === undefined) { - return this.getRuleContexts(Insert_column_itemContext); - } - - return this.getRuleContext(i, Insert_column_itemContext); + public routine_with_argtypes(): Routine_with_argtypesContext | null { + return this.getRuleContext(0, Routine_with_argtypesContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_SEQUENCE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_insert_column_list; + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterInsert_column_list) { - listener.enterInsert_column_list(this); - } + public KW_VIEW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VIEW, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitInsert_column_list) { - listener.exitInsert_column_list(this); - } + public view_name(): View_nameContext | null { + return this.getRuleContext(0, View_nameContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitInsert_column_list) { - return visitor.visitInsert_column_list(this); - } else { - return visitor.visitChildren(this); - } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } -} - - -export class Insert_column_itemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public relation_expr(): Relation_exprContext | null { + return this.getRuleContext(0, Relation_exprContext); } - public column_name(): Column_nameContext { - return this.getRuleContext(0, Column_nameContext)!; + public KW_CLASS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CLASS, 0); } - public opt_indirection(): Opt_indirectionContext { - return this.getRuleContext(0, Opt_indirectionContext)!; + public KW_FAMILY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FAMILY, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_insert_column_item; + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterInsert_column_item) { - listener.enterInsert_column_item(this); - } + public KW_MATERIALIZED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitInsert_column_item) { - listener.exitInsert_column_item(this); - } + public KW_FOREIGN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitInsert_column_item) { - return visitor.visitInsert_column_item(this); - } else { - return visitor.visitChildren(this); - } + public KW_TEXT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEXT, 0); } -} - - -export class Opt_on_conflictContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_SEARCH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEARCH, 0); } - public KW_ON(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ON, 0)!; + public KW_COLLATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLLATION, 0); } - public KW_CONFLICT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CONFLICT, 0)!; + public KW_CONVERSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONVERSION, 0); } - public KW_DO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DO, 0)!; + public KW_DOMAIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); } - public KW_UPDATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UPDATE, 0); + public KW_STATISTICS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); } - public set_clause_list(): Set_clause_listContext | null { - return this.getRuleContext(0, Set_clause_listContext); + public KW_PARSER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARSER, 0); } - public KW_NOTHING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOTHING, 0); + public KW_DICTIONARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); } - public opt_conf_expr(): Opt_conf_exprContext | null { - return this.getRuleContext(0, Opt_conf_exprContext); + public KW_TEMPLATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); } - public where_clause(): Where_clauseContext | null { - return this.getRuleContext(0, Where_clauseContext); + public KW_CONFIGURATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_on_conflict; + return PostgreSqlParser.RULE_alterobjectschemastmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_on_conflict) { - listener.enterOpt_on_conflict(this); + if(listener.enterAlterobjectschemastmt) { + listener.enterAlterobjectschemastmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_on_conflict) { - listener.exitOpt_on_conflict(this); + if(listener.exitAlterobjectschemastmt) { + listener.exitAlterobjectschemastmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_on_conflict) { - return visitor.visitOpt_on_conflict(this); + if (visitor.visitAlterobjectschemastmt) { + return visitor.visitAlterobjectschemastmt(this); } else { return visitor.visitChildren(this); } @@ -96840,47 +72163,41 @@ export class Opt_on_conflictContext extends antlr.ParserRuleContext { } -export class Opt_conf_exprContext extends antlr.ParserRuleContext { +export class AlteroperatorstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public index_params(): Index_paramsContext | null { - return this.getRuleContext(0, Index_paramsContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public where_clause(): Where_clauseContext | null { - return this.getRuleContext(0, Where_clauseContext); + public KW_OPERATOR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0)!; } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); + public operator_with_argtypes(): Operator_with_argtypesContext { + return this.getRuleContext(0, Operator_with_argtypesContext)!; } - public KW_CONSTRAINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); + public KW_SET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SET, 0)!; } - public name(): NameContext | null { - return this.getRuleContext(0, NameContext); + public operator_def_list(): Operator_def_listContext { + return this.getRuleContext(0, Operator_def_listContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_conf_expr; + return PostgreSqlParser.RULE_alteroperatorstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_conf_expr) { - listener.enterOpt_conf_expr(this); + if(listener.enterAlteroperatorstmt) { + listener.enterAlteroperatorstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_conf_expr) { - listener.exitOpt_conf_expr(this); + if(listener.exitAlteroperatorstmt) { + listener.exitAlteroperatorstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_conf_expr) { - return visitor.visitOpt_conf_expr(this); + if (visitor.visitAlteroperatorstmt) { + return visitor.visitAlteroperatorstmt(this); } else { return visitor.visitChildren(this); } @@ -96888,32 +72205,50 @@ export class Opt_conf_exprContext extends antlr.ParserRuleContext { } -export class Returning_clauseContext extends antlr.ParserRuleContext { +export class Operator_def_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_RETURNING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_RETURNING, 0)!; + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public target_list(): Target_listContext { - return this.getRuleContext(0, Target_listContext)!; + public operator_def_elem(): Operator_def_elemContext[]; + public operator_def_elem(i: number): Operator_def_elemContext | null; + public operator_def_elem(i?: number): Operator_def_elemContext[] | Operator_def_elemContext | null { + if (i === undefined) { + return this.getRuleContexts(Operator_def_elemContext); + } + + return this.getRuleContext(i, Operator_def_elemContext); + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_returning_clause; + return PostgreSqlParser.RULE_operator_def_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReturning_clause) { - listener.enterReturning_clause(this); + if(listener.enterOperator_def_list) { + listener.enterOperator_def_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReturning_clause) { - listener.exitReturning_clause(this); + if(listener.exitOperator_def_list) { + listener.exitOperator_def_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReturning_clause) { - return visitor.visitReturning_clause(this); + if (visitor.visitOperator_def_list) { + return visitor.visitOperator_def_list(this); } else { return visitor.visitChildren(this); } @@ -96921,47 +72256,50 @@ export class Returning_clauseContext extends antlr.ParserRuleContext { } -export class DeletestmtContext extends antlr.ParserRuleContext { +export class Operator_def_elemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_DELETE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DELETE, 0)!; + public collabel(): CollabelContext { + return this.getRuleContext(0, CollabelContext)!; } - public KW_FROM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FROM, 0)!; + public EQUAL(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.EQUAL, 0)!; } - public relation_expr_opt_alias(): Relation_expr_opt_aliasContext { - return this.getRuleContext(0, Relation_expr_opt_aliasContext)!; + public KW_NONE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NONE, 0); + } + public func_type(): Func_typeContext | null { + return this.getRuleContext(0, Func_typeContext); } - public opt_with_clause(): Opt_with_clauseContext | null { - return this.getRuleContext(0, Opt_with_clauseContext); + public reserved_keyword(): Reserved_keywordContext | null { + return this.getRuleContext(0, Reserved_keywordContext); } - public using_clause(): Using_clauseContext | null { - return this.getRuleContext(0, Using_clauseContext); + public qual_all_op(): Qual_all_opContext | null { + return this.getRuleContext(0, Qual_all_opContext); } - public where_or_current_clause(): Where_or_current_clauseContext | null { - return this.getRuleContext(0, Where_or_current_clauseContext); + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); } - public returning_clause(): Returning_clauseContext | null { - return this.getRuleContext(0, Returning_clauseContext); + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_deletestmt; + return PostgreSqlParser.RULE_operator_def_elem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDeletestmt) { - listener.enterDeletestmt(this); + if(listener.enterOperator_def_elem) { + listener.enterOperator_def_elem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDeletestmt) { - listener.exitDeletestmt(this); + if(listener.exitOperator_def_elem) { + listener.exitOperator_def_elem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDeletestmt) { - return visitor.visitDeletestmt(this); + if (visitor.visitOperator_def_elem) { + return visitor.visitOperator_def_elem(this); } else { return visitor.visitChildren(this); } @@ -96969,32 +72307,41 @@ export class DeletestmtContext extends antlr.ParserRuleContext { } -export class Using_clauseContext extends antlr.ParserRuleContext { +export class AltertypestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public from_list(): From_listContext { - return this.getRuleContext(0, From_listContext)!; + public KW_TYPE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TYPE, 0)!; + } + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; + } + public KW_SET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SET, 0)!; + } + public operator_def_list(): Operator_def_listContext { + return this.getRuleContext(0, Operator_def_listContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_using_clause; + return PostgreSqlParser.RULE_altertypestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterUsing_clause) { - listener.enterUsing_clause(this); + if(listener.enterAltertypestmt) { + listener.enterAltertypestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitUsing_clause) { - listener.exitUsing_clause(this); + if(listener.exitAltertypestmt) { + listener.exitAltertypestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitUsing_clause) { - return visitor.visitUsing_clause(this); + if (visitor.visitAltertypestmt) { + return visitor.visitAltertypestmt(this); } else { return visitor.visitChildren(this); } @@ -97002,185 +72349,164 @@ export class Using_clauseContext extends antlr.ParserRuleContext { } -export class LockstmtContext extends antlr.ParserRuleContext { +export class AlterownerstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_LOCK(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_LOCK, 0)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public relation_expr_list(): Relation_expr_listContext { - return this.getRuleContext(0, Relation_expr_listContext)!; + public KW_OPERATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); } - public opt_table(): Opt_tableContext | null { - return this.getRuleContext(0, Opt_tableContext); + public any_name(): Any_nameContext | null { + return this.getRuleContext(0, Any_nameContext); } - public opt_lock(): Opt_lockContext | null { - return this.getRuleContext(0, Opt_lockContext); + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); } - public opt_nowait(): Opt_nowaitContext | null { - return this.getRuleContext(0, Opt_nowaitContext); + public KW_OWNER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_OWNER, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_lockstmt; + public KW_TO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TO, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterLockstmt) { - listener.enterLockstmt(this); - } + public rolespec(): RolespecContext { + return this.getRuleContext(0, RolespecContext)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitLockstmt) { - listener.exitLockstmt(this); - } + public KW_CLASS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CLASS, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitLockstmt) { - return visitor.visitLockstmt(this); - } else { - return visitor.visitChildren(this); - } + public KW_FAMILY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FAMILY, 0); } -} - - -export class Opt_lockContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_AGGREGATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AGGREGATE, 0); } - public KW_IN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_IN, 0)!; + public aggregate_with_argtypes(): Aggregate_with_argtypesContext | null { + return this.getRuleContext(0, Aggregate_with_argtypesContext); } - public lock_type(): Lock_typeContext { - return this.getRuleContext(0, Lock_typeContext)!; + public KW_DATABASE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATABASE, 0); } - public KW_MODE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_MODE, 0)!; + public database_name(): Database_nameContext | null { + return this.getRuleContext(0, Database_nameContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_lock; + public KW_FUNCTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FUNCTION, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_lock) { - listener.enterOpt_lock(this); - } + public function_with_argtypes(): Function_with_argtypesContext | null { + return this.getRuleContext(0, Function_with_argtypesContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_lock) { - listener.exitOpt_lock(this); - } + public KW_LANGUAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LANGUAGE, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_lock) { - return visitor.visitOpt_lock(this); - } else { - return visitor.visitChildren(this); - } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } -} - - -export class Lock_typeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_LARGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LARGE, 0); } - public KW_ACCESS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ACCESS, 0); + public KW_OBJECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OBJECT, 0); } - public KW_SHARE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SHARE, 0); + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); } - public KW_EXCLUSIVE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXCLUSIVE, 0); + public operator_with_argtypes(): Operator_with_argtypesContext | null { + return this.getRuleContext(0, Operator_with_argtypesContext); } - public KW_ROW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROW, 0); + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); } - public KW_UPDATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UPDATE, 0); + public procedure_with_argtypes(): Procedure_with_argtypesContext | null { + return this.getRuleContext(0, Procedure_with_argtypesContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_lock_type; + public KW_ROUTINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterLock_type) { - listener.enterLock_type(this); - } + public routine_with_argtypes(): Routine_with_argtypesContext | null { + return this.getRuleContext(0, Routine_with_argtypesContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitLock_type) { - listener.exitLock_type(this); - } + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitLock_type) { - return visitor.visitLock_type(this); - } else { - return visitor.visitChildren(this); - } + public schema_name(): Schema_nameContext | null { + return this.getRuleContext(0, Schema_nameContext); } -} - - -export class Opt_nowaitContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public opttablespace(): OpttablespaceContext | null { + return this.getRuleContext(0, OpttablespaceContext); } - public KW_NOWAIT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_NOWAIT, 0)!; + public KW_PROCEDURAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURAL, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_nowait; + public KW_TEXT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEXT, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_nowait) { - listener.enterOpt_nowait(this); - } + public KW_SEARCH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEARCH, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_nowait) { - listener.exitOpt_nowait(this); - } + public KW_COLLATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLLATION, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_nowait) { - return visitor.visitOpt_nowait(this); - } else { - return visitor.visitChildren(this); - } + public KW_CONVERSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONVERSION, 0); } -} - - -export class Opt_nowait_or_skipContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_DOMAIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DOMAIN, 0); } - public KW_NOWAIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOWAIT, 0); + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); } - public KW_SKIP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SKIP, 0); + public KW_STATISTICS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); } - public KW_LOCKED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LOCKED, 0); + public KW_DICTIONARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0); + } + public KW_CONFIGURATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0); + } + public KW_SERVER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SERVER, 0); + } + public KW_PUBLICATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); + } + public KW_SUBSCRIPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0); + } + public KW_FOREIGN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); + } + public KW_DATA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DATA, 0); + } + public KW_WRAPPER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); + } + public KW_EVENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EVENT, 0); + } + public KW_TRIGGER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_nowait_or_skip; + return PostgreSqlParser.RULE_alterownerstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_nowait_or_skip) { - listener.enterOpt_nowait_or_skip(this); + if(listener.enterAlterownerstmt) { + listener.enterAlterownerstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_nowait_or_skip) { - listener.exitOpt_nowait_or_skip(this); + if(listener.exitAlterownerstmt) { + listener.exitAlterownerstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_nowait_or_skip) { - return visitor.visitOpt_nowait_or_skip(this); + if (visitor.visitAlterownerstmt) { + return visitor.visitAlterownerstmt(this); } else { return visitor.visitChildren(this); } @@ -97188,50 +72514,53 @@ export class Opt_nowait_or_skipContext extends antlr.ParserRuleContext { } -export class UpdatestmtContext extends antlr.ParserRuleContext { +export class CreatepublicationstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_UPDATE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_UPDATE, 0)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public relation_expr_opt_alias(): Relation_expr_opt_aliasContext { - return this.getRuleContext(0, Relation_expr_opt_aliasContext)!; + public KW_PUBLICATION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0)!; } - public KW_SET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SET, 0)!; + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public set_clause_list(): Set_clause_listContext { - return this.getRuleContext(0, Set_clause_listContext)!; + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } - public opt_with_clause(): Opt_with_clauseContext | null { - return this.getRuleContext(0, Opt_with_clauseContext); + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } - public from_clause(): From_clauseContext | null { - return this.getRuleContext(0, From_clauseContext); + public relation_expr_list(): Relation_expr_listContext | null { + return this.getRuleContext(0, Relation_expr_listContext); } - public where_or_current_clause(): Where_or_current_clauseContext | null { - return this.getRuleContext(0, Where_or_current_clauseContext); + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public returning_clause(): Returning_clauseContext | null { - return this.getRuleContext(0, Returning_clauseContext); + public KW_TABLES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLES, 0); + } + public opt_definition(): Opt_definitionContext | null { + return this.getRuleContext(0, Opt_definitionContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_updatestmt; + return PostgreSqlParser.RULE_createpublicationstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterUpdatestmt) { - listener.enterUpdatestmt(this); + if(listener.enterCreatepublicationstmt) { + listener.enterCreatepublicationstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitUpdatestmt) { - listener.exitUpdatestmt(this); + if(listener.exitCreatepublicationstmt) { + listener.exitCreatepublicationstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitUpdatestmt) { - return visitor.visitUpdatestmt(this); + if (visitor.visitCreatepublicationstmt) { + return visitor.visitCreatepublicationstmt(this); } else { return visitor.visitChildren(this); } @@ -97239,18 +72568,57 @@ export class UpdatestmtContext extends antlr.ParserRuleContext { } -export class Set_clause_listContext extends antlr.ParserRuleContext { +export class AlterpublicationstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public set_clause(): Set_clauseContext[]; - public set_clause(i: number): Set_clauseContext | null; - public set_clause(i?: number): Set_clauseContext[] | Set_clauseContext | null { + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public KW_PUBLICATION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0)!; + } + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { if (i === undefined) { - return this.getRuleContexts(Set_clauseContext); + return this.getRuleContexts(ColidContext); } - return this.getRuleContext(i, Set_clauseContext); + return this.getRuleContext(i, ColidContext); + } + public publication_relation_expr(): Publication_relation_exprContext[]; + public publication_relation_expr(i: number): Publication_relation_exprContext | null; + public publication_relation_expr(i?: number): Publication_relation_exprContext[] | Publication_relation_exprContext | null { + if (i === undefined) { + return this.getRuleContexts(Publication_relation_exprContext); + } + + return this.getRuleContext(i, Publication_relation_exprContext); + } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADD, 0); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); + } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); + } + public KW_OWNER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OWNER, 0); + } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); + } + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); + } + public definition(): DefinitionContext | null { + return this.getRuleContext(0, DefinitionContext); + } + public KW_RENAME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RENAME, 0); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -97262,21 +72630,21 @@ export class Set_clause_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_set_clause_list; + return PostgreSqlParser.RULE_alterpublicationstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSet_clause_list) { - listener.enterSet_clause_list(this); + if(listener.enterAlterpublicationstmt) { + listener.enterAlterpublicationstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSet_clause_list) { - listener.exitSet_clause_list(this); + if(listener.exitAlterpublicationstmt) { + listener.exitAlterpublicationstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSet_clause_list) { - return visitor.visitSet_clause_list(this); + if (visitor.visitAlterpublicationstmt) { + return visitor.visitAlterpublicationstmt(this); } else { return visitor.visitChildren(this); } @@ -97284,62 +72652,65 @@ export class Set_clause_listContext extends antlr.ParserRuleContext { } -export class Set_clauseContext extends antlr.ParserRuleContext { +export class CreatesubscriptionstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public set_target(): Set_targetContext | null { - return this.getRuleContext(0, Set_targetContext); + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public EQUAL(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.EQUAL, 0)!; + public KW_SUBSCRIPTION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0)!; } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public OPEN_PAREN(): antlr.TerminalNode[]; - public OPEN_PAREN(i: number): antlr.TerminalNode | null; - public OPEN_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.OPEN_PAREN); - } else { - return this.getToken(PostgreSqlParser.OPEN_PAREN, i); - } + public KW_CONNECTION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CONNECTION, 0)!; + } + public sconst(): SconstContext { + return this.getRuleContext(0, SconstContext)!; } - public set_target_list(): Set_target_listContext | null { - return this.getRuleContext(0, Set_target_listContext); + public KW_PUBLICATION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode[]; - public CLOSE_PAREN(i: number): antlr.TerminalNode | null; - public CLOSE_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.CLOSE_PAREN); - } else { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, i); - } + public collabel(): CollabelContext[]; + public collabel(i: number): CollabelContext | null; + public collabel(i?: number): CollabelContext[] | CollabelContext | null { + if (i === undefined) { + return this.getRuleContexts(CollabelContext); + } + + return this.getRuleContext(i, CollabelContext); } - public select_clause(): Select_clauseContext | null { - return this.getRuleContext(0, Select_clauseContext); + public opt_definition(): Opt_definitionContext | null { + return this.getRuleContext(0, Opt_definitionContext); } - public KW_ROW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROW, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_set_clause; + return PostgreSqlParser.RULE_createsubscriptionstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSet_clause) { - listener.enterSet_clause(this); + if(listener.enterCreatesubscriptionstmt) { + listener.enterCreatesubscriptionstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSet_clause) { - listener.exitSet_clause(this); + if(listener.exitCreatesubscriptionstmt) { + listener.exitCreatesubscriptionstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSet_clause) { - return visitor.visitSet_clause(this); + if (visitor.visitCreatesubscriptionstmt) { + return visitor.visitCreatesubscriptionstmt(this); } else { return visitor.visitChildren(this); } @@ -97347,51 +72718,54 @@ export class Set_clauseContext extends antlr.ParserRuleContext { } -export class Set_targetContext extends antlr.ParserRuleContext { +export class AltersubscriptionstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public column_name(): Column_nameContext { - return this.getRuleContext(0, Column_nameContext)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public opt_indirection(): Opt_indirectionContext { - return this.getRuleContext(0, Opt_indirectionContext)!; + public KW_SUBSCRIPTION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_set_target; + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSet_target) { - listener.enterSet_target(this); - } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSet_target) { - listener.exitSet_target(this); - } + public definition(): DefinitionContext | null { + return this.getRuleContext(0, DefinitionContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSet_target) { - return visitor.visitSet_target(this); - } else { - return visitor.visitChildren(this); - } + public KW_CONNECTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONNECTION, 0); } -} - - -export class Set_target_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } - public set_target(): Set_targetContext[]; - public set_target(i: number): Set_targetContext | null; - public set_target(i?: number): Set_targetContext[] | Set_targetContext | null { + public KW_REFRESH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REFRESH, 0); + } + public KW_PUBLICATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); + } + public opt_definition(): Opt_definitionContext | null { + return this.getRuleContext(0, Opt_definitionContext); + } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADD, 0); + } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); + } + public collabel(): CollabelContext[]; + public collabel(i: number): CollabelContext | null; + public collabel(i?: number): CollabelContext[] | CollabelContext | null { if (i === undefined) { - return this.getRuleContexts(Set_targetContext); + return this.getRuleContexts(CollabelContext); } - return this.getRuleContext(i, Set_targetContext); + return this.getRuleContext(i, CollabelContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -97402,22 +72776,49 @@ export class Set_target_listContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.COMMA, i); } } + public KW_ENABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ENABLE, 0); + } + public KW_DISABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DISABLE, 0); + } + public KW_SKIP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SKIP, 0); + } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + } + public old_aggr_elem(): Old_aggr_elemContext | null { + return this.getRuleContext(0, Old_aggr_elemContext); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + } + public KW_OWNER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OWNER, 0); + } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); + } + public rolespec(): RolespecContext | null { + return this.getRuleContext(0, RolespecContext); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_set_target_list; + return PostgreSqlParser.RULE_altersubscriptionstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSet_target_list) { - listener.enterSet_target_list(this); + if(listener.enterAltersubscriptionstmt) { + listener.enterAltersubscriptionstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSet_target_list) { - listener.exitSet_target_list(this); + if(listener.exitAltersubscriptionstmt) { + listener.exitAltersubscriptionstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSet_target_list) { - return visitor.visitSet_target_list(this); + if (visitor.visitAltersubscriptionstmt) { + return visitor.visitAltersubscriptionstmt(this); } else { return visitor.visitChildren(this); } @@ -97425,140 +72826,101 @@ export class Set_target_listContext extends antlr.ParserRuleContext { } -export class DeclarecursorstmtContext extends antlr.ParserRuleContext { +export class RulestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_DECLARE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DECLARE, 0)!; - } - public cursor_name(): Cursor_nameContext { - return this.getRuleContext(0, Cursor_nameContext)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public cursor_options(): Cursor_optionsContext { - return this.getRuleContext(0, Cursor_optionsContext)!; + public KW_RULE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_RULE, 0)!; } - public KW_CURSOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CURSOR, 0)!; + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public opt_hold(): Opt_holdContext { - return this.getRuleContext(0, Opt_holdContext)!; + public KW_AS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_AS, 0)!; } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; + public KW_ON(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ON, 0)!; } - public selectstmt(): SelectstmtContext { - return this.getRuleContext(0, SelectstmtContext)!; + public KW_TO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TO, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_declarecursorstmt; + public qualified_name(): Qualified_nameContext { + return this.getRuleContext(0, Qualified_nameContext)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDeclarecursorstmt) { - listener.enterDeclarecursorstmt(this); - } + public KW_DO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DO, 0)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDeclarecursorstmt) { - listener.exitDeclarecursorstmt(this); - } + public KW_SELECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SELECT, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDeclarecursorstmt) { - return visitor.visitDeclarecursorstmt(this); - } else { - return visitor.visitChildren(this); - } + public KW_UPDATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UPDATE, 0); } -} - - -export class Cursor_nameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_DELETE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DELETE, 0); } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; + public KW_INSERT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INSERT, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_cursor_name; + public KW_NOTHING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOTHING, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCursor_name) { - listener.enterCursor_name(this); + public ruleactionstmt(): RuleactionstmtContext[]; + public ruleactionstmt(i: number): RuleactionstmtContext | null; + public ruleactionstmt(i?: number): RuleactionstmtContext[] | RuleactionstmtContext | null { + if (i === undefined) { + return this.getRuleContexts(RuleactionstmtContext); } + + return this.getRuleContext(i, RuleactionstmtContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCursor_name) { - listener.exitCursor_name(this); - } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCursor_name) { - return visitor.visitCursor_name(this); - } else { - return visitor.visitChildren(this); - } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } -} - - -export class Cursor_optionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public opt_or_replace(): Opt_or_replaceContext | null { + return this.getRuleContext(0, Opt_or_replaceContext); } - public KW_NO(): antlr.TerminalNode[]; - public KW_NO(i: number): antlr.TerminalNode | null; - public KW_NO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_NO); - } else { - return this.getToken(PostgreSqlParser.KW_NO, i); - } + public where_clause(): Where_clauseContext | null { + return this.getRuleContext(0, Where_clauseContext); } - public KW_SCROLL(): antlr.TerminalNode[]; - public KW_SCROLL(i: number): antlr.TerminalNode | null; - public KW_SCROLL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_SCROLL); - } else { - return this.getToken(PostgreSqlParser.KW_SCROLL, i); - } + public KW_INSTEAD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INSTEAD, 0); } - public KW_BINARY(): antlr.TerminalNode[]; - public KW_BINARY(i: number): antlr.TerminalNode | null; - public KW_BINARY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_BINARY); - } else { - return this.getToken(PostgreSqlParser.KW_BINARY, i); - } + public KW_ALSO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALSO, 0); } - public KW_INSENSITIVE(): antlr.TerminalNode[]; - public KW_INSENSITIVE(i: number): antlr.TerminalNode | null; - public KW_INSENSITIVE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public SEMI(): antlr.TerminalNode[]; + public SEMI(i: number): antlr.TerminalNode | null; + public SEMI(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_INSENSITIVE); + return this.getTokens(PostgreSqlParser.SEMI); } else { - return this.getToken(PostgreSqlParser.KW_INSENSITIVE, i); + return this.getToken(PostgreSqlParser.SEMI, i); } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_cursor_options; + return PostgreSqlParser.RULE_rulestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCursor_options) { - listener.enterCursor_options(this); + if(listener.enterRulestmt) { + listener.enterRulestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCursor_options) { - listener.exitCursor_options(this); + if(listener.exitRulestmt) { + listener.exitRulestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCursor_options) { - return visitor.visitCursor_options(this); + if (visitor.visitRulestmt) { + return visitor.visitRulestmt(this); } else { return visitor.visitChildren(this); } @@ -97566,35 +72928,41 @@ export class Cursor_optionsContext extends antlr.ParserRuleContext { } -export class Opt_holdContext extends antlr.ParserRuleContext { +export class RuleactionstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); + public selectstmt(): SelectstmtContext | null { + return this.getRuleContext(0, SelectstmtContext); } - public KW_HOLD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_HOLD, 0); + public insertstmt(): InsertstmtContext | null { + return this.getRuleContext(0, InsertstmtContext); } - public KW_WITHOUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); + public updatestmt(): UpdatestmtContext | null { + return this.getRuleContext(0, UpdatestmtContext); + } + public deletestmt(): DeletestmtContext | null { + return this.getRuleContext(0, DeletestmtContext); + } + public notifystmt(): NotifystmtContext | null { + return this.getRuleContext(0, NotifystmtContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_hold; + return PostgreSqlParser.RULE_ruleactionstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_hold) { - listener.enterOpt_hold(this); + if(listener.enterRuleactionstmt) { + listener.enterRuleactionstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_hold) { - listener.exitOpt_hold(this); + if(listener.exitRuleactionstmt) { + listener.exitRuleactionstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_hold) { - return visitor.visitOpt_hold(this); + if (visitor.visitRuleactionstmt) { + return visitor.visitRuleactionstmt(this); } else { return visitor.visitChildren(this); } @@ -97602,41 +72970,35 @@ export class Opt_holdContext extends antlr.ParserRuleContext { } -export class SelectstmtContext extends antlr.ParserRuleContext { +export class NotifystmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_selectstmt; - } - public override copyFrom(ctx: SelectstmtContext): void { - super.copyFrom(ctx); + public KW_NOTIFY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_NOTIFY, 0)!; } -} -export class SelectStatementContext extends SelectstmtContext { - public constructor(ctx: SelectstmtContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public select_no_parens(): Select_no_parensContext | null { - return this.getRuleContext(0, Select_no_parensContext); + public notify_payload(): Notify_payloadContext | null { + return this.getRuleContext(0, Notify_payloadContext); } - public select_with_parens(): Select_with_parensContext | null { - return this.getRuleContext(0, Select_with_parensContext); + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_notifystmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSelectStatement) { - listener.enterSelectStatement(this); + if(listener.enterNotifystmt) { + listener.enterNotifystmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSelectStatement) { - listener.exitSelectStatement(this); + if(listener.exitNotifystmt) { + listener.exitNotifystmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSelectStatement) { - return visitor.visitSelectStatement(this); + if (visitor.visitNotifystmt) { + return visitor.visitNotifystmt(this); } else { return visitor.visitChildren(this); } @@ -97644,38 +73006,32 @@ export class SelectStatementContext extends SelectstmtContext { } -export class Select_with_parensContext extends antlr.ParserRuleContext { +export class Notify_payloadContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public select_no_parens(): Select_no_parensContext | null { - return this.getRuleContext(0, Select_no_parensContext); - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public COMMA(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.COMMA, 0)!; } - public select_with_parens(): Select_with_parensContext | null { - return this.getRuleContext(0, Select_with_parensContext); + public sconst(): SconstContext { + return this.getRuleContext(0, SconstContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_select_with_parens; + return PostgreSqlParser.RULE_notify_payload; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSelect_with_parens) { - listener.enterSelect_with_parens(this); + if(listener.enterNotify_payload) { + listener.enterNotify_payload(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSelect_with_parens) { - listener.exitSelect_with_parens(this); + if(listener.exitNotify_payload) { + listener.exitNotify_payload(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSelect_with_parens) { - return visitor.visitSelect_with_parens(this); + if (visitor.visitNotify_payload) { + return visitor.visitNotify_payload(this); } else { return visitor.visitChildren(this); } @@ -97683,47 +73039,32 @@ export class Select_with_parensContext extends antlr.ParserRuleContext { } -export class Select_no_parensContext extends antlr.ParserRuleContext { +export class ListenstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public select_clause(): Select_clauseContext { - return this.getRuleContext(0, Select_clauseContext)!; - } - public opt_sort_clause(): Opt_sort_clauseContext | null { - return this.getRuleContext(0, Opt_sort_clauseContext); - } - public for_locking_clause(): For_locking_clauseContext | null { - return this.getRuleContext(0, For_locking_clauseContext); - } - public select_limit(): Select_limitContext | null { - return this.getRuleContext(0, Select_limitContext); - } - public opt_select_limit(): Opt_select_limitContext | null { - return this.getRuleContext(0, Opt_select_limitContext); - } - public opt_for_locking_clause(): Opt_for_locking_clauseContext | null { - return this.getRuleContext(0, Opt_for_locking_clauseContext); + public KW_LISTEN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_LISTEN, 0)!; } - public with_clause(): With_clauseContext | null { - return this.getRuleContext(0, With_clauseContext); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_select_no_parens; + return PostgreSqlParser.RULE_listenstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSelect_no_parens) { - listener.enterSelect_no_parens(this); + if(listener.enterListenstmt) { + listener.enterListenstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSelect_no_parens) { - listener.exitSelect_no_parens(this); + if(listener.exitListenstmt) { + listener.exitListenstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSelect_no_parens) { - return visitor.visitSelect_no_parens(this); + if (visitor.visitListenstmt) { + return visitor.visitListenstmt(this); } else { return visitor.visitChildren(this); } @@ -97731,32 +73072,35 @@ export class Select_no_parensContext extends antlr.ParserRuleContext { } -export class Select_clauseContext extends antlr.ParserRuleContext { +export class UnlistenstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public simple_select(): Simple_selectContext | null { - return this.getRuleContext(0, Simple_selectContext); + public KW_UNLISTEN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_UNLISTEN, 0)!; } - public select_with_parens(): Select_with_parensContext | null { - return this.getRuleContext(0, Select_with_parensContext); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); + } + public STAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.STAR, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_select_clause; + return PostgreSqlParser.RULE_unlistenstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSelect_clause) { - listener.enterSelect_clause(this); + if(listener.enterUnlistenstmt) { + listener.enterUnlistenstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSelect_clause) { - listener.exitSelect_clause(this); + if(listener.exitUnlistenstmt) { + listener.exitUnlistenstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSelect_clause) { - return visitor.visitSelect_clause(this); + if (visitor.visitUnlistenstmt) { + return visitor.visitUnlistenstmt(this); } else { return visitor.visitChildren(this); } @@ -97764,101 +73108,83 @@ export class Select_clauseContext extends antlr.ParserRuleContext { } -export class Simple_selectContext extends antlr.ParserRuleContext { +export class TransactionstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_SELECT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SELECT, 0); + public KW_BEGIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BEGIN, 0); } - public values_clause(): Values_clauseContext | null { - return this.getRuleContext(0, Values_clauseContext); + public opt_transaction(): Opt_transactionContext | null { + return this.getRuleContext(0, Opt_transactionContext); } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); + public transaction_mode_list(): Transaction_mode_listContext | null { + return this.getRuleContext(0, Transaction_mode_listContext); } - public relation_expr(): Relation_exprContext | null { - return this.getRuleContext(0, Relation_exprContext); + public KW_START(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_START, 0); } - public select_with_parens(): Select_with_parensContext[]; - public select_with_parens(i: number): Select_with_parensContext | null; - public select_with_parens(i?: number): Select_with_parensContext[] | Select_with_parensContext | null { - if (i === undefined) { - return this.getRuleContexts(Select_with_parensContext); - } - - return this.getRuleContext(i, Select_with_parensContext); + public KW_TRANSACTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); } - public set_operator_with_all_or_distinct(): Set_operator_with_all_or_distinctContext[]; - public set_operator_with_all_or_distinct(i: number): Set_operator_with_all_or_distinctContext | null; - public set_operator_with_all_or_distinct(i?: number): Set_operator_with_all_or_distinctContext[] | Set_operator_with_all_or_distinctContext | null { - if (i === undefined) { - return this.getRuleContexts(Set_operator_with_all_or_distinctContext); - } - - return this.getRuleContext(i, Set_operator_with_all_or_distinctContext); + public KW_SAVEPOINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SAVEPOINT, 0); } - public simple_select(): Simple_selectContext[]; - public simple_select(i: number): Simple_selectContext | null; - public simple_select(i?: number): Simple_selectContext[] | Simple_selectContext | null { - if (i === undefined) { - return this.getRuleContexts(Simple_selectContext); - } - - return this.getRuleContext(i, Simple_selectContext); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public into_clause(): Into_clauseContext[]; - public into_clause(i: number): Into_clauseContext | null; - public into_clause(i?: number): Into_clauseContext[] | Into_clauseContext | null { - if (i === undefined) { - return this.getRuleContexts(Into_clauseContext); - } - - return this.getRuleContext(i, Into_clauseContext); + public KW_RELEASE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RELEASE, 0); } - public from_clause(): From_clauseContext | null { - return this.getRuleContext(0, From_clauseContext); + public KW_PREPARE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PREPARE, 0); } - public where_clause(): Where_clauseContext | null { - return this.getRuleContext(0, Where_clauseContext); + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } - public group_clause(): Group_clauseContext | null { - return this.getRuleContext(0, Group_clauseContext); + public KW_PREPARED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PREPARED, 0); } - public having_clause(): Having_clauseContext | null { - return this.getRuleContext(0, Having_clauseContext); + public KW_COMMIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COMMIT, 0); } - public window_clause(): Window_clauseContext | null { - return this.getRuleContext(0, Window_clauseContext); + public KW_ROLLBACK(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLLBACK, 0); } - public opt_all_clause(): Opt_all_clauseContext | null { - return this.getRuleContext(0, Opt_all_clauseContext); + public KW_ABORT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ABORT, 0); } - public opt_target_list(): Opt_target_listContext | null { - return this.getRuleContext(0, Opt_target_listContext); + public KW_END(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_END, 0); } - public distinct_clause(): Distinct_clauseContext | null { - return this.getRuleContext(0, Distinct_clauseContext); + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AND, 0); } - public target_list(): Target_listContext | null { - return this.getRuleContext(0, Target_listContext); + public KW_CHAIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CHAIN, 0); + } + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); + } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_simple_select; + return PostgreSqlParser.RULE_transactionstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSimple_select) { - listener.enterSimple_select(this); + if(listener.enterTransactionstmt) { + listener.enterTransactionstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSimple_select) { - listener.exitSimple_select(this); + if(listener.exitTransactionstmt) { + listener.exitTransactionstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSimple_select) { - return visitor.visitSimple_select(this); + if (visitor.visitTransactionstmt) { + return visitor.visitTransactionstmt(this); } else { return visitor.visitChildren(this); } @@ -97866,90 +73192,83 @@ export class Simple_selectContext extends antlr.ParserRuleContext { } -export class Set_operatorContext extends antlr.ParserRuleContext { +export class Opt_transactionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_set_operator; - } - public override copyFrom(ctx: Set_operatorContext): void { - super.copyFrom(ctx); + public KW_WORK(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WORK, 0); } -} -export class IntersectContext extends Set_operatorContext { - public constructor(ctx: Set_operatorContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); + public KW_TRANSACTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); } - public KW_INTERSECT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INTERSECT, 0)!; + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_opt_transaction; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIntersect) { - listener.enterIntersect(this); + if(listener.enterOpt_transaction) { + listener.enterOpt_transaction(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIntersect) { - listener.exitIntersect(this); + if(listener.exitOpt_transaction) { + listener.exitOpt_transaction(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIntersect) { - return visitor.visitIntersect(this); + if (visitor.visitOpt_transaction) { + return visitor.visitOpt_transaction(this); } else { return visitor.visitChildren(this); } } -} -export class ExceptContext extends Set_operatorContext { - public constructor(ctx: Set_operatorContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); +} + + +export class Transaction_mode_itemContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public KW_ISOLATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ISOLATION, 0); + } + public KW_LEVEL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LEVEL, 0); } - public KW_EXCEPT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXCEPT, 0)!; + public iso_level(): Iso_levelContext | null { + return this.getRuleContext(0, Iso_levelContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExcept) { - listener.enterExcept(this); - } + public KW_READ(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_READ, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExcept) { - listener.exitExcept(this); - } + public KW_ONLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ONLY, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExcept) { - return visitor.visitExcept(this); - } else { - return visitor.visitChildren(this); - } + public KW_WRITE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WRITE, 0); } -} -export class UnionContext extends Set_operatorContext { - public constructor(ctx: Set_operatorContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); + public KW_DEFERRABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFERRABLE, 0); + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } - public KW_UNION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_UNION, 0)!; + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_transaction_mode_item; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterUnion) { - listener.enterUnion(this); + if(listener.enterTransaction_mode_item) { + listener.enterTransaction_mode_item(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitUnion) { - listener.exitUnion(this); + if(listener.exitTransaction_mode_item) { + listener.exitTransaction_mode_item(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitUnion) { - return visitor.visitUnion(this); + if (visitor.visitTransaction_mode_item) { + return visitor.visitTransaction_mode_item(this); } else { return visitor.visitChildren(this); } @@ -97957,32 +73276,44 @@ export class UnionContext extends Set_operatorContext { } -export class Set_operator_with_all_or_distinctContext extends antlr.ParserRuleContext { +export class Transaction_mode_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public set_operator(): Set_operatorContext { - return this.getRuleContext(0, Set_operatorContext)!; + public transaction_mode_item(): Transaction_mode_itemContext[]; + public transaction_mode_item(i: number): Transaction_mode_itemContext | null; + public transaction_mode_item(i?: number): Transaction_mode_itemContext[] | Transaction_mode_itemContext | null { + if (i === undefined) { + return this.getRuleContexts(Transaction_mode_itemContext); + } + + return this.getRuleContext(i, Transaction_mode_itemContext); } - public all_or_distinct(): All_or_distinctContext | null { - return this.getRuleContext(0, All_or_distinctContext); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_set_operator_with_all_or_distinct; + return PostgreSqlParser.RULE_transaction_mode_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSet_operator_with_all_or_distinct) { - listener.enterSet_operator_with_all_or_distinct(this); + if(listener.enterTransaction_mode_list) { + listener.enterTransaction_mode_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSet_operator_with_all_or_distinct) { - listener.exitSet_operator_with_all_or_distinct(this); + if(listener.exitTransaction_mode_list) { + listener.exitTransaction_mode_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSet_operator_with_all_or_distinct) { - return visitor.visitSet_operator_with_all_or_distinct(this); + if (visitor.visitTransaction_mode_list) { + return visitor.visitTransaction_mode_list(this); } else { return visitor.visitChildren(this); } @@ -97990,35 +73321,86 @@ export class Set_operator_with_all_or_distinctContext extends antlr.ParserRuleCo } -export class With_clauseContext extends antlr.ParserRuleContext { +export class ViewstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_viewstmt; + } + public override copyFrom(ctx: ViewstmtContext): void { + super.copyFrom(ctx); + } +} +export class CreateViewContext extends ViewstmtContext { + public constructor(ctx: ViewstmtContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); + } + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + } + public KW_AS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_AS, 0)!; + } + public selectstmt(): SelectstmtContext { + return this.getRuleContext(0, SelectstmtContext)!; + } + public KW_VIEW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VIEW, 0); } - public cte_list(): Cte_listContext { - return this.getRuleContext(0, Cte_listContext)!; + public view_name_create(): View_name_createContext | null { + return this.getRuleContext(0, View_name_createContext); } public KW_RECURSIVE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_RECURSIVE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_with_clause; + public opt_column_list(): Opt_column_listContext | null { + return this.getRuleContext(0, Opt_column_listContext); + } + public KW_OR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OR, 0); + } + public KW_REPLACE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REPLACE, 0); + } + public opttemp(): OpttempContext | null { + return this.getRuleContext(0, OpttempContext); + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); + } + public KW_CHECK(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CHECK, 0); + } + public KW_OPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OPTION, 0); + } + public opt_column_list_create(): Opt_column_list_createContext | null { + return this.getRuleContext(0, Opt_column_list_createContext); + } + public opt_reloptions(): Opt_reloptionsContext | null { + return this.getRuleContext(0, Opt_reloptionsContext); + } + public KW_CASCADED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CASCADED, 0); + } + public KW_LOCAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LOCAL, 0); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterWith_clause) { - listener.enterWith_clause(this); + if(listener.enterCreateView) { + listener.enterCreateView(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitWith_clause) { - listener.exitWith_clause(this); + if(listener.exitCreateView) { + listener.exitCreateView(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitWith_clause) { - return visitor.visitWith_clause(this); + if (visitor.visitCreateView) { + return visitor.visitCreateView(this); } else { return visitor.visitChildren(this); } @@ -98026,44 +73408,32 @@ export class With_clauseContext extends antlr.ParserRuleContext { } -export class Cte_listContext extends antlr.ParserRuleContext { +export class LoadstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public common_table_expr(): Common_table_exprContext[]; - public common_table_expr(i: number): Common_table_exprContext | null; - public common_table_expr(i?: number): Common_table_exprContext[] | Common_table_exprContext | null { - if (i === undefined) { - return this.getRuleContexts(Common_table_exprContext); - } - - return this.getRuleContext(i, Common_table_exprContext); + public KW_LOAD(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_LOAD, 0)!; } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public sconst(): SconstContext { + return this.getRuleContext(0, SconstContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_cte_list; + return PostgreSqlParser.RULE_loadstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCte_list) { - listener.enterCte_list(this); + if(listener.enterLoadstmt) { + listener.enterLoadstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCte_list) { - listener.exitCte_list(this); + if(listener.exitLoadstmt) { + listener.exitLoadstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCte_list) { - return visitor.visitCte_list(this); + if (visitor.visitLoadstmt) { + return visitor.visitLoadstmt(this); } else { return visitor.visitChildren(this); } @@ -98071,53 +73441,56 @@ export class Cte_listContext extends antlr.ParserRuleContext { } -export class Common_table_exprContext extends antlr.ParserRuleContext { +export class CreatedbstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public name(): NameContext { - return this.getRuleContext(0, NameContext)!; - } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_createdbstmt; } - public preparablestmt(): PreparablestmtContext { - return this.getRuleContext(0, PreparablestmtContext)!; + public override copyFrom(ctx: CreatedbstmtContext): void { + super.copyFrom(ctx); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; +} +export class CreateDatabaseContext extends CreatedbstmtContext { + public constructor(ctx: CreatedbstmtContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public opt_name_list(): Opt_name_listContext | null { - return this.getRuleContext(0, Opt_name_listContext); + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public opt_materialized(): Opt_materializedContext | null { - return this.getRuleContext(0, Opt_materializedContext); + public KW_DATABASE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DATABASE, 0)!; } - public search_cluase(): Search_cluaseContext | null { - return this.getRuleContext(0, Search_cluaseContext); + public database_name_create(): Database_name_createContext { + return this.getRuleContext(0, Database_name_createContext)!; } - public cycle_cluase(): Cycle_cluaseContext | null { - return this.getRuleContext(0, Cycle_cluaseContext); + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_common_table_expr; + public createdb_opt_item(): Createdb_opt_itemContext[]; + public createdb_opt_item(i: number): Createdb_opt_itemContext | null; + public createdb_opt_item(i?: number): Createdb_opt_itemContext[] | Createdb_opt_itemContext | null { + if (i === undefined) { + return this.getRuleContexts(Createdb_opt_itemContext); + } + + return this.getRuleContext(i, Createdb_opt_itemContext); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCommon_table_expr) { - listener.enterCommon_table_expr(this); + if(listener.enterCreateDatabase) { + listener.enterCreateDatabase(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCommon_table_expr) { - listener.exitCommon_table_expr(this); + if(listener.exitCreateDatabase) { + listener.exitCreateDatabase(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCommon_table_expr) { - return visitor.visitCommon_table_expr(this); + if (visitor.visitCreateDatabase) { + return visitor.visitCreateDatabase(this); } else { return visitor.visitChildren(this); } @@ -98125,50 +73498,62 @@ export class Common_table_exprContext extends antlr.ParserRuleContext { } -export class Search_cluaseContext extends antlr.ParserRuleContext { +export class Createdb_opt_itemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_SEARCH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SEARCH, 0)!; + public KW_CONNECTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONNECTION, 0); } - public KW_FIRST(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FIRST, 0)!; + public KW_LIMIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LIMIT, 0); } - public KW_BY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BY, 0)!; + public KW_ENCODING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ENCODING, 0); } - public column_list(): Column_listContext { - return this.getRuleContext(0, Column_listContext)!; + public KW_LOCATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LOCATION, 0); } - public KW_SET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SET, 0)!; + public KW_OWNER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OWNER, 0); } - public column_name(): Column_nameContext { - return this.getRuleContext(0, Column_nameContext)!; + public KW_TABLESPACE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); } - public KW_BREADTH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BREADTH, 0); + public KW_TEMPLATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); } - public KW_DEPTH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEPTH, 0); + public identifier(): IdentifierContext | null { + return this.getRuleContext(0, IdentifierContext); + } + public signediconst(): SignediconstContext | null { + return this.getRuleContext(0, SignediconstContext); + } + public opt_boolean_or_string(): Opt_boolean_or_stringContext | null { + return this.getRuleContext(0, Opt_boolean_or_stringContext); + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); + } + public EQUAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.EQUAL, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_search_cluase; + return PostgreSqlParser.RULE_createdb_opt_item; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSearch_cluase) { - listener.enterSearch_cluase(this); + if(listener.enterCreatedb_opt_item) { + listener.enterCreatedb_opt_item(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSearch_cluase) { - listener.exitSearch_cluase(this); + if(listener.exitCreatedb_opt_item) { + listener.exitCreatedb_opt_item(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSearch_cluase) { - return visitor.visitSearch_cluase(this); + if (visitor.visitCreatedb_opt_item) { + return visitor.visitCreatedb_opt_item(this); } else { return visitor.visitChildren(this); } @@ -98176,62 +73561,56 @@ export class Search_cluaseContext extends antlr.ParserRuleContext { } -export class Cycle_cluaseContext extends antlr.ParserRuleContext { +export class AlterdatabasestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CYCLE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CYCLE, 0)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public column_list(): Column_listContext { - return this.getRuleContext(0, Column_listContext)!; + public KW_DATABASE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DATABASE, 0)!; } - public KW_SET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SET, 0)!; + public database_name(): Database_nameContext { + return this.getRuleContext(0, Database_nameContext)!; } - public column_name(): Column_nameContext[]; - public column_name(i: number): Column_nameContext | null; - public column_name(i?: number): Column_nameContext[] | Column_nameContext | null { - if (i === undefined) { - return this.getRuleContexts(Column_nameContext); - } - - return this.getRuleContext(i, Column_nameContext); + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public KW_USING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_USING, 0)!; + public KW_TABLESPACE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); + public tablespace_name_create(): Tablespace_name_createContext | null { + return this.getRuleContext(0, Tablespace_name_createContext); + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public name(): NameContext[]; - public name(i: number): NameContext | null; - public name(i?: number): NameContext[] | NameContext | null { + public createdb_opt_item(): Createdb_opt_itemContext[]; + public createdb_opt_item(i: number): Createdb_opt_itemContext | null; + public createdb_opt_item(i?: number): Createdb_opt_itemContext[] | Createdb_opt_itemContext | null { if (i === undefined) { - return this.getRuleContexts(NameContext); + return this.getRuleContexts(Createdb_opt_itemContext); } - return this.getRuleContext(i, NameContext); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); + return this.getRuleContext(i, Createdb_opt_itemContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_cycle_cluase; + return PostgreSqlParser.RULE_alterdatabasestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCycle_cluase) { - listener.enterCycle_cluase(this); + if(listener.enterAlterdatabasestmt) { + listener.enterAlterdatabasestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCycle_cluase) { - listener.exitCycle_cluase(this); + if(listener.exitAlterdatabasestmt) { + listener.exitAlterdatabasestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCycle_cluase) { - return visitor.visitCycle_cluase(this); + if (visitor.visitAlterdatabasestmt) { + return visitor.visitAlterdatabasestmt(this); } else { return visitor.visitChildren(this); } @@ -98239,32 +73618,38 @@ export class Cycle_cluaseContext extends antlr.ParserRuleContext { } -export class Opt_materializedContext extends antlr.ParserRuleContext { +export class AlterdatabasesetstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_MATERIALIZED(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); + public KW_DATABASE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DATABASE, 0)!; + } + public database_name(): Database_nameContext { + return this.getRuleContext(0, Database_nameContext)!; + } + public setresetclause(): SetresetclauseContext | null { + return this.getRuleContext(0, SetresetclauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_materialized; + return PostgreSqlParser.RULE_alterdatabasesetstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_materialized) { - listener.enterOpt_materialized(this); + if(listener.enterAlterdatabasesetstmt) { + listener.enterAlterdatabasesetstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_materialized) { - listener.exitOpt_materialized(this); + if(listener.exitAlterdatabasesetstmt) { + listener.exitAlterdatabasesetstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_materialized) { - return visitor.visitOpt_materialized(this); + if (visitor.visitAlterdatabasesetstmt) { + return visitor.visitAlterdatabasesetstmt(this); } else { return visitor.visitChildren(this); } @@ -98272,29 +73657,41 @@ export class Opt_materializedContext extends antlr.ParserRuleContext { } -export class Opt_with_clauseContext extends antlr.ParserRuleContext { +export class AltercollationstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public with_clause(): With_clauseContext { - return this.getRuleContext(0, With_clauseContext)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; + } + public KW_COLLATION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_COLLATION, 0)!; + } + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; + } + public KW_REFRESH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_REFRESH, 0)!; + } + public KW_VERSION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_VERSION, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_with_clause; + return PostgreSqlParser.RULE_altercollationstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_with_clause) { - listener.enterOpt_with_clause(this); + if(listener.enterAltercollationstmt) { + listener.enterAltercollationstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_with_clause) { - listener.exitOpt_with_clause(this); + if(listener.exitAltercollationstmt) { + listener.exitAltercollationstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_with_clause) { - return visitor.visitOpt_with_clause(this); + if (visitor.visitAltercollationstmt) { + return visitor.visitAltercollationstmt(this); } else { return visitor.visitChildren(this); } @@ -98302,38 +73699,41 @@ export class Opt_with_clauseContext extends antlr.ParserRuleContext { } -export class Into_clauseContext extends antlr.ParserRuleContext { +export class AltersystemstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_INTO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INTO, 0)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public opt_strict(): Opt_strictContext | null { - return this.getRuleContext(0, Opt_strictContext); + public KW_SYSTEM(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SYSTEM, 0)!; } - public opttempTableName(): OpttempTableNameContext | null { - return this.getRuleContext(0, OpttempTableNameContext); + public generic_set(): Generic_setContext { + return this.getRuleContext(0, Generic_setContext)!; + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public into_target(): Into_targetContext | null { - return this.getRuleContext(0, Into_targetContext); + public KW_RESET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESET, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_into_clause; + return PostgreSqlParser.RULE_altersystemstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterInto_clause) { - listener.enterInto_clause(this); + if(listener.enterAltersystemstmt) { + listener.enterAltersystemstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitInto_clause) { - listener.exitInto_clause(this); + if(listener.exitAltersystemstmt) { + listener.exitAltersystemstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitInto_clause) { - return visitor.visitInto_clause(this); + if (visitor.visitAltersystemstmt) { + return visitor.visitAltersystemstmt(this); } else { return visitor.visitChildren(this); } @@ -98341,29 +73741,50 @@ export class Into_clauseContext extends antlr.ParserRuleContext { } -export class Opt_strictContext extends antlr.ParserRuleContext { +export class CreatedomainstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_STRICT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STRICT, 0); + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; + } + public KW_DOMAIN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DOMAIN, 0)!; + } + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; + } + public typename(): TypenameContext { + return this.getRuleContext(0, TypenameContext)!; + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); + } + public colconstraint(): ColconstraintContext[]; + public colconstraint(i: number): ColconstraintContext | null; + public colconstraint(i?: number): ColconstraintContext[] | ColconstraintContext | null { + if (i === undefined) { + return this.getRuleContexts(ColconstraintContext); + } + + return this.getRuleContext(i, ColconstraintContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_strict; + return PostgreSqlParser.RULE_createdomainstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_strict) { - listener.enterOpt_strict(this); + if(listener.enterCreatedomainstmt) { + listener.enterCreatedomainstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_strict) { - listener.exitOpt_strict(this); + if(listener.exitCreatedomainstmt) { + listener.exitCreatedomainstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_strict) { - return visitor.visitOpt_strict(this); + if (visitor.visitCreatedomainstmt) { + return visitor.visitCreatedomainstmt(this); } else { return visitor.visitChildren(this); } @@ -98371,80 +73792,71 @@ export class Opt_strictContext extends antlr.ParserRuleContext { } -export class OpttempTableNameContext extends antlr.ParserRuleContext { +export class AlterdomainstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public table_name_create(): Table_name_createContext { - return this.getRuleContext(0, Table_name_createContext)!; + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public KW_TEMPORARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPORARY, 0); + public KW_DOMAIN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DOMAIN, 0)!; } - public KW_TEMP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMP, 0); + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; } - public opt_table(): Opt_tableContext | null { - return this.getRuleContext(0, Opt_tableContext); + public alter_column_default(): Alter_column_defaultContext | null { + return this.getRuleContext(0, Alter_column_defaultContext); } - public KW_LOCAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LOCAL, 0); + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } - public KW_GLOBAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GLOBAL, 0); + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULL, 0); } - public KW_UNLOGGED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNLOGGED, 0); + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADD, 0); } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); + public constraintelem(): ConstraintelemContext | null { + return this.getRuleContext(0, ConstraintelemContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opttempTableName; + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpttempTableName) { - listener.enterOpttempTableName(this); - } + public KW_CONSTRAINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpttempTableName) { - listener.exitOpttempTableName(this); - } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpttempTableName) { - return visitor.visitOpttempTableName(this); - } else { - return visitor.visitChildren(this); - } + public KW_VALIDATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALIDATE, 0); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } -} - - -export class Opt_tableContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); } - public KW_TABLE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TABLE, 0)!; + public opt_drop_behavior(): Opt_drop_behaviorContext | null { + return this.getRuleContext(0, Opt_drop_behaviorContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_table; + return PostgreSqlParser.RULE_alterdomainstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_table) { - listener.enterOpt_table(this); + if(listener.enterAlterdomainstmt) { + listener.enterAlterdomainstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_table) { - listener.exitOpt_table(this); + if(listener.exitAlterdomainstmt) { + listener.exitAlterdomainstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_table) { - return visitor.visitOpt_table(this); + if (visitor.visitAlterdomainstmt) { + return visitor.visitAlterdomainstmt(this); } else { return visitor.visitChildren(this); } @@ -98452,32 +73864,44 @@ export class Opt_tableContext extends antlr.ParserRuleContext { } -export class All_or_distinctContext extends antlr.ParserRuleContext { +export class AltertsdictionarystmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); + public KW_ALTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ALTER, 0)!; } - public KW_DISTINCT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DISTINCT, 0); + public KW_TEXT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TEXT, 0)!; + } + public KW_SEARCH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SEARCH, 0)!; + } + public KW_DICTIONARY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DICTIONARY, 0)!; + } + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; + } + public definition(): DefinitionContext { + return this.getRuleContext(0, DefinitionContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_all_or_distinct; + return PostgreSqlParser.RULE_altertsdictionarystmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAll_or_distinct) { - listener.enterAll_or_distinct(this); + if(listener.enterAltertsdictionarystmt) { + listener.enterAltertsdictionarystmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAll_or_distinct) { - listener.exitAll_or_distinct(this); + if(listener.exitAltertsdictionarystmt) { + listener.exitAltertsdictionarystmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAll_or_distinct) { - return visitor.visitAll_or_distinct(this); + if (visitor.visitAltertsdictionarystmt) { + return visitor.visitAltertsdictionarystmt(this); } else { return visitor.visitChildren(this); } @@ -98485,71 +73909,80 @@ export class All_or_distinctContext extends antlr.ParserRuleContext { } -export class Distinct_clauseContext extends antlr.ParserRuleContext { +export class AltertsconfigurationstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_DISTINCT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DISTINCT, 0)!; + public KW_ALTER(): antlr.TerminalNode[]; + public KW_ALTER(i: number): antlr.TerminalNode | null; + public KW_ALTER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_ALTER); + } else { + return this.getToken(PostgreSqlParser.KW_ALTER, i); + } } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); + public KW_TEXT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TEXT, 0)!; } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_SEARCH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SEARCH, 0)!; } - public expr_list(): Expr_listContext | null { - return this.getRuleContext(0, Expr_listContext); + public KW_CONFIGURATION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CONFIGURATION, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public any_name(): Any_nameContext[]; + public any_name(i: number): Any_nameContext | null; + public any_name(i?: number): Any_nameContext[] | Any_nameContext | null { + if (i === undefined) { + return this.getRuleContexts(Any_nameContext); + } + + return this.getRuleContext(i, Any_nameContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_distinct_clause; + public KW_MAPPING(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_MAPPING, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDistinct_clause) { - listener.enterDistinct_clause(this); - } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDistinct_clause) { - listener.exitDistinct_clause(this); - } + public name_list(): Name_listContext | null { + return this.getRuleContext(0, Name_listContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDistinct_clause) { - return visitor.visitDistinct_clause(this); - } else { - return visitor.visitChildren(this); - } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } -} - - -export class Opt_all_clauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public any_name_list(): Any_name_listContext | null { + return this.getRuleContext(0, Any_name_listContext); + } + public KW_ADD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ADD, 0); + } + public KW_REPLACE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REPLACE, 0); + } + public KW_DROP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DROP, 0); } - public KW_ALL(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ALL, 0)!; + public opt_if_exists(): Opt_if_existsContext | null { + return this.getRuleContext(0, Opt_if_existsContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_all_clause; + return PostgreSqlParser.RULE_altertsconfigurationstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_all_clause) { - listener.enterOpt_all_clause(this); + if(listener.enterAltertsconfigurationstmt) { + listener.enterAltertsconfigurationstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_all_clause) { - listener.exitOpt_all_clause(this); + if(listener.exitAltertsconfigurationstmt) { + listener.exitAltertsconfigurationstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_all_clause) { - return visitor.visitOpt_all_clause(this); + if (visitor.visitAltertsconfigurationstmt) { + return visitor.visitAltertsconfigurationstmt(this); } else { return visitor.visitChildren(this); } @@ -98557,65 +73990,62 @@ export class Opt_all_clauseContext extends antlr.ParserRuleContext { } -export class Opt_sort_clauseContext extends antlr.ParserRuleContext { +export class CreateconversionstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public sort_clause(): Sort_clauseContext { - return this.getRuleContext(0, Sort_clauseContext)!; + public KW_CREATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CREATE, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_sort_clause; + public KW_CONVERSION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CONVERSION, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_sort_clause) { - listener.enterOpt_sort_clause(this); + public any_name(): Any_nameContext[]; + public any_name(i: number): Any_nameContext | null; + public any_name(i?: number): Any_nameContext[] | Any_nameContext | null { + if (i === undefined) { + return this.getRuleContexts(Any_nameContext); } + + return this.getRuleContext(i, Any_nameContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_sort_clause) { - listener.exitOpt_sort_clause(this); - } + public KW_FOR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOR, 0)!; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_sort_clause) { - return visitor.visitOpt_sort_clause(this); - } else { - return visitor.visitChildren(this); + public sconst(): SconstContext[]; + public sconst(i: number): SconstContext | null; + public sconst(i?: number): SconstContext[] | SconstContext | null { + if (i === undefined) { + return this.getRuleContexts(SconstContext); } - } -} - -export class Sort_clauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, SconstContext); } - public KW_ORDER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ORDER, 0)!; + public KW_TO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TO, 0)!; } - public KW_BY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BY, 0)!; + public KW_FROM(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FROM, 0)!; } - public sortby_list(): Sortby_listContext { - return this.getRuleContext(0, Sortby_listContext)!; + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_sort_clause; + return PostgreSqlParser.RULE_createconversionstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSort_clause) { - listener.enterSort_clause(this); + if(listener.enterCreateconversionstmt) { + listener.enterCreateconversionstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSort_clause) { - listener.exitSort_clause(this); + if(listener.exitCreateconversionstmt) { + listener.exitCreateconversionstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSort_clause) { - return visitor.visitSort_clause(this); + if (visitor.visitCreateconversionstmt) { + return visitor.visitCreateconversionstmt(this); } else { return visitor.visitChildren(this); } @@ -98623,18 +74053,33 @@ export class Sort_clauseContext extends antlr.ParserRuleContext { } -export class Sortby_listContext extends antlr.ParserRuleContext { +export class ClusterstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public sortby(): SortbyContext[]; - public sortby(i: number): SortbyContext | null; - public sortby(i?: number): SortbyContext[] | SortbyContext | null { + public KW_CLUSTER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CLUSTER, 0)!; + } + public opt_verbose(): Opt_verboseContext[]; + public opt_verbose(i: number): Opt_verboseContext | null; + public opt_verbose(i?: number): Opt_verboseContext[] | Opt_verboseContext | null { if (i === undefined) { - return this.getRuleContexts(SortbyContext); + return this.getRuleContexts(Opt_verboseContext); } - return this.getRuleContext(i, SortbyContext); + return this.getRuleContext(i, Opt_verboseContext); + } + public table_name(): Table_nameContext | null { + return this.getRuleContext(0, Table_nameContext); + } + public table_access_method_clause(): Table_access_method_clauseContext | null { + return this.getRuleContext(0, Table_access_method_clauseContext); + } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -98646,21 +74091,21 @@ export class Sortby_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_sortby_list; + return PostgreSqlParser.RULE_clusterstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSortby_list) { - listener.enterSortby_list(this); + if(listener.enterClusterstmt) { + listener.enterClusterstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSortby_list) { - listener.exitSortby_list(this); + if(listener.exitClusterstmt) { + listener.exitClusterstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSortby_list) { - return visitor.visitSortby_list(this); + if (visitor.visitClusterstmt) { + return visitor.visitClusterstmt(this); } else { return visitor.visitChildren(this); } @@ -98668,41 +74113,47 @@ export class Sortby_listContext extends antlr.ParserRuleContext { } -export class SortbyContext extends antlr.ParserRuleContext { +export class VacuumstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public column_expr_noparen(): Column_expr_noparenContext { - return this.getRuleContext(0, Column_expr_noparenContext)!; + public KW_VACUUM(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_VACUUM, 0)!; } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); + public vacuum_relation_list(): Vacuum_relation_listContext | null { + return this.getRuleContext(0, Vacuum_relation_listContext); } - public qual_all_op(): Qual_all_opContext | null { - return this.getRuleContext(0, Qual_all_opContext); + public explain_option_list(): Explain_option_listContext | null { + return this.getRuleContext(0, Explain_option_listContext); } - public opt_asc_desc(): Opt_asc_descContext | null { - return this.getRuleContext(0, Opt_asc_descContext); + public KW_FULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FULL, 0); + } + public KW_FREEZE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FREEZE, 0); + } + public opt_verbose(): Opt_verboseContext | null { + return this.getRuleContext(0, Opt_verboseContext); } - public opt_nulls_order(): Opt_nulls_orderContext | null { - return this.getRuleContext(0, Opt_nulls_orderContext); + public analyze_keyword(): Analyze_keywordContext | null { + return this.getRuleContext(0, Analyze_keywordContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_sortby; + return PostgreSqlParser.RULE_vacuumstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSortby) { - listener.enterSortby(this); + if(listener.enterVacuumstmt) { + listener.enterVacuumstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSortby) { - listener.exitSortby(this); + if(listener.exitVacuumstmt) { + listener.exitVacuumstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSortby) { - return visitor.visitSortby(this); + if (visitor.visitVacuumstmt) { + return visitor.visitVacuumstmt(this); } else { return visitor.visitChildren(this); } @@ -98710,35 +74161,59 @@ export class SortbyContext extends antlr.ParserRuleContext { } -export class Select_limitContext extends antlr.ParserRuleContext { +export class AnalyzestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public limit_clause(): Limit_clauseContext | null { - return this.getRuleContext(0, Limit_clauseContext); + public analyze_keyword(): Analyze_keywordContext { + return this.getRuleContext(0, Analyze_keywordContext)!; } - public offset_clause(): Offset_clauseContext | null { - return this.getRuleContext(0, Offset_clauseContext); + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public fetch_clause(): Fetch_clauseContext | null { - return this.getRuleContext(0, Fetch_clauseContext); + public analyze_option_elem(): Analyze_option_elemContext[]; + public analyze_option_elem(i: number): Analyze_option_elemContext | null; + public analyze_option_elem(i?: number): Analyze_option_elemContext[] | Analyze_option_elemContext | null { + if (i === undefined) { + return this.getRuleContexts(Analyze_option_elemContext); + } + + return this.getRuleContext(i, Analyze_option_elemContext); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + } + public vacuum_relation_list(): Vacuum_relation_listContext | null { + return this.getRuleContext(0, Vacuum_relation_listContext); + } + public opt_verbose(): Opt_verboseContext | null { + return this.getRuleContext(0, Opt_verboseContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_select_limit; + return PostgreSqlParser.RULE_analyzestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSelect_limit) { - listener.enterSelect_limit(this); + if(listener.enterAnalyzestmt) { + listener.enterAnalyzestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSelect_limit) { - listener.exitSelect_limit(this); + if(listener.exitAnalyzestmt) { + listener.exitAnalyzestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSelect_limit) { - return visitor.visitSelect_limit(this); + if (visitor.visitAnalyzestmt) { + return visitor.visitAnalyzestmt(this); } else { return visitor.visitChildren(this); } @@ -98746,29 +74221,32 @@ export class Select_limitContext extends antlr.ParserRuleContext { } -export class Opt_select_limitContext extends antlr.ParserRuleContext { +export class Analyze_keywordContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public select_limit(): Select_limitContext { - return this.getRuleContext(0, Select_limitContext)!; + public KW_ANALYZE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ANALYZE, 0); + } + public KW_ANALYSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ANALYSE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_select_limit; + return PostgreSqlParser.RULE_analyze_keyword; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_select_limit) { - listener.enterOpt_select_limit(this); + if(listener.enterAnalyze_keyword) { + listener.enterAnalyze_keyword(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_select_limit) { - listener.exitOpt_select_limit(this); + if(listener.exitAnalyze_keyword) { + listener.exitAnalyze_keyword(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_select_limit) { - return visitor.visitOpt_select_limit(this); + if (visitor.visitAnalyze_keyword) { + return visitor.visitAnalyze_keyword(this); } else { return visitor.visitChildren(this); } @@ -98776,38 +74254,38 @@ export class Opt_select_limitContext extends antlr.ParserRuleContext { } -export class Limit_clauseContext extends antlr.ParserRuleContext { +export class Vac_analyze_option_elemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_LIMIT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_LIMIT, 0)!; + public nonreservedword(): NonreservedwordContext | null { + return this.getRuleContext(0, NonreservedwordContext); } - public select_limit_value(): Select_limit_valueContext { - return this.getRuleContext(0, Select_limit_valueContext)!; + public analyze_keyword(): Analyze_keywordContext | null { + return this.getRuleContext(0, Analyze_keywordContext); } - public COMMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.COMMA, 0); + public opt_boolean_or_string(): Opt_boolean_or_stringContext | null { + return this.getRuleContext(0, Opt_boolean_or_stringContext); } - public select_offset_value(): Select_offset_valueContext | null { - return this.getRuleContext(0, Select_offset_valueContext); + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_limit_clause; + return PostgreSqlParser.RULE_vac_analyze_option_elem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterLimit_clause) { - listener.enterLimit_clause(this); + if(listener.enterVac_analyze_option_elem) { + listener.enterVac_analyze_option_elem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitLimit_clause) { - listener.exitLimit_clause(this); + if(listener.exitVac_analyze_option_elem) { + listener.exitVac_analyze_option_elem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitLimit_clause) { - return visitor.visitLimit_clause(this); + if (visitor.visitVac_analyze_option_elem) { + return visitor.visitVac_analyze_option_elem(this); } else { return visitor.visitChildren(this); } @@ -98815,47 +74293,47 @@ export class Limit_clauseContext extends antlr.ParserRuleContext { } -export class Fetch_clauseContext extends antlr.ParserRuleContext { +export class Analyze_option_elemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FETCH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FETCH, 0)!; + public KW_SKIP_LOCKED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SKIP_LOCKED, 0); } - public first_or_next(): First_or_nextContext { - return this.getRuleContext(0, First_or_nextContext)!; + public KW_VERBOSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VERBOSE, 0); } - public select_fetch_first_value(): Select_fetch_first_valueContext | null { - return this.getRuleContext(0, Select_fetch_first_valueContext); + public KW_FALSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FALSE, 0); } - public row_or_rows(): Row_or_rowsContext | null { - return this.getRuleContext(0, Row_or_rowsContext); + public KW_TRUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRUE, 0); } - public KW_ONLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ONLY, 0); + public KW_BUFFER_USAGE_LIMIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BUFFER_USAGE_LIMIT, 0); } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); + public numericonly(): NumericonlyContext | null { + return this.getRuleContext(0, NumericonlyContext); } - public KW_TIES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TIES, 0); + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_fetch_clause; + return PostgreSqlParser.RULE_analyze_option_elem; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFetch_clause) { - listener.enterFetch_clause(this); + if(listener.enterAnalyze_option_elem) { + listener.enterAnalyze_option_elem(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFetch_clause) { - listener.exitFetch_clause(this); + if(listener.exitAnalyze_option_elem) { + listener.exitAnalyze_option_elem(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFetch_clause) { - return visitor.visitFetch_clause(this); + if (visitor.visitAnalyze_option_elem) { + return visitor.visitAnalyze_option_elem(this); } else { return visitor.visitChildren(this); } @@ -98863,38 +74341,35 @@ export class Fetch_clauseContext extends antlr.ParserRuleContext { } -export class Offset_clauseContext extends antlr.ParserRuleContext { +export class Opt_verboseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_OFFSET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OFFSET, 0)!; - } - public select_fetch_first_value(): Select_fetch_first_valueContext | null { - return this.getRuleContext(0, Select_fetch_first_valueContext); + public KW_VERBOSE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_VERBOSE, 0)!; } - public row_or_rows(): Row_or_rowsContext | null { - return this.getRuleContext(0, Row_or_rowsContext); + public KW_FALSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FALSE, 0); } - public select_offset_value(): Select_offset_valueContext | null { - return this.getRuleContext(0, Select_offset_valueContext); + public KW_TRUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRUE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_offset_clause; + return PostgreSqlParser.RULE_opt_verbose; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOffset_clause) { - listener.enterOffset_clause(this); + if(listener.enterOpt_verbose) { + listener.enterOpt_verbose(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOffset_clause) { - listener.exitOffset_clause(this); + if(listener.exitOpt_verbose) { + listener.exitOpt_verbose(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOffset_clause) { - return visitor.visitOffset_clause(this); + if (visitor.visitOpt_verbose) { + return visitor.visitOpt_verbose(this); } else { return visitor.visitChildren(this); } @@ -98902,32 +74377,32 @@ export class Offset_clauseContext extends antlr.ParserRuleContext { } -export class Select_limit_valueContext extends antlr.ParserRuleContext { +export class Vacuum_relationContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public table_name(): Table_nameContext { + return this.getRuleContext(0, Table_nameContext)!; } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); + public opt_column_list(): Opt_column_listContext | null { + return this.getRuleContext(0, Opt_column_listContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_select_limit_value; + return PostgreSqlParser.RULE_vacuum_relation; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSelect_limit_value) { - listener.enterSelect_limit_value(this); + if(listener.enterVacuum_relation) { + listener.enterVacuum_relation(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSelect_limit_value) { - listener.exitSelect_limit_value(this); + if(listener.exitVacuum_relation) { + listener.exitVacuum_relation(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSelect_limit_value) { - return visitor.visitSelect_limit_value(this); + if (visitor.visitVacuum_relation) { + return visitor.visitVacuum_relation(this); } else { return visitor.visitChildren(this); } @@ -98935,29 +74410,44 @@ export class Select_limit_valueContext extends antlr.ParserRuleContext { } -export class Select_offset_valueContext extends antlr.ParserRuleContext { +export class Vacuum_relation_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; + public vacuum_relation(): Vacuum_relationContext[]; + public vacuum_relation(i: number): Vacuum_relationContext | null; + public vacuum_relation(i?: number): Vacuum_relationContext[] | Vacuum_relationContext | null { + if (i === undefined) { + return this.getRuleContexts(Vacuum_relationContext); + } + + return this.getRuleContext(i, Vacuum_relationContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_select_offset_value; + return PostgreSqlParser.RULE_vacuum_relation_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSelect_offset_value) { - listener.enterSelect_offset_value(this); + if(listener.enterVacuum_relation_list) { + listener.enterVacuum_relation_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSelect_offset_value) { - listener.exitSelect_offset_value(this); + if(listener.exitVacuum_relation_list) { + listener.exitVacuum_relation_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSelect_offset_value) { - return visitor.visitSelect_offset_value(this); + if (visitor.visitVacuum_relation_list) { + return visitor.visitVacuum_relation_list(this); } else { return visitor.visitChildren(this); } @@ -98965,71 +74455,98 @@ export class Select_offset_valueContext extends antlr.ParserRuleContext { } -export class Select_fetch_first_valueContext extends antlr.ParserRuleContext { +export class ExplainstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public PLUS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.PLUS, 0); + public KW_EXPLAIN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EXPLAIN, 0)!; } - public i_or_f_const(): I_or_f_constContext | null { - return this.getRuleContext(0, I_or_f_constContext); + public explainablestmt(): ExplainablestmtContext { + return this.getRuleContext(0, ExplainablestmtContext)!; } - public MINUS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.MINUS, 0); + public explain_option_list(): Explain_option_listContext | null { + return this.getRuleContext(0, Explain_option_listContext); + } + public KW_VERBOSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VERBOSE, 0); + } + public analyze_keyword(): Analyze_keywordContext | null { + return this.getRuleContext(0, Analyze_keywordContext); } - public c_expr(): C_exprContext | null { - return this.getRuleContext(0, C_exprContext); + public opt_verbose(): Opt_verboseContext | null { + return this.getRuleContext(0, Opt_verboseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_select_fetch_first_value; + return PostgreSqlParser.RULE_explainstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSelect_fetch_first_value) { - listener.enterSelect_fetch_first_value(this); + if(listener.enterExplainstmt) { + listener.enterExplainstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSelect_fetch_first_value) { - listener.exitSelect_fetch_first_value(this); + if(listener.exitExplainstmt) { + listener.exitExplainstmt(this); + } + } + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitExplainstmt) { + return visitor.visitExplainstmt(this); + } else { + return visitor.visitChildren(this); } } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSelect_fetch_first_value) { - return visitor.visitSelect_fetch_first_value(this); - } else { - return visitor.visitChildren(this); - } +} + + +export class ExplainablestmtContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public selectstmt(): SelectstmtContext | null { + return this.getRuleContext(0, SelectstmtContext); + } + public insertstmt(): InsertstmtContext | null { + return this.getRuleContext(0, InsertstmtContext); + } + public updatestmt(): UpdatestmtContext | null { + return this.getRuleContext(0, UpdatestmtContext); + } + public deletestmt(): DeletestmtContext | null { + return this.getRuleContext(0, DeletestmtContext); + } + public declarecursorstmt(): DeclarecursorstmtContext | null { + return this.getRuleContext(0, DeclarecursorstmtContext); + } + public createasstmt(): CreateasstmtContext | null { + return this.getRuleContext(0, CreateasstmtContext); } -} - - -export class I_or_f_constContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public creatematviewstmt(): CreatematviewstmtContext | null { + return this.getRuleContext(0, CreatematviewstmtContext); } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); + public refreshmatviewstmt(): RefreshmatviewstmtContext | null { + return this.getRuleContext(0, RefreshmatviewstmtContext); } - public fconst(): FconstContext | null { - return this.getRuleContext(0, FconstContext); + public executestmt(): ExecutestmtContext | null { + return this.getRuleContext(0, ExecutestmtContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_i_or_f_const; + return PostgreSqlParser.RULE_explainablestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterI_or_f_const) { - listener.enterI_or_f_const(this); + if(listener.enterExplainablestmt) { + listener.enterExplainablestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitI_or_f_const) { - listener.exitI_or_f_const(this); + if(listener.exitExplainablestmt) { + listener.exitExplainablestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitI_or_f_const) { - return visitor.visitI_or_f_const(this); + if (visitor.visitExplainablestmt) { + return visitor.visitExplainablestmt(this); } else { return visitor.visitChildren(this); } @@ -99037,32 +74554,50 @@ export class I_or_f_constContext extends antlr.ParserRuleContext { } -export class Row_or_rowsContext extends antlr.ParserRuleContext { +export class Explain_option_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ROW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROW, 0); + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public KW_ROWS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROWS, 0); + public vac_analyze_option_elem(): Vac_analyze_option_elemContext[]; + public vac_analyze_option_elem(i: number): Vac_analyze_option_elemContext | null; + public vac_analyze_option_elem(i?: number): Vac_analyze_option_elemContext[] | Vac_analyze_option_elemContext | null { + if (i === undefined) { + return this.getRuleContexts(Vac_analyze_option_elemContext); + } + + return this.getRuleContext(i, Vac_analyze_option_elemContext); + } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_row_or_rows; + return PostgreSqlParser.RULE_explain_option_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRow_or_rows) { - listener.enterRow_or_rows(this); + if(listener.enterExplain_option_list) { + listener.enterExplain_option_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRow_or_rows) { - listener.exitRow_or_rows(this); + if(listener.exitExplain_option_list) { + listener.exitExplain_option_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRow_or_rows) { - return visitor.visitRow_or_rows(this); + if (visitor.visitExplain_option_list) { + return visitor.visitExplain_option_list(this); } else { return visitor.visitChildren(this); } @@ -99070,32 +74605,41 @@ export class Row_or_rowsContext extends antlr.ParserRuleContext { } -export class First_or_nextContext extends antlr.ParserRuleContext { +export class PreparestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FIRST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FIRST, 0); + public KW_PREPARE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_PREPARE, 0)!; } - public KW_NEXT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NEXT, 0); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; + } + public KW_AS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_AS, 0)!; + } + public preparablestmt(): PreparablestmtContext { + return this.getRuleContext(0, PreparablestmtContext)!; + } + public prep_type_clause(): Prep_type_clauseContext | null { + return this.getRuleContext(0, Prep_type_clauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_first_or_next; + return PostgreSqlParser.RULE_preparestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFirst_or_next) { - listener.enterFirst_or_next(this); + if(listener.enterPreparestmt) { + listener.enterPreparestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFirst_or_next) { - listener.exitFirst_or_next(this); + if(listener.exitPreparestmt) { + listener.exitPreparestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFirst_or_next) { - return visitor.visitFirst_or_next(this); + if (visitor.visitPreparestmt) { + return visitor.visitPreparestmt(this); } else { return visitor.visitChildren(this); } @@ -99103,38 +74647,50 @@ export class First_or_nextContext extends antlr.ParserRuleContext { } -export class Group_clauseContext extends antlr.ParserRuleContext { +export class Prep_type_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_GROUP(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_GROUP, 0)!; + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public KW_BY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BY, 0)!; + public typename(): TypenameContext[]; + public typename(i: number): TypenameContext | null; + public typename(i?: number): TypenameContext[] | TypenameContext | null { + if (i === undefined) { + return this.getRuleContexts(TypenameContext); + } + + return this.getRuleContext(i, TypenameContext); } - public group_by_list(): Group_by_listContext { - return this.getRuleContext(0, Group_by_listContext)!; + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public all_or_distinct(): All_or_distinctContext | null { - return this.getRuleContext(0, All_or_distinctContext); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_group_clause; + return PostgreSqlParser.RULE_prep_type_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGroup_clause) { - listener.enterGroup_clause(this); + if(listener.enterPrep_type_clause) { + listener.enterPrep_type_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGroup_clause) { - listener.exitGroup_clause(this); + if(listener.exitPrep_type_clause) { + listener.exitPrep_type_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGroup_clause) { - return visitor.visitGroup_clause(this); + if (visitor.visitPrep_type_clause) { + return visitor.visitPrep_type_clause(this); } else { return visitor.visitChildren(this); } @@ -99142,44 +74698,38 @@ export class Group_clauseContext extends antlr.ParserRuleContext { } -export class Group_by_listContext extends antlr.ParserRuleContext { +export class PreparablestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public group_by_item(): Group_by_itemContext[]; - public group_by_item(i: number): Group_by_itemContext | null; - public group_by_item(i?: number): Group_by_itemContext[] | Group_by_itemContext | null { - if (i === undefined) { - return this.getRuleContexts(Group_by_itemContext); - } - - return this.getRuleContext(i, Group_by_itemContext); + public selectstmt(): SelectstmtContext | null { + return this.getRuleContext(0, SelectstmtContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public insertstmt(): InsertstmtContext | null { + return this.getRuleContext(0, InsertstmtContext); + } + public updatestmt(): UpdatestmtContext | null { + return this.getRuleContext(0, UpdatestmtContext); + } + public deletestmt(): DeletestmtContext | null { + return this.getRuleContext(0, DeletestmtContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_group_by_list; + return PostgreSqlParser.RULE_preparablestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGroup_by_list) { - listener.enterGroup_by_list(this); + if(listener.enterPreparablestmt) { + listener.enterPreparablestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGroup_by_list) { - listener.exitGroup_by_list(this); + if(listener.exitPreparablestmt) { + listener.exitPreparablestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGroup_by_list) { - return visitor.visitGroup_by_list(this); + if (visitor.visitPreparablestmt) { + return visitor.visitPreparablestmt(this); } else { return visitor.visitChildren(this); } @@ -99187,50 +74737,56 @@ export class Group_by_listContext extends antlr.ParserRuleContext { } -export class Group_by_itemContext extends antlr.ParserRuleContext { +export class ExecutestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public column_expr_noparen(): Column_expr_noparenContext | null { - return this.getRuleContext(0, Column_expr_noparenContext); + public KW_EXECUTE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EXECUTE, 0)!; } - public empty_grouping_set(): Empty_grouping_setContext | null { - return this.getRuleContext(0, Empty_grouping_setContext); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public cube_clause(): Cube_clauseContext | null { - return this.getRuleContext(0, Cube_clauseContext); + public execute_param_clause(): Execute_param_clauseContext | null { + return this.getRuleContext(0, Execute_param_clauseContext); } - public rollup_clause(): Rollup_clauseContext | null { - return this.getRuleContext(0, Rollup_clauseContext); + public KW_CREATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CREATE, 0); } - public grouping_sets_clause(): Grouping_sets_clauseContext | null { - return this.getRuleContext(0, Grouping_sets_clauseContext); + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public create_as_target(): Create_as_targetContext | null { + return this.getRuleContext(0, Create_as_targetContext); } - public column_expr_list_noparen(): Column_expr_list_noparenContext | null { - return this.getRuleContext(0, Column_expr_list_noparenContext); + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public opttemp(): OpttempContext | null { + return this.getRuleContext(0, OpttempContext); + } + public opt_if_not_exists(): Opt_if_not_existsContext | null { + return this.getRuleContext(0, Opt_if_not_existsContext); + } + public opt_with_data(): Opt_with_dataContext | null { + return this.getRuleContext(0, Opt_with_dataContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_group_by_item; + return PostgreSqlParser.RULE_executestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGroup_by_item) { - listener.enterGroup_by_item(this); + if(listener.enterExecutestmt) { + listener.enterExecutestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGroup_by_item) { - listener.exitGroup_by_item(this); + if(listener.exitExecutestmt) { + listener.exitExecutestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGroup_by_item) { - return visitor.visitGroup_by_item(this); + if (visitor.visitExecutestmt) { + return visitor.visitExecutestmt(this); } else { return visitor.visitChildren(this); } @@ -99238,32 +74794,35 @@ export class Group_by_itemContext extends antlr.ParserRuleContext { } -export class Empty_grouping_setContext extends antlr.ParserRuleContext { +export class Execute_param_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } public OPEN_PAREN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } + public expr_list(): Expr_listContext { + return this.getRuleContext(0, Expr_listContext)!; + } public CLOSE_PAREN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_empty_grouping_set; + return PostgreSqlParser.RULE_execute_param_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterEmpty_grouping_set) { - listener.enterEmpty_grouping_set(this); + if(listener.enterExecute_param_clause) { + listener.enterExecute_param_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitEmpty_grouping_set) { - listener.exitEmpty_grouping_set(this); + if(listener.exitExecute_param_clause) { + listener.exitExecute_param_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitEmpty_grouping_set) { - return visitor.visitEmpty_grouping_set(this); + if (visitor.visitExecute_param_clause) { + return visitor.visitExecute_param_clause(this); } else { return visitor.visitChildren(this); } @@ -99271,38 +74830,38 @@ export class Empty_grouping_setContext extends antlr.ParserRuleContext { } -export class Rollup_clauseContext extends antlr.ParserRuleContext { +export class DeallocatestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ROLLUP(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ROLLUP, 0)!; + public KW_DEALLOCATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DEALLOCATE, 0)!; } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public column_expr_list_noparen(): Column_expr_list_noparenContext { - return this.getRuleContext(0, Column_expr_list_noparenContext)!; + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public KW_PREPARE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PREPARE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_rollup_clause; + return PostgreSqlParser.RULE_deallocatestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRollup_clause) { - listener.enterRollup_clause(this); + if(listener.enterDeallocatestmt) { + listener.enterDeallocatestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRollup_clause) { - listener.exitRollup_clause(this); + if(listener.exitDeallocatestmt) { + listener.exitDeallocatestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRollup_clause) { - return visitor.visitRollup_clause(this); + if (visitor.visitDeallocatestmt) { + return visitor.visitDeallocatestmt(this); } else { return visitor.visitChildren(this); } @@ -99310,38 +74869,107 @@ export class Rollup_clauseContext extends antlr.ParserRuleContext { } -export class Cube_clauseContext extends antlr.ParserRuleContext { +export class InsertstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CUBE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CUBE, 0)!; + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_insertstmt; } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public override copyFrom(ctx: InsertstmtContext): void { + super.copyFrom(ctx); } - public column_expr_list_noparen(): Column_expr_list_noparenContext { - return this.getRuleContext(0, Column_expr_list_noparenContext)!; +} +export class InsertStatementContext extends InsertstmtContext { + public constructor(ctx: InsertstmtContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public KW_INSERT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_INSERT, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_cube_clause; + public KW_INTO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_INTO, 0)!; + } + public table_name(): Table_nameContext { + return this.getRuleContext(0, Table_nameContext)!; + } + public insert_rest(): Insert_restContext { + return this.getRuleContext(0, Insert_restContext)!; + } + public with_clause(): With_clauseContext | null { + return this.getRuleContext(0, With_clauseContext); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); + } + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { + if (i === undefined) { + return this.getRuleContexts(ColidContext); + } + + return this.getRuleContext(i, ColidContext); + } + public KW_ON(): antlr.TerminalNode[]; + public KW_ON(i: number): antlr.TerminalNode | null; + public KW_ON(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_ON); + } else { + return this.getToken(PostgreSqlParser.KW_ON, i); + } + } + public KW_CONFLICT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONFLICT, 0); + } + public KW_DO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DO, 0); + } + public returning_clause(): Returning_clauseContext | null { + return this.getRuleContext(0, Returning_clauseContext); + } + public KW_UPDATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UPDATE, 0); + } + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); + } + public set_clause_list(): Set_clause_listContext | null { + return this.getRuleContext(0, Set_clause_listContext); + } + public KW_NOTHING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOTHING, 0); + } + public index_params(): Index_paramsContext | null { + return this.getRuleContext(0, Index_paramsContext); + } + public KW_CONSTRAINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); + } + public where_clause(): Where_clauseContext[]; + public where_clause(i: number): Where_clauseContext | null; + public where_clause(i?: number): Where_clauseContext[] | Where_clauseContext | null { + if (i === undefined) { + return this.getRuleContexts(Where_clauseContext); + } + + return this.getRuleContext(i, Where_clauseContext); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCube_clause) { - listener.enterCube_clause(this); + if(listener.enterInsertStatement) { + listener.enterInsertStatement(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCube_clause) { - listener.exitCube_clause(this); + if(listener.exitInsertStatement) { + listener.exitInsertStatement(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCube_clause) { - return visitor.visitCube_clause(this); + if (visitor.visitInsertStatement) { + return visitor.visitInsertStatement(this); } else { return visitor.visitChildren(this); } @@ -99349,41 +74977,53 @@ export class Cube_clauseContext extends antlr.ParserRuleContext { } -export class Grouping_sets_clauseContext extends antlr.ParserRuleContext { +export class Insert_restContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_GROUPING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_GROUPING, 0)!; + public default_values_or_values(): Default_values_or_valuesContext | null { + return this.getRuleContext(0, Default_values_or_valuesContext); } - public KW_SETS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SETS, 0)!; + public selectstmt(): SelectstmtContext | null { + return this.getRuleContext(0, SelectstmtContext); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public group_by_list(): Group_by_listContext { - return this.getRuleContext(0, Group_by_listContext)!; + public insert_column_list(): Insert_column_listContext | null { + return this.getRuleContext(0, Insert_column_listContext); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + } + public KW_OVERRIDING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OVERRIDING, 0); + } + public KW_VALUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALUE, 0); + } + public KW_USER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USER, 0); + } + public KW_SYSTEM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SYSTEM, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_grouping_sets_clause; + return PostgreSqlParser.RULE_insert_rest; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGrouping_sets_clause) { - listener.enterGrouping_sets_clause(this); + if(listener.enterInsert_rest) { + listener.enterInsert_rest(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGrouping_sets_clause) { - listener.exitGrouping_sets_clause(this); + if(listener.exitInsert_rest) { + listener.exitInsert_rest(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGrouping_sets_clause) { - return visitor.visitGrouping_sets_clause(this); + if (visitor.visitInsert_rest) { + return visitor.visitInsert_rest(this); } else { return visitor.visitChildren(this); } @@ -99391,32 +75031,44 @@ export class Grouping_sets_clauseContext extends antlr.ParserRuleContext { } -export class Having_clauseContext extends antlr.ParserRuleContext { +export class Insert_column_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_HAVING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_HAVING, 0)!; + public insert_column_item(): Insert_column_itemContext[]; + public insert_column_item(i: number): Insert_column_itemContext | null; + public insert_column_item(i?: number): Insert_column_itemContext[] | Insert_column_itemContext | null { + if (i === undefined) { + return this.getRuleContexts(Insert_column_itemContext); + } + + return this.getRuleContext(i, Insert_column_itemContext); } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_having_clause; + return PostgreSqlParser.RULE_insert_column_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterHaving_clause) { - listener.enterHaving_clause(this); + if(listener.enterInsert_column_list) { + listener.enterInsert_column_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitHaving_clause) { - listener.exitHaving_clause(this); + if(listener.exitInsert_column_list) { + listener.exitInsert_column_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitHaving_clause) { - return visitor.visitHaving_clause(this); + if (visitor.visitInsert_column_list) { + return visitor.visitInsert_column_list(this); } else { return visitor.visitChildren(this); } @@ -99424,38 +75076,32 @@ export class Having_clauseContext extends antlr.ParserRuleContext { } -export class For_locking_clauseContext extends antlr.ParserRuleContext { +export class Insert_column_itemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public for_locking_items(): For_locking_itemsContext | null { - return this.getRuleContext(0, For_locking_itemsContext); - } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); - } - public KW_READ(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_READ, 0); + public column_name(): Column_nameContext { + return this.getRuleContext(0, Column_nameContext)!; } - public KW_ONLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ONLY, 0); + public opt_indirection(): Opt_indirectionContext { + return this.getRuleContext(0, Opt_indirectionContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_for_locking_clause; + return PostgreSqlParser.RULE_insert_column_item; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFor_locking_clause) { - listener.enterFor_locking_clause(this); + if(listener.enterInsert_column_item) { + listener.enterInsert_column_item(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFor_locking_clause) { - listener.exitFor_locking_clause(this); + if(listener.exitInsert_column_item) { + listener.exitInsert_column_item(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFor_locking_clause) { - return visitor.visitFor_locking_clause(this); + if (visitor.visitInsert_column_item) { + return visitor.visitInsert_column_item(this); } else { return visitor.visitChildren(this); } @@ -99463,29 +75109,32 @@ export class For_locking_clauseContext extends antlr.ParserRuleContext { } -export class Opt_for_locking_clauseContext extends antlr.ParserRuleContext { +export class Returning_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public for_locking_clause(): For_locking_clauseContext { - return this.getRuleContext(0, For_locking_clauseContext)!; + public KW_RETURNING(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_RETURNING, 0)!; + } + public target_list(): Target_listContext { + return this.getRuleContext(0, Target_listContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_for_locking_clause; + return PostgreSqlParser.RULE_returning_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_for_locking_clause) { - listener.enterOpt_for_locking_clause(this); + if(listener.enterReturning_clause) { + listener.enterReturning_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_for_locking_clause) { - listener.exitOpt_for_locking_clause(this); + if(listener.exitReturning_clause) { + listener.exitReturning_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_for_locking_clause) { - return visitor.visitOpt_for_locking_clause(this); + if (visitor.visitReturning_clause) { + return visitor.visitReturning_clause(this); } else { return visitor.visitChildren(this); } @@ -99493,35 +75142,50 @@ export class Opt_for_locking_clauseContext extends antlr.ParserRuleContext { } -export class For_locking_itemsContext extends antlr.ParserRuleContext { +export class DeletestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public for_locking_item(): For_locking_itemContext[]; - public for_locking_item(i: number): For_locking_itemContext | null; - public for_locking_item(i?: number): For_locking_itemContext[] | For_locking_itemContext | null { - if (i === undefined) { - return this.getRuleContexts(For_locking_itemContext); - } - - return this.getRuleContext(i, For_locking_itemContext); + public KW_DELETE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DELETE, 0)!; + } + public KW_FROM(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FROM, 0)!; + } + public relation_expr_opt_alias(): Relation_expr_opt_aliasContext { + return this.getRuleContext(0, Relation_expr_opt_aliasContext)!; + } + public with_clause(): With_clauseContext | null { + return this.getRuleContext(0, With_clauseContext); + } + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USING, 0); + } + public from_list(): From_listContext | null { + return this.getRuleContext(0, From_listContext); + } + public where_or_current_clause(): Where_or_current_clauseContext | null { + return this.getRuleContext(0, Where_or_current_clauseContext); + } + public returning_clause(): Returning_clauseContext | null { + return this.getRuleContext(0, Returning_clauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_for_locking_items; + return PostgreSqlParser.RULE_deletestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFor_locking_items) { - listener.enterFor_locking_items(this); + if(listener.enterDeletestmt) { + listener.enterDeletestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFor_locking_items) { - listener.exitFor_locking_items(this); + if(listener.exitDeletestmt) { + listener.exitDeletestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFor_locking_items) { - return visitor.visitFor_locking_items(this); + if (visitor.visitDeletestmt) { + return visitor.visitDeletestmt(this); } else { return visitor.visitChildren(this); } @@ -99529,35 +75193,59 @@ export class For_locking_itemsContext extends antlr.ParserRuleContext { } -export class For_locking_itemContext extends antlr.ParserRuleContext { +export class LockstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public for_locking_strength(): For_locking_strengthContext { - return this.getRuleContext(0, For_locking_strengthContext)!; + public KW_LOCK(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_LOCK, 0)!; + } + public relation_expr_list(): Relation_expr_listContext { + return this.getRuleContext(0, Relation_expr_listContext)!; + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); + } + public KW_MODE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MODE, 0); + } + public KW_NOWAIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOWAIT, 0); + } + public KW_SHARE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SHARE, 0); + } + public KW_EXCLUSIVE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXCLUSIVE, 0); + } + public KW_ACCESS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ACCESS, 0); } - public locked_rels_list(): Locked_rels_listContext | null { - return this.getRuleContext(0, Locked_rels_listContext); + public KW_ROW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROW, 0); } - public opt_nowait_or_skip(): Opt_nowait_or_skipContext | null { - return this.getRuleContext(0, Opt_nowait_or_skipContext); + public KW_UPDATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UPDATE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_for_locking_item; + return PostgreSqlParser.RULE_lockstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFor_locking_item) { - listener.enterFor_locking_item(this); + if(listener.enterLockstmt) { + listener.enterLockstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFor_locking_item) { - listener.exitFor_locking_item(this); + if(listener.exitLockstmt) { + listener.exitLockstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFor_locking_item) { - return visitor.visitFor_locking_item(this); + if (visitor.visitLockstmt) { + return visitor.visitLockstmt(this); } else { return visitor.visitChildren(this); } @@ -99565,41 +75253,50 @@ export class For_locking_itemContext extends antlr.ParserRuleContext { } -export class For_locking_strengthContext extends antlr.ParserRuleContext { +export class UpdatestmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; + public KW_UPDATE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_UPDATE, 0)!; + } + public relation_expr_opt_alias(): Relation_expr_opt_aliasContext { + return this.getRuleContext(0, Relation_expr_opt_aliasContext)!; + } + public KW_SET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SET, 0)!; } - public KW_UPDATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UPDATE, 0); + public set_clause_list(): Set_clause_listContext { + return this.getRuleContext(0, Set_clause_listContext)!; } - public KW_SHARE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SHARE, 0); + public with_clause(): With_clauseContext | null { + return this.getRuleContext(0, With_clauseContext); } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); + public from_clause(): From_clauseContext | null { + return this.getRuleContext(0, From_clauseContext); } - public KW_KEY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_KEY, 0); + public where_or_current_clause(): Where_or_current_clauseContext | null { + return this.getRuleContext(0, Where_or_current_clauseContext); + } + public returning_clause(): Returning_clauseContext | null { + return this.getRuleContext(0, Returning_clauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_for_locking_strength; + return PostgreSqlParser.RULE_updatestmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFor_locking_strength) { - listener.enterFor_locking_strength(this); + if(listener.enterUpdatestmt) { + listener.enterUpdatestmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFor_locking_strength) { - listener.exitFor_locking_strength(this); + if(listener.exitUpdatestmt) { + listener.exitUpdatestmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFor_locking_strength) { - return visitor.visitFor_locking_strength(this); + if (visitor.visitUpdatestmt) { + return visitor.visitUpdatestmt(this); } else { return visitor.visitChildren(this); } @@ -99607,32 +75304,44 @@ export class For_locking_strengthContext extends antlr.ParserRuleContext { } -export class Locked_rels_listContext extends antlr.ParserRuleContext { +export class Set_clause_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_OF(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_OF, 0)!; + public set_clause(): Set_clauseContext[]; + public set_clause(i: number): Set_clauseContext | null; + public set_clause(i?: number): Set_clauseContext[] | Set_clauseContext | null { + if (i === undefined) { + return this.getRuleContexts(Set_clauseContext); + } + + return this.getRuleContext(i, Set_clauseContext); } - public qualified_name_list(): Qualified_name_listContext { - return this.getRuleContext(0, Qualified_name_listContext)!; + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_locked_rels_list; + return PostgreSqlParser.RULE_set_clause_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterLocked_rels_list) { - listener.enterLocked_rels_list(this); + if(listener.enterSet_clause_list) { + listener.enterSet_clause_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitLocked_rels_list) { - listener.exitLocked_rels_list(this); + if(listener.exitSet_clause_list) { + listener.exitSet_clause_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitLocked_rels_list) { - return visitor.visitLocked_rels_list(this); + if (visitor.visitSet_clause_list) { + return visitor.visitSet_clause_list(this); } else { return visitor.visitChildren(this); } @@ -99640,12 +75349,18 @@ export class Locked_rels_listContext extends antlr.ParserRuleContext { } -export class Values_clauseContext extends antlr.ParserRuleContext { +export class Set_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_VALUES(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VALUES, 0)!; + public insert_column_item(): Insert_column_itemContext | null { + return this.getRuleContext(0, Insert_column_itemContext); + } + public EQUAL(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.EQUAL, 0)!; + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } public OPEN_PAREN(): antlr.TerminalNode[]; public OPEN_PAREN(i: number): antlr.TerminalNode | null; @@ -99656,14 +75371,8 @@ export class Values_clauseContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.OPEN_PAREN, i); } } - public expr_list(): Expr_listContext[]; - public expr_list(i: number): Expr_listContext | null; - public expr_list(i?: number): Expr_listContext[] | Expr_listContext | null { - if (i === undefined) { - return this.getRuleContexts(Expr_listContext); - } - - return this.getRuleContext(i, Expr_listContext); + public insert_column_list(): Insert_column_listContext | null { + return this.getRuleContext(0, Insert_column_listContext); } public CLOSE_PAREN(): antlr.TerminalNode[]; public CLOSE_PAREN(i: number): antlr.TerminalNode | null; @@ -99674,31 +75383,28 @@ export class Values_clauseContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.CLOSE_PAREN, i); } } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public select_clause(): Select_clauseContext | null { + return this.getRuleContext(0, Select_clauseContext); + } + public KW_ROW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROW, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_values_clause; + return PostgreSqlParser.RULE_set_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterValues_clause) { - listener.enterValues_clause(this); + if(listener.enterSet_clause) { + listener.enterSet_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitValues_clause) { - listener.exitValues_clause(this); + if(listener.exitSet_clause) { + listener.exitSet_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitValues_clause) { - return visitor.visitValues_clause(this); + if (visitor.visitSet_clause) { + return visitor.visitSet_clause(this); } else { return visitor.visitChildren(this); } @@ -99706,77 +75412,86 @@ export class Values_clauseContext extends antlr.ParserRuleContext { } -export class From_clauseContext extends antlr.ParserRuleContext { +export class DeclarecursorstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FROM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FROM, 0)!; + public KW_DECLARE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DECLARE, 0)!; } - public from_list(): From_listContext { - return this.getRuleContext(0, From_listContext)!; + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_from_clause; + public KW_CURSOR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CURSOR, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFrom_clause) { - listener.enterFrom_clause(this); - } + public KW_FOR(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FOR, 0)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFrom_clause) { - listener.exitFrom_clause(this); - } + public selectstmt(): SelectstmtContext { + return this.getRuleContext(0, SelectstmtContext)!; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFrom_clause) { - return visitor.visitFrom_clause(this); - } else { - return visitor.visitChildren(this); - } + public KW_HOLD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_HOLD, 0); } -} - - -export class From_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public table_ref(): Table_refContext[]; - public table_ref(i: number): Table_refContext | null; - public table_ref(i?: number): Table_refContext[] | Table_refContext | null { - if (i === undefined) { - return this.getRuleContexts(Table_refContext); - } - - return this.getRuleContext(i, Table_refContext); + public KW_WITHOUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public KW_BINARY(): antlr.TerminalNode[]; + public KW_BINARY(i: number): antlr.TerminalNode | null; + public KW_BINARY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); + return this.getTokens(PostgreSqlParser.KW_BINARY); } else { - return this.getToken(PostgreSqlParser.COMMA, i); + return this.getToken(PostgreSqlParser.KW_BINARY, i); + } + } + public KW_INSENSITIVE(): antlr.TerminalNode[]; + public KW_INSENSITIVE(i: number): antlr.TerminalNode | null; + public KW_INSENSITIVE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_INSENSITIVE); + } else { + return this.getToken(PostgreSqlParser.KW_INSENSITIVE, i); + } + } + public KW_SCROLL(): antlr.TerminalNode[]; + public KW_SCROLL(i: number): antlr.TerminalNode | null; + public KW_SCROLL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_SCROLL); + } else { + return this.getToken(PostgreSqlParser.KW_SCROLL, i); + } + } + public KW_NO(): antlr.TerminalNode[]; + public KW_NO(i: number): antlr.TerminalNode | null; + public KW_NO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_NO); + } else { + return this.getToken(PostgreSqlParser.KW_NO, i); } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_from_list; + return PostgreSqlParser.RULE_declarecursorstmt; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFrom_list) { - listener.enterFrom_list(this); + if(listener.enterDeclarecursorstmt) { + listener.enterDeclarecursorstmt(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFrom_list) { - listener.exitFrom_list(this); + if(listener.exitDeclarecursorstmt) { + listener.exitDeclarecursorstmt(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFrom_list) { - return visitor.visitFrom_list(this); + if (visitor.visitDeclarecursorstmt) { + return visitor.visitDeclarecursorstmt(this); } else { return visitor.visitChildren(this); } @@ -99784,113 +75499,80 @@ export class From_listContext extends antlr.ParserRuleContext { } -export class Table_refContext extends antlr.ParserRuleContext { +export class SelectstmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public func_table(): Func_tableContext | null { - return this.getRuleContext(0, Func_tableContext); + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_selectstmt; } - public xmltable(): XmltableContext | null { - return this.getRuleContext(0, XmltableContext); + public override copyFrom(ctx: SelectstmtContext): void { + super.copyFrom(ctx); } - public select_with_parens(): Select_with_parensContext | null { - return this.getRuleContext(0, Select_with_parensContext); +} +export class SelectStatementContext extends SelectstmtContext { + public constructor(ctx: SelectstmtContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public KW_LATERAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LATERAL, 0); + public select_no_parens(): Select_no_parensContext | null { + return this.getRuleContext(0, Select_no_parensContext); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public select_with_parens(): Select_with_parensContext | null { + return this.getRuleContext(0, Select_with_parensContext); } - public table_ref(): Table_refContext[]; - public table_ref(i: number): Table_refContext | null; - public table_ref(i?: number): Table_refContext[] | Table_refContext | null { - if (i === undefined) { - return this.getRuleContexts(Table_refContext); + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterSelectStatement) { + listener.enterSelectStatement(this); } - - return this.getRuleContext(i, Table_refContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public KW_CROSS(): antlr.TerminalNode[]; - public KW_CROSS(i: number): antlr.TerminalNode | null; - public KW_CROSS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_CROSS); - } else { - return this.getToken(PostgreSqlParser.KW_CROSS, i); - } - } - public KW_JOIN(): antlr.TerminalNode[]; - public KW_JOIN(i: number): antlr.TerminalNode | null; - public KW_JOIN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_JOIN); - } else { - return this.getToken(PostgreSqlParser.KW_JOIN, i); - } - } - public KW_NATURAL(): antlr.TerminalNode[]; - public KW_NATURAL(i: number): antlr.TerminalNode | null; - public KW_NATURAL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_NATURAL); - } else { - return this.getToken(PostgreSqlParser.KW_NATURAL, i); - } } - public join_qual(): Join_qualContext[]; - public join_qual(i: number): Join_qualContext | null; - public join_qual(i?: number): Join_qualContext[] | Join_qualContext | null { - if (i === undefined) { - return this.getRuleContexts(Join_qualContext); + public override exitRule(listener: PostgreSqlParserListener): void { + if(listener.exitSelectStatement) { + listener.exitSelectStatement(this); } - - return this.getRuleContext(i, Join_qualContext); } - public relation_expr(): Relation_exprContext | null { - return this.getRuleContext(0, Relation_exprContext); + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitSelectStatement) { + return visitor.visitSelectStatement(this); + } else { + return visitor.visitChildren(this); + } } - public view_relation_expr(): View_relation_exprContext | null { - return this.getRuleContext(0, View_relation_exprContext); +} + + +export class Select_with_parensContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); } - public opt_alias_clause(): Opt_alias_clauseContext | null { - return this.getRuleContext(0, Opt_alias_clauseContext); + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public tablesample_clause(): Tablesample_clauseContext | null { - return this.getRuleContext(0, Tablesample_clauseContext); + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public func_alias_clause(): Func_alias_clauseContext | null { - return this.getRuleContext(0, Func_alias_clauseContext); + public select_no_parens(): Select_no_parensContext | null { + return this.getRuleContext(0, Select_no_parensContext); } - public join_type(): Join_typeContext[]; - public join_type(i: number): Join_typeContext | null; - public join_type(i?: number): Join_typeContext[] | Join_typeContext | null { - if (i === undefined) { - return this.getRuleContexts(Join_typeContext); - } - - return this.getRuleContext(i, Join_typeContext); + public select_with_parens(): Select_with_parensContext | null { + return this.getRuleContext(0, Select_with_parensContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_table_ref; + return PostgreSqlParser.RULE_select_with_parens; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTable_ref) { - listener.enterTable_ref(this); + if(listener.enterSelect_with_parens) { + listener.enterSelect_with_parens(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTable_ref) { - listener.exitTable_ref(this); + if(listener.exitSelect_with_parens) { + listener.exitSelect_with_parens(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTable_ref) { - return visitor.visitTable_ref(this); + if (visitor.visitSelect_with_parens) { + return visitor.visitSelect_with_parens(this); } else { return visitor.visitChildren(this); } @@ -99898,41 +75580,41 @@ export class Table_refContext extends antlr.ParserRuleContext { } -export class Alias_clauseContext extends antlr.ParserRuleContext { +export class Select_no_parensContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; + public select_clause(): Select_clauseContext { + return this.getRuleContext(0, Select_clauseContext)!; } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); + public with_clause(): With_clauseContext | null { + return this.getRuleContext(0, With_clauseContext); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public sort_clause(): Sort_clauseContext | null { + return this.getRuleContext(0, Sort_clauseContext); } - public name_list(): Name_listContext | null { - return this.getRuleContext(0, Name_listContext); + public for_locking_clause(): For_locking_clauseContext | null { + return this.getRuleContext(0, For_locking_clauseContext); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public select_limit(): Select_limitContext | null { + return this.getRuleContext(0, Select_limitContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_alias_clause; + return PostgreSqlParser.RULE_select_no_parens; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAlias_clause) { - listener.enterAlias_clause(this); + if(listener.enterSelect_no_parens) { + listener.enterSelect_no_parens(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAlias_clause) { - listener.exitAlias_clause(this); + if(listener.exitSelect_no_parens) { + listener.exitSelect_no_parens(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAlias_clause) { - return visitor.visitAlias_clause(this); + if (visitor.visitSelect_no_parens) { + return visitor.visitSelect_no_parens(this); } else { return visitor.visitChildren(this); } @@ -99940,29 +75622,32 @@ export class Alias_clauseContext extends antlr.ParserRuleContext { } -export class Opt_alias_clauseContext extends antlr.ParserRuleContext { +export class Select_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public alias_clause(): Alias_clauseContext { - return this.getRuleContext(0, Alias_clauseContext)!; + public simple_select(): Simple_selectContext | null { + return this.getRuleContext(0, Simple_selectContext); + } + public select_with_parens(): Select_with_parensContext | null { + return this.getRuleContext(0, Select_with_parensContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_alias_clause; + return PostgreSqlParser.RULE_select_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_alias_clause) { - listener.enterOpt_alias_clause(this); + if(listener.enterSelect_clause) { + listener.enterSelect_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_alias_clause) { - listener.exitOpt_alias_clause(this); + if(listener.exitSelect_clause) { + listener.exitSelect_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_alias_clause) { - return visitor.visitOpt_alias_clause(this); + if (visitor.visitSelect_clause) { + return visitor.visitSelect_clause(this); } else { return visitor.visitChildren(this); } @@ -99970,44 +75655,77 @@ export class Opt_alias_clauseContext extends antlr.ParserRuleContext { } -export class Func_alias_clauseContext extends antlr.ParserRuleContext { +export class Simple_selectContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public alias_clause(): Alias_clauseContext | null { - return this.getRuleContext(0, Alias_clauseContext); + public KW_SELECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SELECT, 0); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public sql_expression(): Sql_expressionContext | null { + return this.getRuleContext(0, Sql_expressionContext); } - public tablefuncelementlist(): TablefuncelementlistContext | null { - return this.getRuleContext(0, TablefuncelementlistContext); + public values_clause(): Values_clauseContext | null { + return this.getRuleContext(0, Values_clauseContext); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); + public relation_expr(): Relation_exprContext | null { + return this.getRuleContext(0, Relation_exprContext); } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); + public select_with_parens(): Select_with_parensContext[]; + public select_with_parens(i: number): Select_with_parensContext | null; + public select_with_parens(i?: number): Select_with_parensContext[] | Select_with_parensContext | null { + if (i === undefined) { + return this.getRuleContexts(Select_with_parensContext); + } + + return this.getRuleContext(i, Select_with_parensContext); + } + public set_operator_with_all_or_distinct(): Set_operator_with_all_or_distinctContext[]; + public set_operator_with_all_or_distinct(i: number): Set_operator_with_all_or_distinctContext | null; + public set_operator_with_all_or_distinct(i?: number): Set_operator_with_all_or_distinctContext[] | Set_operator_with_all_or_distinctContext | null { + if (i === undefined) { + return this.getRuleContexts(Set_operator_with_all_or_distinctContext); + } + + return this.getRuleContext(i, Set_operator_with_all_or_distinctContext); + } + public simple_select(): Simple_selectContext[]; + public simple_select(i: number): Simple_selectContext | null; + public simple_select(i?: number): Simple_selectContext[] | Simple_selectContext | null { + if (i === undefined) { + return this.getRuleContexts(Simple_selectContext); + } + + return this.getRuleContext(i, Simple_selectContext); + } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); + } + public into_clause(): Into_clauseContext | null { + return this.getRuleContext(0, Into_clauseContext); + } + public distinct_clause(): Distinct_clauseContext | null { + return this.getRuleContext(0, Distinct_clauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_func_alias_clause; + return PostgreSqlParser.RULE_simple_select; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunc_alias_clause) { - listener.enterFunc_alias_clause(this); + if(listener.enterSimple_select) { + listener.enterSimple_select(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunc_alias_clause) { - listener.exitFunc_alias_clause(this); + if(listener.exitSimple_select) { + listener.exitSimple_select(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunc_alias_clause) { - return visitor.visitFunc_alias_clause(this); + if (visitor.visitSimple_select) { + return visitor.visitSimple_select(this); } else { return visitor.visitChildren(this); } @@ -100015,41 +75733,41 @@ export class Func_alias_clauseContext extends antlr.ParserRuleContext { } -export class Join_typeContext extends antlr.ParserRuleContext { +export class Set_operator_with_all_or_distinctContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_FULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FULL, 0); + public KW_UNION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNION, 0); } - public KW_LEFT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LEFT, 0); + public KW_INTERSECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INTERSECT, 0); } - public KW_RIGHT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RIGHT, 0); + public KW_EXCEPT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXCEPT, 0); } - public KW_INNER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INNER, 0); + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public KW_OUTER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OUTER, 0); + public KW_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DISTINCT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_join_type; + return PostgreSqlParser.RULE_set_operator_with_all_or_distinct; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterJoin_type) { - listener.enterJoin_type(this); + if(listener.enterSet_operator_with_all_or_distinct) { + listener.enterSet_operator_with_all_or_distinct(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitJoin_type) { - listener.exitJoin_type(this); + if(listener.exitSet_operator_with_all_or_distinct) { + listener.exitSet_operator_with_all_or_distinct(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitJoin_type) { - return visitor.visitJoin_type(this); + if (visitor.visitSet_operator_with_all_or_distinct) { + return visitor.visitSet_operator_with_all_or_distinct(this); } else { return visitor.visitChildren(this); } @@ -100057,44 +75775,50 @@ export class Join_typeContext extends antlr.ParserRuleContext { } -export class Join_qualContext extends antlr.ParserRuleContext { +export class With_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public column_list(): Column_listContext | null { - return this.getRuleContext(0, Column_listContext); + public KW_WITH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WITH, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public common_table_expr(): Common_table_exprContext[]; + public common_table_expr(i: number): Common_table_exprContext | null; + public common_table_expr(i?: number): Common_table_exprContext[] | Common_table_exprContext | null { + if (i === undefined) { + return this.getRuleContexts(Common_table_exprContext); + } + + return this.getRuleContext(i, Common_table_exprContext); } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); + public KW_RECURSIVE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RECURSIVE, 0); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_join_qual; + return PostgreSqlParser.RULE_with_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterJoin_qual) { - listener.enterJoin_qual(this); + if(listener.enterWith_clause) { + listener.enterWith_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitJoin_qual) { - listener.exitJoin_qual(this); + if(listener.exitWith_clause) { + listener.exitWith_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitJoin_qual) { - return visitor.visitJoin_qual(this); + if (visitor.visitWith_clause) { + return visitor.visitWith_clause(this); } else { return visitor.visitChildren(this); } @@ -100102,53 +75826,56 @@ export class Join_qualContext extends antlr.ParserRuleContext { } -export class Relation_exprContext extends antlr.ParserRuleContext { +export class Common_table_exprContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public table_name(): Table_nameContext | null { - return this.getRuleContext(0, Table_nameContext); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public KW_ONLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ONLY, 0); + public KW_AS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_AS, 0)!; } - public STAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.STAR, 0); + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public preparablestmt(): PreparablestmtContext { + return this.getRuleContext(0, PreparablestmtContext)!; } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); + public opt_column_list(): Opt_column_listContext | null { + return this.getRuleContext(0, Opt_column_listContext); } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); + public KW_MATERIALIZED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MATERIALIZED, 0); } - public schema_name(): Schema_nameContext | null { - return this.getRuleContext(0, Schema_nameContext); + public search_cluase(): Search_cluaseContext | null { + return this.getRuleContext(0, Search_cluaseContext); } - public KW_CURRENT_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT_SCHEMA, 0); + public cycle_cluase(): Cycle_cluaseContext | null { + return this.getRuleContext(0, Cycle_cluaseContext); + } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_relation_expr; + return PostgreSqlParser.RULE_common_table_expr; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRelation_expr) { - listener.enterRelation_expr(this); + if(listener.enterCommon_table_expr) { + listener.enterCommon_table_expr(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRelation_expr) { - listener.exitRelation_expr(this); + if(listener.exitCommon_table_expr) { + listener.exitCommon_table_expr(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRelation_expr) { - return visitor.visitRelation_expr(this); + if (visitor.visitCommon_table_expr) { + return visitor.visitCommon_table_expr(this); } else { return visitor.visitChildren(this); } @@ -100156,41 +75883,50 @@ export class Relation_exprContext extends antlr.ParserRuleContext { } -export class View_relation_exprContext extends antlr.ParserRuleContext { +export class Search_cluaseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public view_name(): View_nameContext { - return this.getRuleContext(0, View_nameContext)!; + public KW_SEARCH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SEARCH, 0)!; } - public KW_ONLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ONLY, 0); + public KW_FIRST(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FIRST, 0)!; } - public STAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.STAR, 0); + public KW_BY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_BY, 0)!; } - public column_list(): Column_listContext | null { - return this.getRuleContext(0, Column_listContext); + public column_list(): Column_listContext { + return this.getRuleContext(0, Column_listContext)!; } - public where_clause(): Where_clauseContext | null { - return this.getRuleContext(0, Where_clauseContext); + public KW_SET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SET, 0)!; + } + public column_name(): Column_nameContext { + return this.getRuleContext(0, Column_nameContext)!; + } + public KW_BREADTH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BREADTH, 0); + } + public KW_DEPTH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEPTH, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_view_relation_expr; + return PostgreSqlParser.RULE_search_cluase; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterView_relation_expr) { - listener.enterView_relation_expr(this); + if(listener.enterSearch_cluase) { + listener.enterSearch_cluase(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitView_relation_expr) { - listener.exitView_relation_expr(this); + if(listener.exitSearch_cluase) { + listener.exitSearch_cluase(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitView_relation_expr) { - return visitor.visitView_relation_expr(this); + if (visitor.visitSearch_cluase) { + return visitor.visitSearch_cluase(this); } else { return visitor.visitChildren(this); } @@ -100198,110 +75934,62 @@ export class View_relation_exprContext extends antlr.ParserRuleContext { } -export class Publication_relation_exprContext extends antlr.ParserRuleContext { +export class Cycle_cluaseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); - } - public table_name(): Table_nameContext | null { - return this.getRuleContext(0, Table_nameContext); - } - public KW_ONLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ONLY, 0); - } - public STAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.STAR, 0); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public column_list(): Column_listContext | null { - return this.getRuleContext(0, Column_listContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public where_clause(): Where_clauseContext | null { - return this.getRuleContext(0, Where_clauseContext); - } - public KW_TABLES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLES, 0); - } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); - } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); - } - public schema_name(): Schema_nameContext | null { - return this.getRuleContext(0, Schema_nameContext); - } - public KW_CURRENT_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT_SCHEMA, 0); + public KW_CYCLE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_CYCLE, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_publication_relation_expr; + public column_list(): Column_listContext { + return this.getRuleContext(0, Column_listContext)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPublication_relation_expr) { - listener.enterPublication_relation_expr(this); - } + public KW_SET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SET, 0)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPublication_relation_expr) { - listener.exitPublication_relation_expr(this); + public column_name(): Column_nameContext[]; + public column_name(i: number): Column_nameContext | null; + public column_name(i?: number): Column_nameContext[] | Column_nameContext | null { + if (i === undefined) { + return this.getRuleContexts(Column_nameContext); } + + return this.getRuleContext(i, Column_nameContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPublication_relation_expr) { - return visitor.visitPublication_relation_expr(this); - } else { - return visitor.visitChildren(this); - } + public KW_USING(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_USING, 0)!; } -} - - -export class Relation_expr_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } - public relation_expr(): Relation_exprContext[]; - public relation_expr(i: number): Relation_exprContext | null; - public relation_expr(i?: number): Relation_exprContext[] | Relation_exprContext | null { + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { if (i === undefined) { - return this.getRuleContexts(Relation_exprContext); + return this.getRuleContexts(ColidContext); } - return this.getRuleContext(i, Relation_exprContext); + return this.getRuleContext(i, ColidContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_relation_expr_list; + return PostgreSqlParser.RULE_cycle_cluase; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRelation_expr_list) { - listener.enterRelation_expr_list(this); + if(listener.enterCycle_cluase) { + listener.enterCycle_cluase(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRelation_expr_list) { - listener.exitRelation_expr_list(this); + if(listener.exitCycle_cluase) { + listener.exitCycle_cluase(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRelation_expr_list) { - return visitor.visitRelation_expr_list(this); + if (visitor.visitCycle_cluase) { + return visitor.visitCycle_cluase(this); } else { return visitor.visitChildren(this); } @@ -100309,44 +75997,38 @@ export class Relation_expr_listContext extends antlr.ParserRuleContext { } -export class Publication_relation_expr_listContext extends antlr.ParserRuleContext { +export class Into_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public publication_relation_expr(): Publication_relation_exprContext[]; - public publication_relation_expr(i: number): Publication_relation_exprContext | null; - public publication_relation_expr(i?: number): Publication_relation_exprContext[] | Publication_relation_exprContext | null { - if (i === undefined) { - return this.getRuleContexts(Publication_relation_exprContext); - } - - return this.getRuleContext(i, Publication_relation_exprContext); + public KW_INTO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_INTO, 0)!; } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public opttempTableName(): OpttempTableNameContext | null { + return this.getRuleContext(0, OpttempTableNameContext); + } + public expr_list(): Expr_listContext | null { + return this.getRuleContext(0, Expr_listContext); + } + public KW_STRICT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STRICT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_publication_relation_expr_list; + return PostgreSqlParser.RULE_into_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPublication_relation_expr_list) { - listener.enterPublication_relation_expr_list(this); + if(listener.enterInto_clause) { + listener.enterInto_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPublication_relation_expr_list) { - listener.exitPublication_relation_expr_list(this); + if(listener.exitInto_clause) { + listener.exitInto_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPublication_relation_expr_list) { - return visitor.visitPublication_relation_expr_list(this); + if (visitor.visitInto_clause) { + return visitor.visitInto_clause(this); } else { return visitor.visitChildren(this); } @@ -100354,35 +76036,47 @@ export class Publication_relation_expr_listContext extends antlr.ParserRuleConte } -export class Relation_expr_opt_aliasContext extends antlr.ParserRuleContext { +export class OpttempTableNameContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public relation_expr(): Relation_exprContext { - return this.getRuleContext(0, Relation_exprContext)!; + public table_name_create(): Table_name_createContext { + return this.getRuleContext(0, Table_name_createContext)!; } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPORARY, 0); } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); + public KW_TEMP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMP, 0); + } + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); + } + public KW_LOCAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LOCAL, 0); + } + public KW_GLOBAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GLOBAL, 0); + } + public KW_UNLOGGED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNLOGGED, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_relation_expr_opt_alias; + return PostgreSqlParser.RULE_opttempTableName; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRelation_expr_opt_alias) { - listener.enterRelation_expr_opt_alias(this); + if(listener.enterOpttempTableName) { + listener.enterOpttempTableName(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRelation_expr_opt_alias) { - listener.exitRelation_expr_opt_alias(this); + if(listener.exitOpttempTableName) { + listener.exitOpttempTableName(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRelation_expr_opt_alias) { - return visitor.visitRelation_expr_opt_alias(this); + if (visitor.visitOpttempTableName) { + return visitor.visitOpttempTableName(this); } else { return visitor.visitChildren(this); } @@ -100390,44 +76084,35 @@ export class Relation_expr_opt_aliasContext extends antlr.ParserRuleContext { } -export class Tablesample_clauseContext extends antlr.ParserRuleContext { +export class Distinct_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_TABLESAMPLE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TABLESAMPLE, 0)!; - } - public function_name(): Function_nameContext { - return this.getRuleContext(0, Function_nameContext)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public expr_list(): Expr_listContext { - return this.getRuleContext(0, Expr_listContext)!; + public KW_DISTINCT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DISTINCT, 0)!; } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ON, 0); } - public opt_repeatable_clause(): Opt_repeatable_clauseContext | null { - return this.getRuleContext(0, Opt_repeatable_clauseContext); + public execute_param_clause(): Execute_param_clauseContext | null { + return this.getRuleContext(0, Execute_param_clauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_tablesample_clause; + return PostgreSqlParser.RULE_distinct_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTablesample_clause) { - listener.enterTablesample_clause(this); + if(listener.enterDistinct_clause) { + listener.enterDistinct_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTablesample_clause) { - listener.exitTablesample_clause(this); + if(listener.exitDistinct_clause) { + listener.exitDistinct_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTablesample_clause) { - return visitor.visitTablesample_clause(this); + if (visitor.visitDistinct_clause) { + return visitor.visitDistinct_clause(this); } else { return visitor.visitChildren(this); } @@ -100435,38 +76120,50 @@ export class Tablesample_clauseContext extends antlr.ParserRuleContext { } -export class Opt_repeatable_clauseContext extends antlr.ParserRuleContext { +export class Sort_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_REPEATABLE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_REPEATABLE, 0)!; + public KW_ORDER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ORDER, 0)!; } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_BY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_BY, 0)!; } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; + public sortby(): SortbyContext[]; + public sortby(i: number): SortbyContext | null; + public sortby(i?: number): SortbyContext[] | SortbyContext | null { + if (i === undefined) { + return this.getRuleContexts(SortbyContext); + } + + return this.getRuleContext(i, SortbyContext); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_repeatable_clause; + return PostgreSqlParser.RULE_sort_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_repeatable_clause) { - listener.enterOpt_repeatable_clause(this); + if(listener.enterSort_clause) { + listener.enterSort_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_repeatable_clause) { - listener.exitOpt_repeatable_clause(this); + if(listener.exitSort_clause) { + listener.exitSort_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_repeatable_clause) { - return visitor.visitOpt_repeatable_clause(this); + if (visitor.visitSort_clause) { + return visitor.visitSort_clause(this); } else { return visitor.visitChildren(this); } @@ -100474,47 +76171,50 @@ export class Opt_repeatable_clauseContext extends antlr.ParserRuleContext { } -export class Func_tableContext extends antlr.ParserRuleContext { +export class SortbyContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public func_expr_windowless(): Func_expr_windowlessContext | null { - return this.getRuleContext(0, Func_expr_windowlessContext); + public column_expr_noparen(): Column_expr_noparenContext { + return this.getRuleContext(0, Column_expr_noparenContext)!; } - public opt_ordinality(): Opt_ordinalityContext | null { - return this.getRuleContext(0, Opt_ordinalityContext); + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USING, 0); } - public KW_ROWS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROWS, 0); + public qual_all_op(): Qual_all_opContext | null { + return this.getRuleContext(0, Qual_all_opContext); } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); + public KW_NULLS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULLS, 0); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_ASC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ASC, 0); + } + public KW_DESC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DESC, 0); } - public rowsfrom_list(): Rowsfrom_listContext | null { - return this.getRuleContext(0, Rowsfrom_listContext); + public KW_FIRST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FIRST, 0); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_LAST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LAST, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_func_table; + return PostgreSqlParser.RULE_sortby; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFunc_table) { - listener.enterFunc_table(this); + if(listener.enterSortby) { + listener.enterSortby(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFunc_table) { - listener.exitFunc_table(this); + if(listener.exitSortby) { + listener.exitSortby(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunc_table) { - return visitor.visitFunc_table(this); + if (visitor.visitSortby) { + return visitor.visitSortby(this); } else { return visitor.visitChildren(this); } @@ -100522,32 +76222,35 @@ export class Func_tableContext extends antlr.ParserRuleContext { } -export class Rowsfrom_itemContext extends antlr.ParserRuleContext { +export class Select_limitContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public func_expr_windowless(): Func_expr_windowlessContext { - return this.getRuleContext(0, Func_expr_windowlessContext)!; + public offset_clause(): Offset_clauseContext | null { + return this.getRuleContext(0, Offset_clauseContext); } - public opt_col_def_list(): Opt_col_def_listContext | null { - return this.getRuleContext(0, Opt_col_def_listContext); + public fetch_clause(): Fetch_clauseContext | null { + return this.getRuleContext(0, Fetch_clauseContext); + } + public limit_clause(): Limit_clauseContext | null { + return this.getRuleContext(0, Limit_clauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_rowsfrom_item; + return PostgreSqlParser.RULE_select_limit; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRowsfrom_item) { - listener.enterRowsfrom_item(this); + if(listener.enterSelect_limit) { + listener.enterSelect_limit(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRowsfrom_item) { - listener.exitRowsfrom_item(this); + if(listener.exitSelect_limit) { + listener.exitSelect_limit(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRowsfrom_item) { - return visitor.visitRowsfrom_item(this); + if (visitor.visitSelect_limit) { + return visitor.visitSelect_limit(this); } else { return visitor.visitChildren(this); } @@ -100555,44 +76258,44 @@ export class Rowsfrom_itemContext extends antlr.ParserRuleContext { } -export class Rowsfrom_listContext extends antlr.ParserRuleContext { +export class Limit_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public rowsfrom_item(): Rowsfrom_itemContext[]; - public rowsfrom_item(i: number): Rowsfrom_itemContext | null; - public rowsfrom_item(i?: number): Rowsfrom_itemContext[] | Rowsfrom_itemContext | null { + public KW_LIMIT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_LIMIT, 0)!; + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(Rowsfrom_itemContext); + return this.getRuleContexts(ExpressionContext); } - return this.getRuleContext(i, Rowsfrom_itemContext); + return this.getRuleContext(i, ExpressionContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); + } + public COMMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.COMMA, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_rowsfrom_list; + return PostgreSqlParser.RULE_limit_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRowsfrom_list) { - listener.enterRowsfrom_list(this); + if(listener.enterLimit_clause) { + listener.enterLimit_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRowsfrom_list) { - listener.exitRowsfrom_list(this); + if(listener.exitLimit_clause) { + listener.exitLimit_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRowsfrom_list) { - return visitor.visitRowsfrom_list(this); + if (visitor.visitLimit_clause) { + return visitor.visitLimit_clause(this); } else { return visitor.visitChildren(this); } @@ -100600,38 +76303,53 @@ export class Rowsfrom_listContext extends antlr.ParserRuleContext { } -export class Opt_col_def_listContext extends antlr.ParserRuleContext { +export class Fetch_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_AS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AS, 0)!; + public KW_FETCH(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FETCH, 0)!; } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_FIRST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FIRST, 0); } - public tablefuncelementlist(): TablefuncelementlistContext { - return this.getRuleContext(0, TablefuncelementlistContext)!; + public KW_NEXT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NEXT, 0); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public KW_ROW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROW, 0); + } + public KW_ROWS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROWS, 0); + } + public KW_ONLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ONLY, 0); + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); + } + public KW_TIES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TIES, 0); + } + public select_fetch_first_value(): Select_fetch_first_valueContext | null { + return this.getRuleContext(0, Select_fetch_first_valueContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_col_def_list; + return PostgreSqlParser.RULE_fetch_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_col_def_list) { - listener.enterOpt_col_def_list(this); + if(listener.enterFetch_clause) { + listener.enterFetch_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_col_def_list) { - listener.exitOpt_col_def_list(this); + if(listener.exitFetch_clause) { + listener.exitFetch_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_col_def_list) { - return visitor.visitOpt_col_def_list(this); + if (visitor.visitFetch_clause) { + return visitor.visitFetch_clause(this); } else { return visitor.visitChildren(this); } @@ -100639,32 +76357,41 @@ export class Opt_col_def_listContext extends antlr.ParserRuleContext { } -export class Opt_ordinalityContext extends antlr.ParserRuleContext { +export class Offset_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WITH(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITH, 0)!; + public KW_OFFSET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_OFFSET, 0)!; + } + public select_fetch_first_value(): Select_fetch_first_valueContext | null { + return this.getRuleContext(0, Select_fetch_first_valueContext); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public KW_ROW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROW, 0); } - public KW_ORDINALITY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ORDINALITY, 0)!; + public KW_ROWS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROWS, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_ordinality; + return PostgreSqlParser.RULE_offset_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_ordinality) { - listener.enterOpt_ordinality(this); + if(listener.enterOffset_clause) { + listener.enterOffset_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_ordinality) { - listener.exitOpt_ordinality(this); + if(listener.exitOffset_clause) { + listener.exitOffset_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_ordinality) { - return visitor.visitOpt_ordinality(this); + if (visitor.visitOffset_clause) { + return visitor.visitOffset_clause(this); } else { return visitor.visitChildren(this); } @@ -100672,32 +76399,41 @@ export class Opt_ordinalityContext extends antlr.ParserRuleContext { } -export class Where_clauseContext extends antlr.ParserRuleContext { +export class Select_fetch_first_valueContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WHERE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WHERE, 0)!; + public PLUS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.PLUS, 0); } - public column_expr_noparen(): Column_expr_noparenContext { - return this.getRuleContext(0, Column_expr_noparenContext)!; + public MINUS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.MINUS, 0); + } + public Integral(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.Integral, 0); + } + public Numeric(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.Numeric, 0); + } + public primaryExpression(): PrimaryExpressionContext | null { + return this.getRuleContext(0, PrimaryExpressionContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_where_clause; + return PostgreSqlParser.RULE_select_fetch_first_value; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterWhere_clause) { - listener.enterWhere_clause(this); + if(listener.enterSelect_fetch_first_value) { + listener.enterSelect_fetch_first_value(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitWhere_clause) { - listener.exitWhere_clause(this); + if(listener.exitSelect_fetch_first_value) { + listener.exitSelect_fetch_first_value(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitWhere_clause) { - return visitor.visitWhere_clause(this); + if (visitor.visitSelect_fetch_first_value) { + return visitor.visitSelect_fetch_first_value(this); } else { return visitor.visitChildren(this); } @@ -100705,41 +76441,41 @@ export class Where_clauseContext extends antlr.ParserRuleContext { } -export class Where_or_current_clauseContext extends antlr.ParserRuleContext { +export class Group_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WHERE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WHERE, 0)!; + public KW_GROUP(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_GROUP, 0)!; } - public KW_CURRENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT, 0); + public KW_BY(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_BY, 0)!; } - public KW_OF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OF, 0); + public group_by_list(): Group_by_listContext { + return this.getRuleContext(0, Group_by_listContext)!; } - public cursor_name(): Cursor_nameContext | null { - return this.getRuleContext(0, Cursor_nameContext); + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public KW_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DISTINCT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_where_or_current_clause; + return PostgreSqlParser.RULE_group_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterWhere_or_current_clause) { - listener.enterWhere_or_current_clause(this); + if(listener.enterGroup_clause) { + listener.enterGroup_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitWhere_or_current_clause) { - listener.exitWhere_or_current_clause(this); + if(listener.exitGroup_clause) { + listener.exitGroup_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitWhere_or_current_clause) { - return visitor.visitWhere_or_current_clause(this); + if (visitor.visitGroup_clause) { + return visitor.visitGroup_clause(this); } else { return visitor.visitChildren(this); } @@ -100747,29 +76483,44 @@ export class Where_or_current_clauseContext extends antlr.ParserRuleContext { } -export class OpttablefuncelementlistContext extends antlr.ParserRuleContext { +export class Group_by_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public tablefuncelementlist(): TablefuncelementlistContext { - return this.getRuleContext(0, TablefuncelementlistContext)!; + public group_by_item(): Group_by_itemContext[]; + public group_by_item(i: number): Group_by_itemContext | null; + public group_by_item(i?: number): Group_by_itemContext[] | Group_by_itemContext | null { + if (i === undefined) { + return this.getRuleContexts(Group_by_itemContext); + } + + return this.getRuleContext(i, Group_by_itemContext); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opttablefuncelementlist; + return PostgreSqlParser.RULE_group_by_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpttablefuncelementlist) { - listener.enterOpttablefuncelementlist(this); + if(listener.enterGroup_by_list) { + listener.enterGroup_by_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpttablefuncelementlist) { - listener.exitOpttablefuncelementlist(this); + if(listener.exitGroup_by_list) { + listener.exitGroup_by_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpttablefuncelementlist) { - return visitor.visitOpttablefuncelementlist(this); + if (visitor.visitGroup_by_list) { + return visitor.visitGroup_by_list(this); } else { return visitor.visitChildren(this); } @@ -100777,18 +76528,30 @@ export class OpttablefuncelementlistContext extends antlr.ParserRuleContext { } -export class TablefuncelementlistContext extends antlr.ParserRuleContext { +export class Group_by_itemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public tablefuncelement(): TablefuncelementContext[]; - public tablefuncelement(i: number): TablefuncelementContext | null; - public tablefuncelement(i?: number): TablefuncelementContext[] | TablefuncelementContext | null { + public column_expr_noparen(): Column_expr_noparenContext[]; + public column_expr_noparen(i: number): Column_expr_noparenContext | null; + public column_expr_noparen(i?: number): Column_expr_noparenContext[] | Column_expr_noparenContext | null { if (i === undefined) { - return this.getRuleContexts(TablefuncelementContext); + return this.getRuleContexts(Column_expr_noparenContext); } - return this.getRuleContext(i, TablefuncelementContext); + return this.getRuleContext(i, Column_expr_noparenContext); + } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + } + public KW_CUBE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CUBE, 0); + } + public KW_ROLLUP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLLUP, 0); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -100799,22 +76562,31 @@ export class TablefuncelementlistContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.COMMA, i); } } + public KW_GROUPING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GROUPING, 0); + } + public KW_SETS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SETS, 0); + } + public group_by_list(): Group_by_listContext | null { + return this.getRuleContext(0, Group_by_listContext); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_tablefuncelementlist; + return PostgreSqlParser.RULE_group_by_item; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTablefuncelementlist) { - listener.enterTablefuncelementlist(this); + if(listener.enterGroup_by_item) { + listener.enterGroup_by_item(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTablefuncelementlist) { - listener.exitTablefuncelementlist(this); + if(listener.exitGroup_by_item) { + listener.exitGroup_by_item(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTablefuncelementlist) { - return visitor.visitTablefuncelementlist(this); + if (visitor.visitGroup_by_item) { + return visitor.visitGroup_by_item(this); } else { return visitor.visitChildren(this); } @@ -100822,35 +76594,122 @@ export class TablefuncelementlistContext extends antlr.ParserRuleContext { } -export class TablefuncelementContext extends antlr.ParserRuleContext { +export class For_locking_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; + public KW_FOR(): antlr.TerminalNode[]; + public KW_FOR(i: number): antlr.TerminalNode | null; + public KW_FOR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_FOR); + } else { + return this.getToken(PostgreSqlParser.KW_FOR, i); + } } - public typename(): TypenameContext { - return this.getRuleContext(0, TypenameContext)!; + public KW_UPDATE(): antlr.TerminalNode[]; + public KW_UPDATE(i: number): antlr.TerminalNode | null; + public KW_UPDATE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_UPDATE); + } else { + return this.getToken(PostgreSqlParser.KW_UPDATE, i); + } } - public opt_collate_clause(): Opt_collate_clauseContext | null { - return this.getRuleContext(0, Opt_collate_clauseContext); + public KW_SHARE(): antlr.TerminalNode[]; + public KW_SHARE(i: number): antlr.TerminalNode | null; + public KW_SHARE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_SHARE); + } else { + return this.getToken(PostgreSqlParser.KW_SHARE, i); + } + } + public KW_OF(): antlr.TerminalNode[]; + public KW_OF(i: number): antlr.TerminalNode | null; + public KW_OF(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_OF); + } else { + return this.getToken(PostgreSqlParser.KW_OF, i); + } + } + public qualified_name_list(): Qualified_name_listContext[]; + public qualified_name_list(i: number): Qualified_name_listContext | null; + public qualified_name_list(i?: number): Qualified_name_listContext[] | Qualified_name_listContext | null { + if (i === undefined) { + return this.getRuleContexts(Qualified_name_listContext); + } + + return this.getRuleContext(i, Qualified_name_listContext); + } + public KW_NOWAIT(): antlr.TerminalNode[]; + public KW_NOWAIT(i: number): antlr.TerminalNode | null; + public KW_NOWAIT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_NOWAIT); + } else { + return this.getToken(PostgreSqlParser.KW_NOWAIT, i); + } + } + public KW_SKIP(): antlr.TerminalNode[]; + public KW_SKIP(i: number): antlr.TerminalNode | null; + public KW_SKIP(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_SKIP); + } else { + return this.getToken(PostgreSqlParser.KW_SKIP, i); + } + } + public KW_LOCKED(): antlr.TerminalNode[]; + public KW_LOCKED(i: number): antlr.TerminalNode | null; + public KW_LOCKED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_LOCKED); + } else { + return this.getToken(PostgreSqlParser.KW_LOCKED, i); + } + } + public KW_NO(): antlr.TerminalNode[]; + public KW_NO(i: number): antlr.TerminalNode | null; + public KW_NO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_NO); + } else { + return this.getToken(PostgreSqlParser.KW_NO, i); + } + } + public KW_KEY(): antlr.TerminalNode[]; + public KW_KEY(i: number): antlr.TerminalNode | null; + public KW_KEY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_KEY); + } else { + return this.getToken(PostgreSqlParser.KW_KEY, i); + } + } + public KW_READ(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_READ, 0); + } + public KW_ONLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ONLY, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_tablefuncelement; + return PostgreSqlParser.RULE_for_locking_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTablefuncelement) { - listener.enterTablefuncelement(this); + if(listener.enterFor_locking_clause) { + listener.enterFor_locking_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTablefuncelement) { - listener.exitTablefuncelement(this); + if(listener.exitFor_locking_clause) { + listener.exitFor_locking_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTablefuncelement) { - return visitor.visitTablefuncelement(this); + if (visitor.visitFor_locking_clause) { + return visitor.visitFor_locking_clause(this); } else { return visitor.visitChildren(this); } @@ -100858,68 +76717,80 @@ export class TablefuncelementContext extends antlr.ParserRuleContext { } -export class XmltableContext extends antlr.ParserRuleContext { +export class Values_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_XMLTABLE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_XMLTABLE, 0)!; + public KW_VALUES(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_VALUES, 0)!; } - public OPEN_PAREN(): antlr.TerminalNode[]; - public OPEN_PAREN(i: number): antlr.TerminalNode | null; - public OPEN_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.OPEN_PAREN); - } else { - return this.getToken(PostgreSqlParser.OPEN_PAREN, i); - } + public execute_param_clause(): Execute_param_clauseContext[]; + public execute_param_clause(i: number): Execute_param_clauseContext | null; + public execute_param_clause(i?: number): Execute_param_clauseContext[] | Execute_param_clauseContext | null { + if (i === undefined) { + return this.getRuleContexts(Execute_param_clauseContext); + } + + return this.getRuleContext(i, Execute_param_clauseContext); } - public CLOSE_PAREN(): antlr.TerminalNode[]; - public CLOSE_PAREN(i: number): antlr.TerminalNode | null; - public CLOSE_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.CLOSE_PAREN); + return this.getTokens(PostgreSqlParser.COMMA); } else { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, i); + return this.getToken(PostgreSqlParser.COMMA, i); } } - public c_expr(): C_exprContext | null { - return this.getRuleContext(0, C_exprContext); + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_values_clause; } - public xmlexists_argument(): Xmlexists_argumentContext | null { - return this.getRuleContext(0, Xmlexists_argumentContext); + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterValues_clause) { + listener.enterValues_clause(this); + } } - public KW_COLUMNS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLUMNS, 0); + public override exitRule(listener: PostgreSqlParserListener): void { + if(listener.exitValues_clause) { + listener.exitValues_clause(this); + } } - public xmltable_column_list(): Xmltable_column_listContext | null { - return this.getRuleContext(0, Xmltable_column_listContext); + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitValues_clause) { + return visitor.visitValues_clause(this); + } else { + return visitor.visitChildren(this); + } } - public KW_XMLNAMESPACES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLNAMESPACES, 0); +} + + +export class From_clauseContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); } - public xml_namespace_list(): Xml_namespace_listContext | null { - return this.getRuleContext(0, Xml_namespace_listContext); + public KW_FROM(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FROM, 0)!; } - public COMMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.COMMA, 0); + public from_list(): From_listContext { + return this.getRuleContext(0, From_listContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_xmltable; + return PostgreSqlParser.RULE_from_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterXmltable) { - listener.enterXmltable(this); + if(listener.enterFrom_clause) { + listener.enterFrom_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitXmltable) { - listener.exitXmltable(this); + if(listener.exitFrom_clause) { + listener.exitFrom_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitXmltable) { - return visitor.visitXmltable(this); + if (visitor.visitFrom_clause) { + return visitor.visitFrom_clause(this); } else { return visitor.visitChildren(this); } @@ -100927,18 +76798,18 @@ export class XmltableContext extends antlr.ParserRuleContext { } -export class Xmltable_column_listContext extends antlr.ParserRuleContext { +export class From_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public xmltable_column_el(): Xmltable_column_elContext[]; - public xmltable_column_el(i: number): Xmltable_column_elContext | null; - public xmltable_column_el(i?: number): Xmltable_column_elContext[] | Xmltable_column_elContext | null { + public table_ref(): Table_refContext[]; + public table_ref(i: number): Table_refContext | null; + public table_ref(i?: number): Table_refContext[] | Table_refContext | null { if (i === undefined) { - return this.getRuleContexts(Xmltable_column_elContext); + return this.getRuleContexts(Table_refContext); } - return this.getRuleContext(i, Xmltable_column_elContext); + return this.getRuleContext(i, Table_refContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -100950,21 +76821,21 @@ export class Xmltable_column_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_xmltable_column_list; + return PostgreSqlParser.RULE_from_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterXmltable_column_list) { - listener.enterXmltable_column_list(this); + if(listener.enterFrom_list) { + listener.enterFrom_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitXmltable_column_list) { - listener.exitXmltable_column_list(this); + if(listener.exitFrom_list) { + listener.exitFrom_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitXmltable_column_list) { - return visitor.visitXmltable_column_list(this); + if (visitor.visitFrom_list) { + return visitor.visitFrom_list(this); } else { return visitor.visitChildren(this); } @@ -100972,77 +76843,125 @@ export class Xmltable_column_listContext extends antlr.ParserRuleContext { } -export class Xmltable_column_elContext extends antlr.ParserRuleContext { +export class Table_refContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public typename(): TypenameContext | null { - return this.getRuleContext(0, TypenameContext); + public table_ref(): Table_refContext[]; + public table_ref(i: number): Table_refContext | null; + public table_ref(i?: number): Table_refContext[] | Table_refContext | null { + if (i === undefined) { + return this.getRuleContexts(Table_refContext); + } + + return this.getRuleContext(i, Table_refContext); } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public KW_ORDINALITY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ORDINALITY, 0); + public KW_CROSS(): antlr.TerminalNode[]; + public KW_CROSS(i: number): antlr.TerminalNode | null; + public KW_CROSS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_CROSS); + } else { + return this.getToken(PostgreSqlParser.KW_CROSS, i); + } } - public xmltable_column_option_list(): Xmltable_column_option_listContext | null { - return this.getRuleContext(0, Xmltable_column_option_listContext); + public KW_JOIN(): antlr.TerminalNode[]; + public KW_JOIN(i: number): antlr.TerminalNode | null; + public KW_JOIN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_JOIN); + } else { + return this.getToken(PostgreSqlParser.KW_JOIN, i); + } } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_xmltable_column_el; + public KW_NATURAL(): antlr.TerminalNode[]; + public KW_NATURAL(i: number): antlr.TerminalNode | null; + public KW_NATURAL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_NATURAL); + } else { + return this.getToken(PostgreSqlParser.KW_NATURAL, i); + } } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterXmltable_column_el) { - listener.enterXmltable_column_el(this); + public join_qual(): Join_qualContext[]; + public join_qual(i: number): Join_qualContext | null; + public join_qual(i?: number): Join_qualContext[] | Join_qualContext | null { + if (i === undefined) { + return this.getRuleContexts(Join_qualContext); } + + return this.getRuleContext(i, Join_qualContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitXmltable_column_el) { - listener.exitXmltable_column_el(this); - } + public relation_expr(): Relation_exprContext | null { + return this.getRuleContext(0, Relation_exprContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitXmltable_column_el) { - return visitor.visitXmltable_column_el(this); - } else { - return visitor.visitChildren(this); - } + public xmltable(): XmltableContext | null { + return this.getRuleContext(0, XmltableContext); } -} - - -export class Xmltable_column_option_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public func_table(): Func_tableContext | null { + return this.getRuleContext(0, Func_tableContext); } - public xmltable_column_option_el(): Xmltable_column_option_elContext[]; - public xmltable_column_option_el(i: number): Xmltable_column_option_elContext | null; - public xmltable_column_option_el(i?: number): Xmltable_column_option_elContext[] | Xmltable_column_option_elContext | null { + public select_with_parens(): Select_with_parensContext | null { + return this.getRuleContext(0, Select_with_parensContext); + } + public alias_clause(): Alias_clauseContext | null { + return this.getRuleContext(0, Alias_clauseContext); + } + public tablesample_clause(): Tablesample_clauseContext | null { + return this.getRuleContext(0, Tablesample_clauseContext); + } + public KW_LATERAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LATERAL, 0); + } + public view_name(): View_nameContext | null { + return this.getRuleContext(0, View_nameContext); + } + public join_type(): Join_typeContext[]; + public join_type(i: number): Join_typeContext | null; + public join_type(i?: number): Join_typeContext[] | Join_typeContext | null { if (i === undefined) { - return this.getRuleContexts(Xmltable_column_option_elContext); + return this.getRuleContexts(Join_typeContext); } - return this.getRuleContext(i, Xmltable_column_option_elContext); + return this.getRuleContext(i, Join_typeContext); + } + public func_alias_clause(): Func_alias_clauseContext | null { + return this.getRuleContext(0, Func_alias_clauseContext); + } + public KW_ONLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ONLY, 0); + } + public STAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.STAR, 0); + } + public column_list(): Column_listContext | null { + return this.getRuleContext(0, Column_listContext); + } + public where_clause(): Where_clauseContext | null { + return this.getRuleContext(0, Where_clauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_xmltable_column_option_list; + return PostgreSqlParser.RULE_table_ref; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterXmltable_column_option_list) { - listener.enterXmltable_column_option_list(this); + if(listener.enterTable_ref) { + listener.enterTable_ref(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitXmltable_column_option_list) { - listener.exitXmltable_column_option_list(this); + if(listener.exitTable_ref) { + listener.exitTable_ref(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitXmltable_column_option_list) { - return visitor.visitXmltable_column_option_list(this); + if (visitor.visitTable_ref) { + return visitor.visitTable_ref(this); } else { return visitor.visitChildren(this); } @@ -101050,41 +76969,41 @@ export class Xmltable_column_option_listContext extends antlr.ParserRuleContext } -export class Xmltable_column_option_elContext extends antlr.ParserRuleContext { +export class Alias_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } - public identifier(): IdentifierContext | null { - return this.getRuleContext(0, IdentifierContext); + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); + public name_list(): Name_listContext | null { + return this.getRuleContext(0, Name_listContext); } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_xmltable_column_option_el; + return PostgreSqlParser.RULE_alias_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterXmltable_column_option_el) { - listener.enterXmltable_column_option_el(this); + if(listener.enterAlias_clause) { + listener.enterAlias_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitXmltable_column_option_el) { - listener.exitXmltable_column_option_el(this); + if(listener.exitAlias_clause) { + listener.exitAlias_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitXmltable_column_option_el) { - return visitor.visitXmltable_column_option_el(this); + if (visitor.visitAlias_clause) { + return visitor.visitAlias_clause(this); } else { return visitor.visitChildren(this); } @@ -101092,44 +77011,44 @@ export class Xmltable_column_option_elContext extends antlr.ParserRuleContext { } -export class Xml_namespace_listContext extends antlr.ParserRuleContext { +export class Func_alias_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public xml_namespace_el(): Xml_namespace_elContext[]; - public xml_namespace_el(i: number): Xml_namespace_elContext | null; - public xml_namespace_el(i?: number): Xml_namespace_elContext[] | Xml_namespace_elContext | null { - if (i === undefined) { - return this.getRuleContexts(Xml_namespace_elContext); - } - - return this.getRuleContext(i, Xml_namespace_elContext); + public alias_clause(): Alias_clauseContext | null { + return this.getRuleContext(0, Alias_clauseContext); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + } + public tablefuncelementlist(): TablefuncelementlistContext | null { + return this.getRuleContext(0, TablefuncelementlistContext); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); + } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_xml_namespace_list; + return PostgreSqlParser.RULE_func_alias_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterXml_namespace_list) { - listener.enterXml_namespace_list(this); + if(listener.enterFunc_alias_clause) { + listener.enterFunc_alias_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitXml_namespace_list) { - listener.exitXml_namespace_list(this); + if(listener.exitFunc_alias_clause) { + listener.exitFunc_alias_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitXml_namespace_list) { - return visitor.visitXml_namespace_list(this); + if (visitor.visitFunc_alias_clause) { + return visitor.visitFunc_alias_clause(this); } else { return visitor.visitChildren(this); } @@ -101137,38 +77056,41 @@ export class Xml_namespace_listContext extends antlr.ParserRuleContext { } -export class Xml_namespace_elContext extends antlr.ParserRuleContext { +export class Join_typeContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public b_expr(): B_exprContext { - return this.getRuleContext(0, B_exprContext)!; + public KW_FULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FULL, 0); + } + public KW_LEFT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LEFT, 0); } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); + public KW_RIGHT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RIGHT, 0); } - public collabel(): CollabelContext | null { - return this.getRuleContext(0, CollabelContext); + public KW_INNER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INNER, 0); } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); + public KW_OUTER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OUTER, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_xml_namespace_el; + return PostgreSqlParser.RULE_join_type; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterXml_namespace_el) { - listener.enterXml_namespace_el(this); + if(listener.enterJoin_type) { + listener.enterJoin_type(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitXml_namespace_el) { - listener.exitXml_namespace_el(this); + if(listener.exitJoin_type) { + listener.exitJoin_type(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitXml_namespace_el) { - return visitor.visitXml_namespace_el(this); + if (visitor.visitJoin_type) { + return visitor.visitJoin_type(this); } else { return visitor.visitChildren(this); } @@ -101176,59 +77098,38 @@ export class Xml_namespace_elContext extends antlr.ParserRuleContext { } -export class TypenameContext extends antlr.ParserRuleContext { +export class Join_qualContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public simpletypename(): SimpletypenameContext | null { - return this.getRuleContext(0, SimpletypenameContext); - } - public opt_array_bounds(): Opt_array_boundsContext | null { - return this.getRuleContext(0, Opt_array_boundsContext); - } - public KW_ARRAY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ARRAY, 0); - } - public KW_SETOF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SETOF, 0); - } - public OPEN_BRACKET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_BRACKET, 0); - } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); - } - public CLOSE_BRACKET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_BRACKET, 0); - } - public qualified_name(): Qualified_nameContext | null { - return this.getRuleContext(0, Qualified_nameContext); + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USING, 0); } - public PERCENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.PERCENT, 0); + public opt_column_list(): Opt_column_listContext | null { + return this.getRuleContext(0, Opt_column_listContext); } - public KW_ROWTYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROWTYPE, 0); + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ON, 0); } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_typename; + return PostgreSqlParser.RULE_join_qual; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTypename) { - listener.enterTypename(this); + if(listener.enterJoin_qual) { + listener.enterJoin_qual(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTypename) { - listener.exitTypename(this); + if(listener.exitJoin_qual) { + listener.exitJoin_qual(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTypename) { - return visitor.visitTypename(this); + if (visitor.visitJoin_qual) { + return visitor.visitJoin_qual(this); } else { return visitor.visitChildren(this); } @@ -101236,53 +77137,53 @@ export class TypenameContext extends antlr.ParserRuleContext { } -export class Opt_array_boundsContext extends antlr.ParserRuleContext { +export class Relation_exprContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public OPEN_BRACKET(): antlr.TerminalNode[]; - public OPEN_BRACKET(i: number): antlr.TerminalNode | null; - public OPEN_BRACKET(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.OPEN_BRACKET); - } else { - return this.getToken(PostgreSqlParser.OPEN_BRACKET, i); - } + public truncate_table(): Truncate_tableContext | null { + return this.getRuleContext(0, Truncate_tableContext); } - public CLOSE_BRACKET(): antlr.TerminalNode[]; - public CLOSE_BRACKET(i: number): antlr.TerminalNode | null; - public CLOSE_BRACKET(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.CLOSE_BRACKET); - } else { - return this.getToken(PostgreSqlParser.CLOSE_BRACKET, i); - } + public KW_ONLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ONLY, 0); } - public iconst(): IconstContext[]; - public iconst(i: number): IconstContext | null; - public iconst(i?: number): IconstContext[] | IconstContext | null { - if (i === undefined) { - return this.getRuleContexts(IconstContext); - } - - return this.getRuleContext(i, IconstContext); + public table_name(): Table_nameContext | null { + return this.getRuleContext(0, Table_nameContext); + } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); + } + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); + } + public schema_name(): Schema_nameContext | null { + return this.getRuleContext(0, Schema_nameContext); + } + public KW_CURRENT_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT_SCHEMA, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_array_bounds; + return PostgreSqlParser.RULE_relation_expr; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_array_bounds) { - listener.enterOpt_array_bounds(this); + if(listener.enterRelation_expr) { + listener.enterRelation_expr(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_array_bounds) { - listener.exitOpt_array_bounds(this); + if(listener.exitRelation_expr) { + listener.exitRelation_expr(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_array_bounds) { - return visitor.visitOpt_array_bounds(this); + if (visitor.visitRelation_expr) { + return visitor.visitRelation_expr(this); } else { return visitor.visitChildren(this); } @@ -101290,56 +77191,65 @@ export class Opt_array_boundsContext extends antlr.ParserRuleContext { } -export class SimpletypenameContext extends antlr.ParserRuleContext { +export class Publication_relation_exprContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public generictype(): GenerictypeContext | null { - return this.getRuleContext(0, GenerictypeContext); + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } - public numeric(): NumericContext | null { - return this.getRuleContext(0, NumericContext); + public truncate_table(): Truncate_tableContext | null { + return this.getRuleContext(0, Truncate_tableContext); } - public bit(): BitContext | null { - return this.getRuleContext(0, BitContext); + public opt_column_list(): Opt_column_listContext | null { + return this.getRuleContext(0, Opt_column_listContext); } - public character(): CharacterContext | null { - return this.getRuleContext(0, CharacterContext); + public where_clause(): Where_clauseContext | null { + return this.getRuleContext(0, Where_clauseContext); } - public constdatetime(): ConstdatetimeContext | null { - return this.getRuleContext(0, ConstdatetimeContext); + public KW_ONLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ONLY, 0); } - public constinterval(): ConstintervalContext | null { - return this.getRuleContext(0, ConstintervalContext); + public table_name(): Table_nameContext | null { + return this.getRuleContext(0, Table_nameContext); } public OPEN_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); - } public CLOSE_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public opt_interval(): Opt_intervalContext | null { - return this.getRuleContext(0, Opt_intervalContext); + public KW_TABLES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLES, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); + } + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); + } + public schema_name(): Schema_nameContext | null { + return this.getRuleContext(0, Schema_nameContext); + } + public KW_CURRENT_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT_SCHEMA, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_simpletypename; + return PostgreSqlParser.RULE_publication_relation_expr; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSimpletypename) { - listener.enterSimpletypename(this); + if(listener.enterPublication_relation_expr) { + listener.enterPublication_relation_expr(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSimpletypename) { - listener.exitSimpletypename(this); + if(listener.exitPublication_relation_expr) { + listener.exitPublication_relation_expr(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSimpletypename) { - return visitor.visitSimpletypename(this); + if (visitor.visitPublication_relation_expr) { + return visitor.visitPublication_relation_expr(this); } else { return visitor.visitChildren(this); } @@ -101347,38 +77257,44 @@ export class SimpletypenameContext extends antlr.ParserRuleContext { } -export class ConsttypenameContext extends antlr.ParserRuleContext { +export class Relation_expr_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public numeric(): NumericContext | null { - return this.getRuleContext(0, NumericContext); - } - public constbit(): ConstbitContext | null { - return this.getRuleContext(0, ConstbitContext); - } - public constcharacter(): ConstcharacterContext | null { - return this.getRuleContext(0, ConstcharacterContext); + public relation_expr(): Relation_exprContext[]; + public relation_expr(i: number): Relation_exprContext | null; + public relation_expr(i?: number): Relation_exprContext[] | Relation_exprContext | null { + if (i === undefined) { + return this.getRuleContexts(Relation_exprContext); + } + + return this.getRuleContext(i, Relation_exprContext); } - public constdatetime(): ConstdatetimeContext | null { - return this.getRuleContext(0, ConstdatetimeContext); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_consttypename; + return PostgreSqlParser.RULE_relation_expr_list; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterConsttypename) { - listener.enterConsttypename(this); + if(listener.enterRelation_expr_list) { + listener.enterRelation_expr_list(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitConsttypename) { - listener.exitConsttypename(this); + if(listener.exitRelation_expr_list) { + listener.exitRelation_expr_list(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitConsttypename) { - return visitor.visitConsttypename(this); + if (visitor.visitRelation_expr_list) { + return visitor.visitRelation_expr_list(this); } else { return visitor.visitChildren(this); } @@ -101386,35 +77302,35 @@ export class ConsttypenameContext extends antlr.ParserRuleContext { } -export class GenerictypeContext extends antlr.ParserRuleContext { +export class Relation_expr_opt_aliasContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public type_function_name(): Type_function_nameContext { - return this.getRuleContext(0, Type_function_nameContext)!; + public relation_expr(): Relation_exprContext { + return this.getRuleContext(0, Relation_exprContext)!; } - public attrs(): AttrsContext | null { - return this.getRuleContext(0, AttrsContext); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public opt_type_modifiers(): Opt_type_modifiersContext | null { - return this.getRuleContext(0, Opt_type_modifiersContext); + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_generictype; + return PostgreSqlParser.RULE_relation_expr_opt_alias; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGenerictype) { - listener.enterGenerictype(this); + if(listener.enterRelation_expr_opt_alias) { + listener.enterRelation_expr_opt_alias(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGenerictype) { - listener.exitGenerictype(this); + if(listener.exitRelation_expr_opt_alias) { + listener.exitRelation_expr_opt_alias(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGenerictype) { - return visitor.visitGenerictype(this); + if (visitor.visitRelation_expr_opt_alias) { + return visitor.visitRelation_expr_opt_alias(this); } else { return visitor.visitChildren(this); } @@ -101422,35 +77338,47 @@ export class GenerictypeContext extends antlr.ParserRuleContext { } -export class Opt_type_modifiersContext extends antlr.ParserRuleContext { +export class Tablesample_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public KW_TABLESAMPLE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TABLESAMPLE, 0)!; } - public expr_list(): Expr_listContext { - return this.getRuleContext(0, Expr_listContext)!; + public function_name(): Function_nameContext { + return this.getRuleContext(0, Function_nameContext)!; } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public execute_param_clause(): Execute_param_clauseContext { + return this.getRuleContext(0, Execute_param_clauseContext)!; + } + public KW_REPEATABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REPEATABLE, 0); + } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_type_modifiers; + return PostgreSqlParser.RULE_tablesample_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_type_modifiers) { - listener.enterOpt_type_modifiers(this); + if(listener.enterTablesample_clause) { + listener.enterTablesample_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_type_modifiers) { - listener.exitOpt_type_modifiers(this); + if(listener.exitTablesample_clause) { + listener.exitTablesample_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_type_modifiers) { - return visitor.visitOpt_type_modifiers(this); + if (visitor.visitTablesample_clause) { + return visitor.visitTablesample_clause(this); } else { return visitor.visitChildren(this); } @@ -101458,68 +77386,65 @@ export class Opt_type_modifiersContext extends antlr.ParserRuleContext { } -export class NumericContext extends antlr.ParserRuleContext { +export class Func_tableContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_INT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INT, 0); - } - public KW_INTEGER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INTEGER, 0); - } - public KW_SMALLINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SMALLINT, 0); - } - public KW_BIGINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BIGINT, 0); - } - public KW_REAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REAL, 0); - } - public KW_FLOAT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FLOAT, 0); + public func_expr_windowless(): Func_expr_windowlessContext | null { + return this.getRuleContext(0, Func_expr_windowlessContext); } - public opt_float(): Opt_floatContext | null { - return this.getRuleContext(0, Opt_floatContext); + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } - public KW_DOUBLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DOUBLE, 0); + public KW_ORDINALITY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ORDINALITY, 0); } - public KW_PRECISION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRECISION, 0); + public KW_ROWS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROWS, 0); } - public KW_DECIMAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DECIMAL, 0); + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); } - public opt_type_modifiers(): Opt_type_modifiersContext | null { - return this.getRuleContext(0, Opt_type_modifiersContext); + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public KW_DEC(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEC, 0); + public rowsfrom_item(): Rowsfrom_itemContext[]; + public rowsfrom_item(i: number): Rowsfrom_itemContext | null; + public rowsfrom_item(i?: number): Rowsfrom_itemContext[] | Rowsfrom_itemContext | null { + if (i === undefined) { + return this.getRuleContexts(Rowsfrom_itemContext); + } + + return this.getRuleContext(i, Rowsfrom_itemContext); } - public KW_NUMERIC(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NUMERIC, 0); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public KW_BOOLEAN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BOOLEAN, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_numeric; + return PostgreSqlParser.RULE_func_table; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterNumeric) { - listener.enterNumeric(this); + if(listener.enterFunc_table) { + listener.enterFunc_table(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitNumeric) { - listener.exitNumeric(this); + if(listener.exitFunc_table) { + listener.exitFunc_table(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitNumeric) { - return visitor.visitNumeric(this); + if (visitor.visitFunc_table) { + return visitor.visitFunc_table(this); } else { return visitor.visitChildren(this); } @@ -101527,35 +77452,41 @@ export class NumericContext extends antlr.ParserRuleContext { } -export class Opt_floatContext extends antlr.ParserRuleContext { +export class Rowsfrom_itemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public func_expr_windowless(): Func_expr_windowlessContext { + return this.getRuleContext(0, Func_expr_windowlessContext)!; + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } - public iconst(): IconstContext { - return this.getRuleContext(0, IconstContext)!; + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public tablefuncelementlist(): TablefuncelementlistContext | null { + return this.getRuleContext(0, TablefuncelementlistContext); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_float; + return PostgreSqlParser.RULE_rowsfrom_item; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_float) { - listener.enterOpt_float(this); + if(listener.enterRowsfrom_item) { + listener.enterRowsfrom_item(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_float) { - listener.exitOpt_float(this); + if(listener.exitRowsfrom_item) { + listener.exitRowsfrom_item(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_float) { - return visitor.visitOpt_float(this); + if (visitor.visitRowsfrom_item) { + return visitor.visitRowsfrom_item(this); } else { return visitor.visitChildren(this); } @@ -101563,32 +77494,32 @@ export class Opt_floatContext extends antlr.ParserRuleContext { } -export class BitContext extends antlr.ParserRuleContext { +export class Where_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public bitwithlength(): BitwithlengthContext | null { - return this.getRuleContext(0, BitwithlengthContext); + public KW_WHERE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WHERE, 0)!; } - public bitwithoutlength(): BitwithoutlengthContext | null { - return this.getRuleContext(0, BitwithoutlengthContext); + public column_expr_noparen(): Column_expr_noparenContext { + return this.getRuleContext(0, Column_expr_noparenContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_bit; + return PostgreSqlParser.RULE_where_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterBit) { - listener.enterBit(this); + if(listener.enterWhere_clause) { + listener.enterWhere_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitBit) { - listener.exitBit(this); + if(listener.exitWhere_clause) { + listener.exitWhere_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitBit) { - return visitor.visitBit(this); + if (visitor.visitWhere_clause) { + return visitor.visitWhere_clause(this); } else { return visitor.visitChildren(this); } @@ -101596,32 +77527,41 @@ export class BitContext extends antlr.ParserRuleContext { } -export class ConstbitContext extends antlr.ParserRuleContext { +export class Where_or_current_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public bitwithlength(): BitwithlengthContext | null { - return this.getRuleContext(0, BitwithlengthContext); + public KW_WHERE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_WHERE, 0)!; + } + public KW_CURRENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT, 0); + } + public KW_OF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OF, 0); + } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public bitwithoutlength(): BitwithoutlengthContext | null { - return this.getRuleContext(0, BitwithoutlengthContext); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_constbit; + return PostgreSqlParser.RULE_where_or_current_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterConstbit) { - listener.enterConstbit(this); + if(listener.enterWhere_or_current_clause) { + listener.enterWhere_or_current_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitConstbit) { - listener.exitConstbit(this); + if(listener.exitWhere_or_current_clause) { + listener.exitWhere_or_current_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitConstbit) { - return visitor.visitConstbit(this); + if (visitor.visitWhere_or_current_clause) { + return visitor.visitWhere_or_current_clause(this); } else { return visitor.visitChildren(this); } @@ -101629,41 +77569,44 @@ export class ConstbitContext extends antlr.ParserRuleContext { } -export class BitwithlengthContext extends antlr.ParserRuleContext { +export class TablefuncelementlistContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_BIT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BIT, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public expr_list(): Expr_listContext { - return this.getRuleContext(0, Expr_listContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public tablefuncelement(): TablefuncelementContext[]; + public tablefuncelement(i: number): TablefuncelementContext | null; + public tablefuncelement(i?: number): TablefuncelementContext[] | TablefuncelementContext | null { + if (i === undefined) { + return this.getRuleContexts(TablefuncelementContext); + } + + return this.getRuleContext(i, TablefuncelementContext); } - public opt_varying(): Opt_varyingContext | null { - return this.getRuleContext(0, Opt_varyingContext); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_bitwithlength; + return PostgreSqlParser.RULE_tablefuncelementlist; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterBitwithlength) { - listener.enterBitwithlength(this); + if(listener.enterTablefuncelementlist) { + listener.enterTablefuncelementlist(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitBitwithlength) { - listener.exitBitwithlength(this); + if(listener.exitTablefuncelementlist) { + listener.exitTablefuncelementlist(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitBitwithlength) { - return visitor.visitBitwithlength(this); + if (visitor.visitTablefuncelementlist) { + return visitor.visitTablefuncelementlist(this); } else { return visitor.visitChildren(this); } @@ -101671,32 +77614,35 @@ export class BitwithlengthContext extends antlr.ParserRuleContext { } -export class BitwithoutlengthContext extends antlr.ParserRuleContext { +export class TablefuncelementContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_BIT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BIT, 0)!; + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public opt_varying(): Opt_varyingContext | null { - return this.getRuleContext(0, Opt_varyingContext); + public typename(): TypenameContext { + return this.getRuleContext(0, TypenameContext)!; + } + public opt_collate_clause(): Opt_collate_clauseContext | null { + return this.getRuleContext(0, Opt_collate_clauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_bitwithoutlength; + return PostgreSqlParser.RULE_tablefuncelement; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterBitwithoutlength) { - listener.enterBitwithoutlength(this); + if(listener.enterTablefuncelement) { + listener.enterTablefuncelement(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitBitwithoutlength) { - listener.exitBitwithoutlength(this); + if(listener.exitTablefuncelement) { + listener.exitTablefuncelement(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitBitwithoutlength) { - return visitor.visitBitwithoutlength(this); + if (visitor.visitTablefuncelement) { + return visitor.visitTablefuncelement(this); } else { return visitor.visitChildren(this); } @@ -101704,77 +77650,86 @@ export class BitwithoutlengthContext extends antlr.ParserRuleContext { } -export class CharacterContext extends antlr.ParserRuleContext { +export class XmltableContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public character_c(): Character_cContext { - return this.getRuleContext(0, Character_cContext)!; - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_XMLTABLE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_XMLTABLE, 0)!; } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); + public OPEN_PAREN(): antlr.TerminalNode[]; + public OPEN_PAREN(i: number): antlr.TerminalNode | null; + public OPEN_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.OPEN_PAREN); + } else { + return this.getToken(PostgreSqlParser.OPEN_PAREN, i); + } } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public CLOSE_PAREN(): antlr.TerminalNode[]; + public CLOSE_PAREN(i: number): antlr.TerminalNode | null; + public CLOSE_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.CLOSE_PAREN); + } else { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, i); + } } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_character; + public primaryExpression(): PrimaryExpressionContext | null { + return this.getRuleContext(0, PrimaryExpressionContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCharacter) { - listener.enterCharacter(this); - } + public xmlexists_argument(): Xmlexists_argumentContext | null { + return this.getRuleContext(0, Xmlexists_argumentContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCharacter) { - listener.exitCharacter(this); - } + public KW_COLUMNS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLUMNS, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCharacter) { - return visitor.visitCharacter(this); - } else { - return visitor.visitChildren(this); + public xmltable_column_el(): Xmltable_column_elContext[]; + public xmltable_column_el(i: number): Xmltable_column_elContext | null; + public xmltable_column_el(i?: number): Xmltable_column_elContext[] | Xmltable_column_elContext | null { + if (i === undefined) { + return this.getRuleContexts(Xmltable_column_elContext); } - } -} - -export class ConstcharacterContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public character_c(): Character_cContext { - return this.getRuleContext(0, Character_cContext)!; + return this.getRuleContext(i, Xmltable_column_elContext); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_XMLNAMESPACES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLNAMESPACES, 0); } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); + public xml_namespace_el(): Xml_namespace_elContext[]; + public xml_namespace_el(i: number): Xml_namespace_elContext | null; + public xml_namespace_el(i?: number): Xml_namespace_elContext[] | Xml_namespace_elContext | null { + if (i === undefined) { + return this.getRuleContexts(Xml_namespace_elContext); + } + + return this.getRuleContext(i, Xml_namespace_elContext); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_constcharacter; + return PostgreSqlParser.RULE_xmltable; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterConstcharacter) { - listener.enterConstcharacter(this); + if(listener.enterXmltable) { + listener.enterXmltable(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitConstcharacter) { - listener.exitConstcharacter(this); + if(listener.exitXmltable) { + listener.exitXmltable(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitConstcharacter) { - return visitor.visitConstcharacter(this); + if (visitor.visitXmltable) { + return visitor.visitXmltable(this); } else { return visitor.visitChildren(this); } @@ -101782,44 +77737,83 @@ export class ConstcharacterContext extends antlr.ParserRuleContext { } -export class Character_cContext extends antlr.ParserRuleContext { +export class Xmltable_column_elContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CHARACTER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CHARACTER, 0); + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } - public KW_CHAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CHAR, 0); + public typename(): TypenameContext | null { + return this.getRuleContext(0, TypenameContext); } - public KW_NCHAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NCHAR, 0); + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); + } + public KW_ORDINALITY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ORDINALITY, 0); } - public opt_varying(): Opt_varyingContext | null { - return this.getRuleContext(0, Opt_varyingContext); + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); } - public KW_VARCHAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VARCHAR, 0); + public KW_NULL(): antlr.TerminalNode[]; + public KW_NULL(i: number): antlr.TerminalNode | null; + public KW_NULL(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_NULL); + } else { + return this.getToken(PostgreSqlParser.KW_NULL, i); + } } - public KW_NATIONAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NATIONAL, 0); + public KW_DEFAULT(): antlr.TerminalNode[]; + public KW_DEFAULT(i: number): antlr.TerminalNode | null; + public KW_DEFAULT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_DEFAULT); + } else { + return this.getToken(PostgreSqlParser.KW_DEFAULT, i); + } + } + public identifier(): IdentifierContext[]; + public identifier(i: number): IdentifierContext | null; + public identifier(i?: number): IdentifierContext[] | IdentifierContext | null { + if (i === undefined) { + return this.getRuleContexts(IdentifierContext); + } + + return this.getRuleContext(i, IdentifierContext); + } + public KW_NOT(): antlr.TerminalNode[]; + public KW_NOT(i: number): antlr.TerminalNode | null; + public KW_NOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_NOT); + } else { + return this.getToken(PostgreSqlParser.KW_NOT, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_character_c; + return PostgreSqlParser.RULE_xmltable_column_el; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCharacter_c) { - listener.enterCharacter_c(this); + if(listener.enterXmltable_column_el) { + listener.enterXmltable_column_el(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCharacter_c) { - listener.exitCharacter_c(this); + if(listener.exitXmltable_column_el) { + listener.exitXmltable_column_el(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCharacter_c) { - return visitor.visitCharacter_c(this); + if (visitor.visitXmltable_column_el) { + return visitor.visitXmltable_column_el(this); } else { return visitor.visitChildren(this); } @@ -101827,29 +77821,38 @@ export class Character_cContext extends antlr.ParserRuleContext { } -export class Opt_varyingContext extends antlr.ParserRuleContext { +export class Xml_namespace_elContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_VARYING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VARYING, 0)!; + public primaryExpression(): PrimaryExpressionContext { + return this.getRuleContext(0, PrimaryExpressionContext)!; + } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); + } + public collabel(): CollabelContext | null { + return this.getRuleContext(0, CollabelContext); + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_varying; + return PostgreSqlParser.RULE_xml_namespace_el; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_varying) { - listener.enterOpt_varying(this); + if(listener.enterXml_namespace_el) { + listener.enterXml_namespace_el(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_varying) { - listener.exitOpt_varying(this); + if(listener.exitXml_namespace_el) { + listener.exitXml_namespace_el(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_varying) { - return visitor.visitOpt_varying(this); + if (visitor.visitXml_namespace_el) { + return visitor.visitXml_namespace_el(this); } else { return visitor.visitChildren(this); } @@ -101857,44 +77860,74 @@ export class Opt_varyingContext extends antlr.ParserRuleContext { } -export class ConstdatetimeContext extends antlr.ParserRuleContext { +export class TypenameContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_TIMESTAMP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TIMESTAMP, 0); + public simpletypename(): SimpletypenameContext | null { + return this.getRuleContext(0, SimpletypenameContext); } - public KW_TIME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TIME, 0); + public KW_ARRAY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ARRAY, 0); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_SETOF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SETOF, 0); + } + public OPEN_BRACKET(): antlr.TerminalNode[]; + public OPEN_BRACKET(i: number): antlr.TerminalNode | null; + public OPEN_BRACKET(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.OPEN_BRACKET); + } else { + return this.getToken(PostgreSqlParser.OPEN_BRACKET, i); + } } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); + public Integral(): antlr.TerminalNode[]; + public Integral(i: number): antlr.TerminalNode | null; + public Integral(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.Integral); + } else { + return this.getToken(PostgreSqlParser.Integral, i); + } } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public CLOSE_BRACKET(): antlr.TerminalNode[]; + public CLOSE_BRACKET(i: number): antlr.TerminalNode | null; + public CLOSE_BRACKET(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.CLOSE_BRACKET); + } else { + return this.getToken(PostgreSqlParser.CLOSE_BRACKET, i); + } + } + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); + } + public PERCENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.PERCENT, 0); + } + public KW_ROWTYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROWTYPE, 0); } - public opt_timezone(): Opt_timezoneContext | null { - return this.getRuleContext(0, Opt_timezoneContext); + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_constdatetime; + return PostgreSqlParser.RULE_typename; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterConstdatetime) { - listener.enterConstdatetime(this); + if(listener.enterTypename) { + listener.enterTypename(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitConstdatetime) { - listener.exitConstdatetime(this); + if(listener.exitTypename) { + listener.exitTypename(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitConstdatetime) { - return visitor.visitConstdatetime(this); + if (visitor.visitTypename) { + return visitor.visitTypename(this); } else { return visitor.visitChildren(this); } @@ -101902,29 +77935,47 @@ export class ConstdatetimeContext extends antlr.ParserRuleContext { } -export class ConstintervalContext extends antlr.ParserRuleContext { +export class SimpletypenameContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_INTERVAL(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INTERVAL, 0)!; + public type_function_name(): Type_function_nameContext | null { + return this.getRuleContext(0, Type_function_nameContext); + } + public attrs(): AttrsContext | null { + return this.getRuleContext(0, AttrsContext); + } + public execute_param_clause(): Execute_param_clauseContext | null { + return this.getRuleContext(0, Execute_param_clauseContext); + } + public consttypename(): ConsttypenameContext | null { + return this.getRuleContext(0, ConsttypenameContext); + } + public KW_INTERVAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INTERVAL, 0); + } + public opt_float(): Opt_floatContext | null { + return this.getRuleContext(0, Opt_floatContext); + } + public opt_interval(): Opt_intervalContext | null { + return this.getRuleContext(0, Opt_intervalContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_constinterval; + return PostgreSqlParser.RULE_simpletypename; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterConstinterval) { - listener.enterConstinterval(this); + if(listener.enterSimpletypename) { + listener.enterSimpletypename(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitConstinterval) { - listener.exitConstinterval(this); + if(listener.exitSimpletypename) { + listener.exitSimpletypename(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitConstinterval) { - return visitor.visitConstinterval(this); + if (visitor.visitSimpletypename) { + return visitor.visitSimpletypename(this); } else { return visitor.visitChildren(this); } @@ -101932,38 +77983,38 @@ export class ConstintervalContext extends antlr.ParserRuleContext { } -export class Opt_timezoneContext extends antlr.ParserRuleContext { +export class ConsttypenameContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); + public numeric(): NumericContext | null { + return this.getRuleContext(0, NumericContext); } - public KW_TIME(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_TIME, 0)!; + public bit(): BitContext | null { + return this.getRuleContext(0, BitContext); } - public KW_ZONE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ZONE, 0)!; + public character(): CharacterContext | null { + return this.getRuleContext(0, CharacterContext); } - public KW_WITHOUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); + public constdatetime(): ConstdatetimeContext | null { + return this.getRuleContext(0, ConstdatetimeContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_timezone; + return PostgreSqlParser.RULE_consttypename; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_timezone) { - listener.enterOpt_timezone(this); + if(listener.enterConsttypename) { + listener.enterConsttypename(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_timezone) { - listener.exitOpt_timezone(this); + if(listener.exitConsttypename) { + listener.exitConsttypename(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_timezone) { - return visitor.visitOpt_timezone(this); + if (visitor.visitConsttypename) { + return visitor.visitConsttypename(this); } else { return visitor.visitChildren(this); } @@ -101971,86 +78022,68 @@ export class Opt_timezoneContext extends antlr.ParserRuleContext { } -export class Opt_intervalContext extends antlr.ParserRuleContext { +export class NumericContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_YEAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_YEAR, 0); - } - public KW_MONTH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MONTH, 0); - } - public KW_DAY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DAY, 0); + public KW_INT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INT, 0); } - public KW_HOUR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_HOUR, 0); + public KW_INTEGER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INTEGER, 0); } - public KW_MINUTE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_MINUTE, 0); + public KW_SMALLINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SMALLINT, 0); } - public interval_second(): Interval_secondContext | null { - return this.getRuleContext(0, Interval_secondContext); + public KW_BIGINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BIGINT, 0); } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); + public KW_REAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REAL, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_interval; + public KW_FLOAT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FLOAT, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_interval) { - listener.enterOpt_interval(this); - } + public opt_float(): Opt_floatContext | null { + return this.getRuleContext(0, Opt_floatContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_interval) { - listener.exitOpt_interval(this); - } + public KW_DOUBLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DOUBLE, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_interval) { - return visitor.visitOpt_interval(this); - } else { - return visitor.visitChildren(this); - } + public KW_PRECISION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRECISION, 0); } -} - - -export class Interval_secondContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_DECIMAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DECIMAL, 0); } - public KW_SECOND(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_SECOND, 0)!; + public KW_DEC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEC, 0); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_NUMERIC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NUMERIC, 0); } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); + public execute_param_clause(): Execute_param_clauseContext | null { + return this.getRuleContext(0, Execute_param_clauseContext); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_BOOLEAN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BOOLEAN, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_interval_second; + return PostgreSqlParser.RULE_numeric; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterInterval_second) { - listener.enterInterval_second(this); + if(listener.enterNumeric) { + listener.enterNumeric(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitInterval_second) { - listener.exitInterval_second(this); + if(listener.exitNumeric) { + listener.exitNumeric(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitInterval_second) { - return visitor.visitInterval_second(this); + if (visitor.visitNumeric) { + return visitor.visitNumeric(this); } else { return visitor.visitChildren(this); } @@ -102058,32 +78091,35 @@ export class Interval_secondContext extends antlr.ParserRuleContext { } -export class Opt_escapeContext extends antlr.ParserRuleContext { +export class Opt_floatContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ESCAPE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ESCAPE, 0)!; + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + } + public Integral(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.Integral, 0)!; } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_escape; + return PostgreSqlParser.RULE_opt_float; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_escape) { - listener.enterOpt_escape(this); + if(listener.enterOpt_float) { + listener.enterOpt_float(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_escape) { - listener.exitOpt_escape(this); + if(listener.exitOpt_float) { + listener.exitOpt_float(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_escape) { - return visitor.visitOpt_escape(this); + if (visitor.visitOpt_float) { + return visitor.visitOpt_float(this); } else { return visitor.visitChildren(this); } @@ -102091,29 +78127,35 @@ export class Opt_escapeContext extends antlr.ParserRuleContext { } -export class A_exprContext extends antlr.ParserRuleContext { +export class BitContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr_qual(): A_expr_qualContext { - return this.getRuleContext(0, A_expr_qualContext)!; + public KW_BIT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_BIT, 0)!; + } + public KW_VARYING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VARYING, 0); + } + public execute_param_clause(): Execute_param_clauseContext | null { + return this.getRuleContext(0, Execute_param_clauseContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr; + return PostgreSqlParser.RULE_bit; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr) { - listener.enterA_expr(this); + if(listener.enterBit) { + listener.enterBit(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr) { - listener.exitA_expr(this); + if(listener.exitBit) { + listener.exitBit(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr) { - return visitor.visitA_expr(this); + if (visitor.visitBit) { + return visitor.visitBit(this); } else { return visitor.visitChildren(this); } @@ -102121,32 +78163,47 @@ export class A_exprContext extends antlr.ParserRuleContext { } -export class A_expr_qualContext extends antlr.ParserRuleContext { +export class CharacterContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr_lessless(): A_expr_lesslessContext { - return this.getRuleContext(0, A_expr_lesslessContext)!; + public KW_VARCHAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VARCHAR, 0); } - public qual_op(): Qual_opContext | null { - return this.getRuleContext(0, Qual_opContext); + public KW_NATIONAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NATIONAL, 0); + } + public KW_CHARACTER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CHARACTER, 0); + } + public KW_CHAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CHAR, 0); + } + public KW_NCHAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NCHAR, 0); + } + public opt_float(): Opt_floatContext | null { + return this.getRuleContext(0, Opt_floatContext); + } + public KW_VARYING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VARYING, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_qual; + return PostgreSqlParser.RULE_character; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_qual) { - listener.enterA_expr_qual(this); + if(listener.enterCharacter) { + listener.enterCharacter(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_qual) { - listener.exitA_expr_qual(this); + if(listener.exitCharacter) { + listener.exitCharacter(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_qual) { - return visitor.visitA_expr_qual(this); + if (visitor.visitCharacter) { + return visitor.visitCharacter(this); } else { return visitor.visitChildren(this); } @@ -102154,53 +78211,50 @@ export class A_expr_qualContext extends antlr.ParserRuleContext { } -export class A_expr_lesslessContext extends antlr.ParserRuleContext { +export class ConstdatetimeContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr_or(): A_expr_orContext[]; - public a_expr_or(i: number): A_expr_orContext | null; - public a_expr_or(i?: number): A_expr_orContext[] | A_expr_orContext | null { - if (i === undefined) { - return this.getRuleContexts(A_expr_orContext); - } - - return this.getRuleContext(i, A_expr_orContext); + public KW_TIMESTAMP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TIMESTAMP, 0); } - public LESS_LESS(): antlr.TerminalNode[]; - public LESS_LESS(i: number): antlr.TerminalNode | null; - public LESS_LESS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public KW_TIME(): antlr.TerminalNode[]; + public KW_TIME(i: number): antlr.TerminalNode | null; + public KW_TIME(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.LESS_LESS); + return this.getTokens(PostgreSqlParser.KW_TIME); } else { - return this.getToken(PostgreSqlParser.LESS_LESS, i); + return this.getToken(PostgreSqlParser.KW_TIME, i); } } - public GREATER_GREATER(): antlr.TerminalNode[]; - public GREATER_GREATER(i: number): antlr.TerminalNode | null; - public GREATER_GREATER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.GREATER_GREATER); - } else { - return this.getToken(PostgreSqlParser.GREATER_GREATER, i); - } + public opt_float(): Opt_floatContext | null { + return this.getRuleContext(0, Opt_floatContext); + } + public KW_ZONE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ZONE, 0); + } + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); + } + public KW_WITHOUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_lessless; + return PostgreSqlParser.RULE_constdatetime; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_lessless) { - listener.enterA_expr_lessless(this); + if(listener.enterConstdatetime) { + listener.enterConstdatetime(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_lessless) { - listener.exitA_expr_lessless(this); + if(listener.exitConstdatetime) { + listener.exitConstdatetime(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_lessless) { - return visitor.visitA_expr_lessless(this); + if (visitor.visitConstdatetime) { + return visitor.visitConstdatetime(this); } else { return visitor.visitChildren(this); } @@ -102208,44 +78262,47 @@ export class A_expr_lesslessContext extends antlr.ParserRuleContext { } -export class A_expr_orContext extends antlr.ParserRuleContext { +export class Opt_intervalContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr_and(): A_expr_andContext[]; - public a_expr_and(i: number): A_expr_andContext | null; - public a_expr_and(i?: number): A_expr_andContext[] | A_expr_andContext | null { - if (i === undefined) { - return this.getRuleContexts(A_expr_andContext); - } - - return this.getRuleContext(i, A_expr_andContext); + public KW_MONTH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MONTH, 0); } - public KW_OR(): antlr.TerminalNode[]; - public KW_OR(i: number): antlr.TerminalNode | null; - public KW_OR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_OR); - } else { - return this.getToken(PostgreSqlParser.KW_OR, i); - } + public interval_second(): Interval_secondContext | null { + return this.getRuleContext(0, Interval_secondContext); + } + public KW_YEAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_YEAR, 0); + } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); + } + public KW_DAY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DAY, 0); + } + public KW_HOUR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_HOUR, 0); + } + public KW_MINUTE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_MINUTE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_or; + return PostgreSqlParser.RULE_opt_interval; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_or) { - listener.enterA_expr_or(this); + if(listener.enterOpt_interval) { + listener.enterOpt_interval(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_or) { - listener.exitA_expr_or(this); + if(listener.exitOpt_interval) { + listener.exitOpt_interval(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_or) { - return visitor.visitA_expr_or(this); + if (visitor.visitOpt_interval) { + return visitor.visitOpt_interval(this); } else { return visitor.visitChildren(this); } @@ -102253,44 +78310,32 @@ export class A_expr_orContext extends antlr.ParserRuleContext { } -export class A_expr_andContext extends antlr.ParserRuleContext { +export class Interval_secondContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr_in(): A_expr_inContext[]; - public a_expr_in(i: number): A_expr_inContext | null; - public a_expr_in(i?: number): A_expr_inContext[] | A_expr_inContext | null { - if (i === undefined) { - return this.getRuleContexts(A_expr_inContext); - } - - return this.getRuleContext(i, A_expr_inContext); + public KW_SECOND(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_SECOND, 0)!; } - public KW_AND(): antlr.TerminalNode[]; - public KW_AND(i: number): antlr.TerminalNode | null; - public KW_AND(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_AND); - } else { - return this.getToken(PostgreSqlParser.KW_AND, i); - } + public opt_float(): Opt_floatContext | null { + return this.getRuleContext(0, Opt_floatContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_and; + return PostgreSqlParser.RULE_interval_second; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_and) { - listener.enterA_expr_and(this); + if(listener.enterInterval_second) { + listener.enterInterval_second(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_and) { - listener.exitA_expr_and(this); + if(listener.exitInterval_second) { + listener.exitInterval_second(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_and) { - return visitor.visitA_expr_and(this); + if (visitor.visitInterval_second) { + return visitor.visitInterval_second(this); } else { return visitor.visitChildren(this); } @@ -102298,38 +78343,44 @@ export class A_expr_andContext extends antlr.ParserRuleContext { } -export class A_expr_inContext extends antlr.ParserRuleContext { +export class ComparisonOperatorContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr_unary_not(): A_expr_unary_notContext { - return this.getRuleContext(0, A_expr_unary_notContext)!; + public LT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.LT, 0); } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); + public GT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.GT, 0); + } + public EQUAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.EQUAL, 0); } - public in_expr(): In_exprContext | null { - return this.getRuleContext(0, In_exprContext); + public LESS_EQUALS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.LESS_EQUALS, 0); } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); + public GREATER_EQUALS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.GREATER_EQUALS, 0); + } + public NOT_EQUALS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.NOT_EQUALS, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_in; + return PostgreSqlParser.RULE_comparisonOperator; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_in) { - listener.enterA_expr_in(this); + if(listener.enterComparisonOperator) { + listener.enterComparisonOperator(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_in) { - listener.exitA_expr_in(this); + if(listener.exitComparisonOperator) { + listener.exitComparisonOperator(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_in) { - return visitor.visitA_expr_in(this); + if (visitor.visitComparisonOperator) { + return visitor.visitComparisonOperator(this); } else { return visitor.visitChildren(this); } @@ -102337,32 +78388,29 @@ export class A_expr_inContext extends antlr.ParserRuleContext { } -export class A_expr_unary_notContext extends antlr.ParserRuleContext { +export class ExpressionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr_isnull(): A_expr_isnullContext { - return this.getRuleContext(0, A_expr_isnullContext)!; - } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); + public booleanExpression(): BooleanExpressionContext { + return this.getRuleContext(0, BooleanExpressionContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_unary_not; + return PostgreSqlParser.RULE_expression; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_unary_not) { - listener.enterA_expr_unary_not(this); + if(listener.enterExpression) { + listener.enterExpression(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_unary_not) { - listener.exitA_expr_unary_not(this); + if(listener.exitExpression) { + listener.exitExpression(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_unary_not) { - return visitor.visitA_expr_unary_not(this); + if (visitor.visitExpression) { + return visitor.visitExpression(this); } else { return visitor.visitChildren(this); } @@ -102370,204 +78418,178 @@ export class A_expr_unary_notContext extends antlr.ParserRuleContext { } -export class A_expr_isnullContext extends antlr.ParserRuleContext { +export class BooleanExpressionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr_is_not(): A_expr_is_notContext { - return this.getRuleContext(0, A_expr_is_notContext)!; + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_booleanExpression; } - public KW_ISNULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ISNULL, 0); + public override copyFrom(ctx: BooleanExpressionContext): void { + super.copyFrom(ctx); } - public KW_NOTNULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOTNULL, 0); +} +export class LogicalNotContext extends BooleanExpressionContext { + public constructor(ctx: BooleanExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_isnull; + public KW_NOT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_NOT, 0)!; + } + public booleanExpression(): BooleanExpressionContext { + return this.getRuleContext(0, BooleanExpressionContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_isnull) { - listener.enterA_expr_isnull(this); + if(listener.enterLogicalNot) { + listener.enterLogicalNot(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_isnull) { - listener.exitA_expr_isnull(this); + if(listener.exitLogicalNot) { + listener.exitLogicalNot(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_isnull) { - return visitor.visitA_expr_isnull(this); + if (visitor.visitLogicalNot) { + return visitor.visitLogicalNot(this); } else { return visitor.visitChildren(this); } } } - - -export class A_expr_is_notContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public a_expr_compare(): A_expr_compareContext { - return this.getRuleContext(0, A_expr_compareContext)!; - } - public KW_IS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IS, 0); - } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); - } - public KW_TRUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRUE, 0); - } - public KW_FALSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FALSE, 0); - } - public KW_UNKNOWN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNKNOWN, 0); - } - public KW_DISTINCT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DISTINCT, 0); - } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } - public KW_OF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OF, 0); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public type_list(): Type_listContext | null { - return this.getRuleContext(0, Type_listContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public KW_DOCUMENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DOCUMENT, 0); - } - public KW_NORMALIZED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NORMALIZED, 0); - } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); +export class PredicatedContext extends BooleanExpressionContext { + public _valueExpression?: ValueExpressionContext; + public constructor(ctx: BooleanExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public unicode_normal_form(): Unicode_normal_formContext | null { - return this.getRuleContext(0, Unicode_normal_formContext); + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_is_not; + public predicate(): PredicateContext | null { + return this.getRuleContext(0, PredicateContext); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_is_not) { - listener.enterA_expr_is_not(this); + if(listener.enterPredicated) { + listener.enterPredicated(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_is_not) { - listener.exitA_expr_is_not(this); + if(listener.exitPredicated) { + listener.exitPredicated(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_is_not) { - return visitor.visitA_expr_is_not(this); + if (visitor.visitPredicated) { + return visitor.visitPredicated(this); } else { return visitor.visitChildren(this); } } } - - -export class A_expr_compareContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); +export class LogicalBinaryContext extends BooleanExpressionContext { + public _left?: BooleanExpressionContext; + public _operator?: Token | null; + public _right?: BooleanExpressionContext; + public constructor(ctx: BooleanExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public a_expr_like(): A_expr_likeContext[]; - public a_expr_like(i: number): A_expr_likeContext | null; - public a_expr_like(i?: number): A_expr_likeContext[] | A_expr_likeContext | null { + public booleanExpression(): BooleanExpressionContext[]; + public booleanExpression(i: number): BooleanExpressionContext | null; + public booleanExpression(i?: number): BooleanExpressionContext[] | BooleanExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(A_expr_likeContext); + return this.getRuleContexts(BooleanExpressionContext); } - return this.getRuleContext(i, A_expr_likeContext); - } - public subquery_Op(): Subquery_OpContext | null { - return this.getRuleContext(0, Subquery_OpContext); + return this.getRuleContext(i, BooleanExpressionContext); } - public sub_type(): Sub_typeContext | null { - return this.getRuleContext(0, Sub_typeContext); - } - public LT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.LT, 0); + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AND, 0); } - public GT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.GT, 0); + public KW_OR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OR, 0); } - public EQUAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.EQUAL, 0); + public override enterRule(listener: PostgreSqlParserListener): void { + if(listener.enterLogicalBinary) { + listener.enterLogicalBinary(this); + } } - public LESS_EQUALS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.LESS_EQUALS, 0); + public override exitRule(listener: PostgreSqlParserListener): void { + if(listener.exitLogicalBinary) { + listener.exitLogicalBinary(this); + } } - public GREATER_EQUALS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.GREATER_EQUALS, 0); + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitLogicalBinary) { + return visitor.visitLogicalBinary(this); + } else { + return visitor.visitChildren(this); + } } - public NOT_EQUALS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.NOT_EQUALS, 0); +} + + +export class PredicateContext extends antlr.ParserRuleContext { + public value: antlr.ParserRuleContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number, value: antlr.ParserRuleContext) { + super(parent, invokingState); + this.value = value; } - public select_with_parens(): Select_with_parensContext | null { - return this.getRuleContext(0, Select_with_parensContext); + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_predicate; } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public override copyFrom(ctx: PredicateContext): void { + super.copyFrom(ctx); + this.value = ctx.value; } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); +} +export class ComparisonContext extends PredicateContext { + public _right?: ValueExpressionContext; + public constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + super.copyFrom(ctx); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public comparisonOperator(): ComparisonOperatorContext { + return this.getRuleContext(0, ComparisonOperatorContext)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_compare; + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_compare) { - listener.enterA_expr_compare(this); + if(listener.enterComparison) { + listener.enterComparison(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_compare) { - listener.exitA_expr_compare(this); + if(listener.exitComparison) { + listener.exitComparison(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_compare) { - return visitor.visitA_expr_compare(this); + if (visitor.visitComparison) { + return visitor.visitComparison(this); } else { return visitor.visitChildren(this); } } } - - -export class A_expr_likeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); +export class LikeContext extends PredicateContext { + public _pattern?: ValueExpressionContext; + public _escape?: ValueExpressionContext; + public constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + super.copyFrom(ctx); } - public a_expr_qual_op(): A_expr_qual_opContext[]; - public a_expr_qual_op(i: number): A_expr_qual_opContext | null; - public a_expr_qual_op(i?: number): A_expr_qual_opContext[] | A_expr_qual_opContext | null { + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext | null; + public valueExpression(i?: number): ValueExpressionContext[] | ValueExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(A_expr_qual_opContext); + return this.getRuleContexts(ValueExpressionContext); } - return this.getRuleContext(i, A_expr_qual_opContext); + return this.getRuleContext(i, ValueExpressionContext); } public KW_LIKE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_LIKE, 0); @@ -102587,337 +78609,268 @@ export class A_expr_likeContext extends antlr.ParserRuleContext { public KW_NOT(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_NOT, 0); } - public opt_escape(): Opt_escapeContext | null { - return this.getRuleContext(0, Opt_escapeContext); + public KW_ESCAPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ESCAPE, 0); } public KW_SYMMETRIC(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_SYMMETRIC, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_like; - } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_like) { - listener.enterA_expr_like(this); + if(listener.enterLike) { + listener.enterLike(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_like) { - listener.exitA_expr_like(this); + if(listener.exitLike) { + listener.exitLike(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_like) { - return visitor.visitA_expr_like(this); + if (visitor.visitLike) { + return visitor.visitLike(this); } else { return visitor.visitChildren(this); } } } - - -export class A_expr_qual_opContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); +export class InSubqueryContext extends PredicateContext { + public constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + super.copyFrom(ctx); } - public a_expr_unary_qualop(): A_expr_unary_qualopContext[]; - public a_expr_unary_qualop(i: number): A_expr_unary_qualopContext | null; - public a_expr_unary_qualop(i?: number): A_expr_unary_qualopContext[] | A_expr_unary_qualopContext | null { - if (i === undefined) { - return this.getRuleContexts(A_expr_unary_qualopContext); - } - - return this.getRuleContext(i, A_expr_unary_qualopContext); + public KW_IN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_IN, 0)!; } - public qual_op(): Qual_opContext[]; - public qual_op(i: number): Qual_opContext | null; - public qual_op(i?: number): Qual_opContext[] | Qual_opContext | null { - if (i === undefined) { - return this.getRuleContexts(Qual_opContext); - } - - return this.getRuleContext(i, Qual_opContext); + public select_with_parens(): Select_with_parensContext { + return this.getRuleContext(0, Select_with_parensContext)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_qual_op; + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_qual_op) { - listener.enterA_expr_qual_op(this); + if(listener.enterInSubquery) { + listener.enterInSubquery(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_qual_op) { - listener.exitA_expr_qual_op(this); + if(listener.exitInSubquery) { + listener.exitInSubquery(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_qual_op) { - return visitor.visitA_expr_qual_op(this); + if (visitor.visitInSubquery) { + return visitor.visitInSubquery(this); } else { return visitor.visitChildren(this); } } } - - -export class A_expr_unary_qualopContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public a_expr_add(): A_expr_addContext { - return this.getRuleContext(0, A_expr_addContext)!; - } - public qual_op(): Qual_opContext | null { - return this.getRuleContext(0, Qual_opContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_unary_qualop; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_unary_qualop) { - listener.enterA_expr_unary_qualop(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_unary_qualop) { - listener.exitA_expr_unary_qualop(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_unary_qualop) { - return visitor.visitA_expr_unary_qualop(this); - } else { - return visitor.visitChildren(this); - } +export class DistinctFromContext extends PredicateContext { + public _right?: ValueExpressionContext; + public constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + super.copyFrom(ctx); } -} - - -export class A_expr_addContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_IS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_IS, 0)!; } - public a_expr_mul(): A_expr_mulContext[]; - public a_expr_mul(i: number): A_expr_mulContext | null; - public a_expr_mul(i?: number): A_expr_mulContext[] | A_expr_mulContext | null { - if (i === undefined) { - return this.getRuleContexts(A_expr_mulContext); - } - - return this.getRuleContext(i, A_expr_mulContext); + public KW_DISTINCT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DISTINCT, 0)!; } - public MINUS(): antlr.TerminalNode[]; - public MINUS(i: number): antlr.TerminalNode | null; - public MINUS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.MINUS); - } else { - return this.getToken(PostgreSqlParser.MINUS, i); - } + public KW_FROM(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_FROM, 0)!; } - public PLUS(): antlr.TerminalNode[]; - public PLUS(i: number): antlr.TerminalNode | null; - public PLUS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.PLUS); - } else { - return this.getToken(PostgreSqlParser.PLUS, i); - } + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_add; + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_add) { - listener.enterA_expr_add(this); + if(listener.enterDistinctFrom) { + listener.enterDistinctFrom(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_add) { - listener.exitA_expr_add(this); + if(listener.exitDistinctFrom) { + listener.exitDistinctFrom(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_add) { - return visitor.visitA_expr_add(this); + if (visitor.visitDistinctFrom) { + return visitor.visitDistinctFrom(this); } else { return visitor.visitChildren(this); } } } - - -export class A_expr_mulContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); +export class InListContext extends PredicateContext { + public constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + super.copyFrom(ctx); + } + public KW_IN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_IN, 0)!; } - public a_expr_caret(): A_expr_caretContext[]; - public a_expr_caret(i: number): A_expr_caretContext | null; - public a_expr_caret(i?: number): A_expr_caretContext[] | A_expr_caretContext | null { + public OPEN_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(A_expr_caretContext); + return this.getRuleContexts(ExpressionContext); } - return this.getRuleContext(i, A_expr_caretContext); + return this.getRuleContext(i, ExpressionContext); } - public STAR(): antlr.TerminalNode[]; - public STAR(i: number): antlr.TerminalNode | null; - public STAR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.STAR); - } else { - return this.getToken(PostgreSqlParser.STAR, i); - } + public CLOSE_PAREN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public SLASH(): antlr.TerminalNode[]; - public SLASH(i: number): antlr.TerminalNode | null; - public SLASH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.SLASH); - } else { - return this.getToken(PostgreSqlParser.SLASH, i); - } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } - public PERCENT(): antlr.TerminalNode[]; - public PERCENT(i: number): antlr.TerminalNode | null; - public PERCENT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSqlParser.PERCENT); + return this.getTokens(PostgreSqlParser.COMMA); } else { - return this.getToken(PostgreSqlParser.PERCENT, i); + return this.getToken(PostgreSqlParser.COMMA, i); } } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_mul; - } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_mul) { - listener.enterA_expr_mul(this); + if(listener.enterInList) { + listener.enterInList(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_mul) { - listener.exitA_expr_mul(this); + if(listener.exitInList) { + listener.exitInList(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_mul) { - return visitor.visitA_expr_mul(this); + if (visitor.visitInList) { + return visitor.visitInList(this); } else { return visitor.visitChildren(this); } } } - - -export class A_expr_caretContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public a_expr_unary_sign(): A_expr_unary_signContext { - return this.getRuleContext(0, A_expr_unary_signContext)!; +export class NullPredicateContext extends PredicateContext { + public constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + super.copyFrom(ctx); } - public CARET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CARET, 0); + public KW_IS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_IS, 0)!; } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public KW_NULL(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_NULL, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_caret; + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_caret) { - listener.enterA_expr_caret(this); + if(listener.enterNullPredicate) { + listener.enterNullPredicate(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_caret) { - listener.exitA_expr_caret(this); + if(listener.exitNullPredicate) { + listener.exitNullPredicate(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_caret) { - return visitor.visitA_expr_caret(this); + if (visitor.visitNullPredicate) { + return visitor.visitNullPredicate(this); } else { return visitor.visitChildren(this); } } } - - -export class A_expr_unary_signContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); +export class BetweenContext extends PredicateContext { + public _lower?: ValueExpressionContext; + public _upper?: ValueExpressionContext; + public constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + super.copyFrom(ctx); } - public a_expr_at_time_zone(): A_expr_at_time_zoneContext { - return this.getRuleContext(0, A_expr_at_time_zoneContext)!; + public KW_BETWEEN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_BETWEEN, 0)!; } - public MINUS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.MINUS, 0); + public KW_AND(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_AND, 0)!; } - public PLUS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.PLUS, 0); + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext | null; + public valueExpression(i?: number): ValueExpressionContext[] | ValueExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ValueExpressionContext); + } + + return this.getRuleContext(i, ValueExpressionContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_unary_sign; + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_unary_sign) { - listener.enterA_expr_unary_sign(this); + if(listener.enterBetween) { + listener.enterBetween(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_unary_sign) { - listener.exitA_expr_unary_sign(this); + if(listener.exitBetween) { + listener.exitBetween(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_unary_sign) { - return visitor.visitA_expr_unary_sign(this); + if (visitor.visitBetween) { + return visitor.visitBetween(this); } else { return visitor.visitChildren(this); } } } - - -export class A_expr_at_time_zoneContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); +export class QuantifiedComparisonContext extends PredicateContext { + public constructor(ctx: PredicateContext) { + super(ctx.parent, ctx.invokingState, ctx.value); + super.copyFrom(ctx); } - public a_expr_collate(): A_expr_collateContext { - return this.getRuleContext(0, A_expr_collateContext)!; + public comparisonOperator(): ComparisonOperatorContext { + return this.getRuleContext(0, ComparisonOperatorContext)!; } - public KW_AT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AT, 0); + public subquery_Op(): Subquery_OpContext { + return this.getRuleContext(0, Subquery_OpContext)!; } - public KW_TIME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TIME, 0); + public sub_type(): Sub_typeContext { + return this.getRuleContext(0, Sub_typeContext)!; } - public KW_ZONE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ZONE, 0); + public select_with_parens(): Select_with_parensContext | null { + return this.getRuleContext(0, Select_with_parensContext); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_at_time_zone; + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_at_time_zone) { - listener.enterA_expr_at_time_zone(this); + if(listener.enterQuantifiedComparison) { + listener.enterQuantifiedComparison(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_at_time_zone) { - listener.exitA_expr_at_time_zone(this); + if(listener.exitQuantifiedComparison) { + listener.exitQuantifiedComparison(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_at_time_zone) { - return visitor.visitA_expr_at_time_zone(this); + if (visitor.visitQuantifiedComparison) { + return visitor.visitQuantifiedComparison(this); } else { return visitor.visitChildren(this); } @@ -102925,117 +78878,96 @@ export class A_expr_at_time_zoneContext extends antlr.ParserRuleContext { } -export class A_expr_collateContext extends antlr.ParserRuleContext { +export class ValueExpressionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr_typecast(): A_expr_typecastContext { - return this.getRuleContext(0, A_expr_typecastContext)!; + public override get ruleIndex(): number { + return PostgreSqlParser.RULE_valueExpression; } - public KW_COLLATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLLATE, 0); + public override copyFrom(ctx: ValueExpressionContext): void { + super.copyFrom(ctx); } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); +} +export class ValueExpressionDefaultContext extends ValueExpressionContext { + public constructor(ctx: ValueExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_collate; + public primaryExpression(): PrimaryExpressionContext { + return this.getRuleContext(0, PrimaryExpressionContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_collate) { - listener.enterA_expr_collate(this); + if(listener.enterValueExpressionDefault) { + listener.enterValueExpressionDefault(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_collate) { - listener.exitA_expr_collate(this); + if(listener.exitValueExpressionDefault) { + listener.exitValueExpressionDefault(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_collate) { - return visitor.visitA_expr_collate(this); + if (visitor.visitValueExpressionDefault) { + return visitor.visitValueExpressionDefault(this); } else { return visitor.visitChildren(this); } } } - - -export class A_expr_typecastContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public c_expr(): C_exprContext { - return this.getRuleContext(0, C_exprContext)!; +export class ConcatenationContext extends ValueExpressionContext { + public _left?: ValueExpressionContext; + public _right?: ValueExpressionContext; + public constructor(ctx: ValueExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public TYPECAST(): antlr.TerminalNode[]; - public TYPECAST(i: number): antlr.TerminalNode | null; - public TYPECAST(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.TYPECAST); - } else { - return this.getToken(PostgreSqlParser.TYPECAST, i); - } + public CARET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.CARET, 0)!; } - public typename(): TypenameContext[]; - public typename(i: number): TypenameContext | null; - public typename(i?: number): TypenameContext[] | TypenameContext | null { + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext | null; + public valueExpression(i?: number): ValueExpressionContext[] | ValueExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(TypenameContext); + return this.getRuleContexts(ValueExpressionContext); } - return this.getRuleContext(i, TypenameContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_a_expr_typecast; + return this.getRuleContext(i, ValueExpressionContext); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterA_expr_typecast) { - listener.enterA_expr_typecast(this); + if(listener.enterConcatenation) { + listener.enterConcatenation(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitA_expr_typecast) { - listener.exitA_expr_typecast(this); + if(listener.exitConcatenation) { + listener.exitConcatenation(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitA_expr_typecast) { - return visitor.visitA_expr_typecast(this); + if (visitor.visitConcatenation) { + return visitor.visitConcatenation(this); } else { return visitor.visitChildren(this); } } } - - -export class B_exprContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public c_expr(): C_exprContext | null { - return this.getRuleContext(0, C_exprContext); +export class ArithmeticBinaryContext extends ValueExpressionContext { + public _left?: ValueExpressionContext; + public _operator?: Token | null; + public _right?: ValueExpressionContext; + public constructor(ctx: ValueExpressionContext) { + super(ctx.parent, ctx.invokingState); + super.copyFrom(ctx); } - public b_expr(): B_exprContext[]; - public b_expr(i: number): B_exprContext | null; - public b_expr(i?: number): B_exprContext[] | B_exprContext | null { + public valueExpression(): ValueExpressionContext[]; + public valueExpression(i: number): ValueExpressionContext | null; + public valueExpression(i?: number): ValueExpressionContext[] | ValueExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(B_exprContext); + return this.getRuleContexts(ValueExpressionContext); } - return this.getRuleContext(i, B_exprContext); - } - public PLUS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.PLUS, 0); - } - public MINUS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.MINUS, 0); - } - public qual_op(): Qual_opContext | null { - return this.getRuleContext(0, Qual_opContext); - } - public CARET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CARET, 0); + return this.getRuleContext(i, ValueExpressionContext); } public STAR(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.STAR, 0); @@ -103046,158 +78978,120 @@ export class B_exprContext extends antlr.ParserRuleContext { public PERCENT(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.PERCENT, 0); } - public LT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.LT, 0); - } - public GT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.GT, 0); - } - public EQUAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.EQUAL, 0); - } - public LESS_EQUALS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.LESS_EQUALS, 0); - } - public GREATER_EQUALS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.GREATER_EQUALS, 0); - } - public NOT_EQUALS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.NOT_EQUALS, 0); - } - public TYPECAST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.TYPECAST, 0); - } - public typename(): TypenameContext | null { - return this.getRuleContext(0, TypenameContext); - } - public KW_IS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IS, 0); - } - public KW_DISTINCT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DISTINCT, 0); - } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public KW_OF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OF, 0); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public type_list(): Type_listContext | null { - return this.getRuleContext(0, Type_listContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public KW_DOCUMENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DOCUMENT, 0); - } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); + public PLUS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.PLUS, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_b_expr; + public MINUS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.MINUS, 0); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterB_expr) { - listener.enterB_expr(this); + if(listener.enterArithmeticBinary) { + listener.enterArithmeticBinary(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitB_expr) { - listener.exitB_expr(this); + if(listener.exitArithmeticBinary) { + listener.exitArithmeticBinary(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitB_expr) { - return visitor.visitB_expr(this); + if (visitor.visitArithmeticBinary) { + return visitor.visitArithmeticBinary(this); } else { return visitor.visitChildren(this); } } } - - -export class C_exprContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_c_expr; - } - public override copyFrom(ctx: C_exprContext): void { - super.copyFrom(ctx); - } -} -export class C_expr_existsContext extends C_exprContext { - public constructor(ctx: C_exprContext) { +export class ArithmeticUnaryContext extends ValueExpressionContext { + public _operator?: Token | null; + public constructor(ctx: ValueExpressionContext) { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); } - public KW_EXISTS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXISTS, 0)!; + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext)!; } - public select_with_parens(): Select_with_parensContext { - return this.getRuleContext(0, Select_with_parensContext)!; + public MINUS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.MINUS, 0); + } + public PLUS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.PLUS, 0); } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterC_expr_exists) { - listener.enterC_expr_exists(this); + if(listener.enterArithmeticUnary) { + listener.enterArithmeticUnary(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitC_expr_exists) { - listener.exitC_expr_exists(this); + if(listener.exitArithmeticUnary) { + listener.exitArithmeticUnary(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitC_expr_exists) { - return visitor.visitC_expr_exists(this); + if (visitor.visitArithmeticUnary) { + return visitor.visitArithmeticUnary(this); } else { return visitor.visitChildren(this); } } } -export class C_expr_caseContext extends C_exprContext { - public constructor(ctx: C_exprContext) { +export class AtTimeZoneContext extends ValueExpressionContext { + public constructor(ctx: ValueExpressionContext) { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); } - public case_expr(): Case_exprContext { - return this.getRuleContext(0, Case_exprContext)!; + public valueExpression(): ValueExpressionContext { + return this.getRuleContext(0, ValueExpressionContext)!; + } + public KW_AT(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_AT, 0)!; + } + public KW_TIME(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_TIME, 0)!; + } + public KW_ZONE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ZONE, 0)!; + } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterC_expr_case) { - listener.enterC_expr_case(this); + if(listener.enterAtTimeZone) { + listener.enterAtTimeZone(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitC_expr_case) { - listener.exitC_expr_case(this); + if(listener.exitAtTimeZone) { + listener.exitAtTimeZone(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitC_expr_case) { - return visitor.visitC_expr_case(this); + if (visitor.visitAtTimeZone) { + return visitor.visitAtTimeZone(this); } else { return visitor.visitChildren(this); } } } -export class C_expr_exprContext extends C_exprContext { - public _a_expr_in_parens?: A_exprContext; - public constructor(ctx: C_exprContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); - } - public KW_ARRAY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ARRAY, 0); + + +export class PrimaryExpressionContext extends antlr.ParserRuleContext { + public _a_expr_in_parens?: ExpressionContext; + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); } public select_with_parens(): Select_with_parensContext | null { return this.getRuleContext(0, Select_with_parensContext); } + public KW_EXISTS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXISTS, 0); + } + public KW_UNIQUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNIQUE, 0); + } + public KW_ARRAY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ARRAY, 0); + } public array_expr(): Array_exprContext | null { return this.getRuleContext(0, Array_exprContext); } @@ -103210,26 +79104,89 @@ export class C_expr_exprContext extends C_exprContext { public KW_GROUPING(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_GROUPING, 0); } + public execute_param_clause(): Execute_param_clauseContext | null { + return this.getRuleContext(0, Execute_param_clauseContext); + } + public Integral(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.Integral, 0); + } + public Numeric(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.Numeric, 0); + } + public BinaryStringConstant(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.BinaryStringConstant, 0); + } + public HexadecimalStringConstant(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.HexadecimalStringConstant, 0); + } + public function_name(): Function_nameContext | null { + return this.getRuleContext(0, Function_nameContext); + } + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); + } public OPEN_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public expr_list(): Expr_listContext | null { - return this.getRuleContext(0, Expr_listContext); + public func_arg_list(): Func_arg_listContext | null { + return this.getRuleContext(0, Func_arg_listContext); } public CLOSE_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public KW_UNIQUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNIQUE, 0); + public sort_clause(): Sort_clauseContext | null { + return this.getRuleContext(0, Sort_clauseContext); + } + public consttypename(): ConsttypenameContext | null { + return this.getRuleContext(0, ConsttypenameContext); + } + public KW_INTERVAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INTERVAL, 0); + } + public opt_float(): Opt_floatContext | null { + return this.getRuleContext(0, Opt_floatContext); + } + public opt_interval(): Opt_intervalContext | null { + return this.getRuleContext(0, Opt_intervalContext); + } + public KW_TRUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRUE, 0); + } + public KW_FALSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FALSE, 0); + } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULL, 0); + } + public PLSQLVARIABLENAME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.PLSQLVARIABLENAME, 0); + } + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(ExpressionContext); + } + + return this.getRuleContext(i, ExpressionContext); + } + public KW_CASE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CASE, 0); } - public aexprconst(): AexprconstContext | null { - return this.getRuleContext(0, AexprconstContext); + public KW_END(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_END, 0); } - public plsqlvariablename(): PlsqlvariablenameContext | null { - return this.getRuleContext(0, PlsqlvariablenameContext); + public when_clause(): When_clauseContext[]; + public when_clause(i: number): When_clauseContext | null; + public when_clause(i?: number): When_clauseContext[] | When_clauseContext | null { + if (i === undefined) { + return this.getRuleContexts(When_clauseContext); + } + + return this.getRuleContext(i, When_clauseContext); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public KW_ELSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ELSE, 0); } public func_expr(): Func_exprContext | null { return this.getRuleContext(0, Func_exprContext); @@ -103240,8 +79197,11 @@ export class C_expr_exprContext extends C_exprContext { public explicit_row(): Explicit_rowContext | null { return this.getRuleContext(0, Explicit_rowContext); } - public implicit_row(): Implicit_rowContext | null { - return this.getRuleContext(0, Implicit_rowContext); + public COMMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.COMMA, 0); + } + public expr_list(): Expr_listContext | null { + return this.getRuleContext(0, Expr_listContext); } public row(): RowContext[]; public row(i: number): RowContext | null; @@ -103255,52 +79215,73 @@ export class C_expr_exprContext extends C_exprContext { public KW_OVERLAPS(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_OVERLAPS, 0); } - public columnref(): ColumnrefContext | null { - return this.getRuleContext(0, ColumnrefContext); + public qualified_name(): Qualified_nameContext | null { + return this.getRuleContext(0, Qualified_nameContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterC_expr_expr) { - listener.enterC_expr_expr(this); + public primaryExpression(): PrimaryExpressionContext[]; + public primaryExpression(i: number): PrimaryExpressionContext | null; + public primaryExpression(i?: number): PrimaryExpressionContext[] | PrimaryExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(PrimaryExpressionContext); } + + return this.getRuleContext(i, PrimaryExpressionContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitC_expr_expr) { - listener.exitC_expr_expr(this); - } + public PLUS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.PLUS, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitC_expr_expr) { - return visitor.visitC_expr_expr(this); - } else { - return visitor.visitChildren(this); - } + public MINUS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.MINUS, 0); } -} - - -export class PlsqlvariablenameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public qual_op(): Qual_opContext | null { + return this.getRuleContext(0, Qual_opContext); + } + public mathop(): MathopContext | null { + return this.getRuleContext(0, MathopContext); + } + public TYPECAST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.TYPECAST, 0); + } + public typename(): TypenameContext | null { + return this.getRuleContext(0, TypenameContext); + } + public KW_IS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IS, 0); + } + public KW_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DISTINCT, 0); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); + } + public KW_OF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OF, 0); + } + public prep_type_clause(): Prep_type_clauseContext | null { + return this.getRuleContext(0, Prep_type_clauseContext); + } + public KW_DOCUMENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DOCUMENT, 0); } - public PLSQLVARIABLENAME(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.PLSQLVARIABLENAME, 0)!; + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_plsqlvariablename; + return PostgreSqlParser.RULE_primaryExpression; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPlsqlvariablename) { - listener.enterPlsqlvariablename(this); + if(listener.enterPrimaryExpression) { + listener.enterPrimaryExpression(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPlsqlvariablename) { - listener.exitPlsqlvariablename(this); + if(listener.exitPrimaryExpression) { + listener.exitPrimaryExpression(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPlsqlvariablename) { - return visitor.visitPlsqlvariablename(this); + if (visitor.visitPrimaryExpression) { + return visitor.visitPrimaryExpression(this); } else { return visitor.visitChildren(this); } @@ -103342,8 +79323,8 @@ export class Func_applicationContext extends antlr.ParserRuleContext { public COMMA(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.COMMA, 0); } - public opt_sort_clause(): Opt_sort_clauseContext | null { - return this.getRuleContext(0, Opt_sort_clauseContext); + public sort_clause(): Sort_clauseContext | null { + return this.getRuleContext(0, Sort_clauseContext); } public override get ruleIndex(): number { return PostgreSqlParser.RULE_func_application; @@ -103358,31 +79339,67 @@ export class Func_applicationContext extends antlr.ParserRuleContext { listener.exitFunc_application(this); } } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFunc_application) { - return visitor.visitFunc_application(this); - } else { - return visitor.visitChildren(this); - } + public override accept(visitor: PostgreSqlParserVisitor): Result | null { + if (visitor.visitFunc_application) { + return visitor.visitFunc_application(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class Func_exprContext extends antlr.ParserRuleContext { + public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { + super(parent, invokingState); + } + public func_application(): Func_applicationContext | null { + return this.getRuleContext(0, Func_applicationContext); + } + public KW_WITHIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITHIN, 0); + } + public KW_GROUP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GROUP, 0); + } + public OPEN_PAREN(): antlr.TerminalNode[]; + public OPEN_PAREN(i: number): antlr.TerminalNode | null; + public OPEN_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.OPEN_PAREN); + } else { + return this.getToken(PostgreSqlParser.OPEN_PAREN, i); + } + } + public sort_clause(): Sort_clauseContext | null { + return this.getRuleContext(0, Sort_clauseContext); + } + public CLOSE_PAREN(): antlr.TerminalNode[]; + public CLOSE_PAREN(i: number): antlr.TerminalNode | null; + public CLOSE_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.CLOSE_PAREN); + } else { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, i); + } + } + public KW_FILTER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FILTER, 0); } -} - - -export class Func_exprContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_WHERE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WHERE, 0); } - public func_application(): Func_applicationContext | null { - return this.getRuleContext(0, Func_applicationContext); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } - public within_group_clause(): Within_group_clauseContext | null { - return this.getRuleContext(0, Within_group_clauseContext); + public KW_OVER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OVER, 0); } - public filter_clause(): Filter_clauseContext | null { - return this.getRuleContext(0, Filter_clauseContext); + public window_specification(): Window_specificationContext | null { + return this.getRuleContext(0, Window_specificationContext); } - public over_clause(): Over_clauseContext | null { - return this.getRuleContext(0, Over_clauseContext); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } public func_expr_common_subexpr(): Func_expr_common_subexprContext | null { return this.getRuleContext(0, Func_expr_common_subexprContext); @@ -103453,20 +79470,32 @@ export class Func_expr_common_subexprContext extends antlr.ParserRuleContext { public KW_FOR(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_FOR, 0); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public OPEN_PAREN(): antlr.TerminalNode[]; + public OPEN_PAREN(i: number): antlr.TerminalNode | null; + public OPEN_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.OPEN_PAREN); + } else { + return this.getToken(PostgreSqlParser.OPEN_PAREN, i); + } } - public a_expr(): A_exprContext[]; - public a_expr(i: number): A_exprContext | null; - public a_expr(i?: number): A_exprContext[] | A_exprContext | null { + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(A_exprContext); + return this.getRuleContexts(ExpressionContext); } - return this.getRuleContext(i, A_exprContext); + return this.getRuleContext(i, ExpressionContext); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public CLOSE_PAREN(): antlr.TerminalNode[]; + public CLOSE_PAREN(i: number): antlr.TerminalNode | null; + public CLOSE_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.CLOSE_PAREN); + } else { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, i); + } } public KW_CURRENT_DATE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_CURRENT_DATE, 0); @@ -103474,9 +79503,6 @@ export class Func_expr_common_subexprContext extends antlr.ParserRuleContext { public KW_CURRENT_TIME(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_CURRENT_TIME, 0); } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); - } public KW_CURRENT_TIMESTAMP(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_CURRENT_TIMESTAMP, 0); } @@ -103486,6 +79512,9 @@ export class Func_expr_common_subexprContext extends antlr.ParserRuleContext { public KW_LOCALTIMESTAMP(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_LOCALTIMESTAMP, 0); } + public opt_float(): Opt_floatContext | null { + return this.getRuleContext(0, Opt_floatContext); + } public KW_CURRENT_ROLE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_CURRENT_ROLE, 0); } @@ -103504,26 +79533,38 @@ export class Func_expr_common_subexprContext extends antlr.ParserRuleContext { public KW_CURRENT_SCHEMA(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_CURRENT_SCHEMA, 0); } - public KW_CAST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CAST, 0); - } public KW_AS(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_AS, 0); } public typename(): TypenameContext | null { return this.getRuleContext(0, TypenameContext); } + public KW_CAST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CAST, 0); + } + public KW_TREAT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TREAT, 0); + } public KW_EXTRACT(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_EXTRACT, 0); } - public extract_list(): Extract_listContext | null { - return this.getRuleContext(0, Extract_listContext); + public extract_arg(): Extract_argContext | null { + return this.getRuleContext(0, Extract_argContext); + } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); } public KW_NORMALIZE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_NORMALIZE, 0); } - public COMMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.COMMA, 0); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public unicode_normal_form(): Unicode_normal_formContext | null { return this.getRuleContext(0, Unicode_normal_formContext); @@ -103531,14 +79572,23 @@ export class Func_expr_common_subexprContext extends antlr.ParserRuleContext { public KW_OVERLAY(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_OVERLAY, 0); } - public overlay_list(): Overlay_listContext | null { - return this.getRuleContext(0, Overlay_listContext); + public KW_PLACING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PLACING, 0); } public KW_POSITION(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_POSITION, 0); } - public position_list(): Position_listContext | null { - return this.getRuleContext(0, Position_listContext); + public primaryExpression(): PrimaryExpressionContext[]; + public primaryExpression(i: number): PrimaryExpressionContext | null; + public primaryExpression(i?: number): PrimaryExpressionContext[] | PrimaryExpressionContext | null { + if (i === undefined) { + return this.getRuleContexts(PrimaryExpressionContext); + } + + return this.getRuleContext(i, PrimaryExpressionContext); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); } public KW_SUBSTRING(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_SUBSTRING, 0); @@ -103546,14 +79596,11 @@ export class Func_expr_common_subexprContext extends antlr.ParserRuleContext { public substr_list(): Substr_listContext | null { return this.getRuleContext(0, Substr_listContext); } - public KW_TREAT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TREAT, 0); - } public KW_TRIM(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_TRIM, 0); } - public trim_list(): Trim_listContext | null { - return this.getRuleContext(0, Trim_listContext); + public expr_list(): Expr_listContext | null { + return this.getRuleContext(0, Expr_listContext); } public KW_BOTH(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_BOTH, 0); @@ -103567,12 +79614,12 @@ export class Func_expr_common_subexprContext extends antlr.ParserRuleContext { public KW_NULLIF(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_NULLIF, 0); } + public execute_param_clause(): Execute_param_clauseContext | null { + return this.getRuleContext(0, Execute_param_clauseContext); + } public KW_COALESCE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_COALESCE, 0); } - public expr_list(): Expr_listContext | null { - return this.getRuleContext(0, Expr_listContext); - } public KW_GREATEST(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_GREATEST, 0); } @@ -103591,32 +79638,35 @@ export class Func_expr_common_subexprContext extends antlr.ParserRuleContext { public collabel(): CollabelContext | null { return this.getRuleContext(0, CollabelContext); } - public xml_attributes(): Xml_attributesContext | null { - return this.getRuleContext(0, Xml_attributesContext); + public KW_XMLATTRIBUTES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLATTRIBUTES, 0); + } + public xml_attribute_list(): Xml_attribute_listContext | null { + return this.getRuleContext(0, Xml_attribute_listContext); } public KW_XMLEXISTS(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_XMLEXISTS, 0); } - public c_expr(): C_exprContext | null { - return this.getRuleContext(0, C_exprContext); - } public xmlexists_argument(): Xmlexists_argumentContext | null { return this.getRuleContext(0, Xmlexists_argumentContext); } public KW_XMLFOREST(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_XMLFOREST, 0); } - public xml_attribute_list(): Xml_attribute_listContext | null { - return this.getRuleContext(0, Xml_attribute_listContext); - } public KW_XMLPARSE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_XMLPARSE, 0); } public document_or_content(): Document_or_contentContext | null { return this.getRuleContext(0, Document_or_contentContext); } - public xml_whitespace_option(): Xml_whitespace_optionContext | null { - return this.getRuleContext(0, Xml_whitespace_optionContext); + public KW_WHITESPACE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WHITESPACE, 0); + } + public KW_PRESERVE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRESERVE, 0); + } + public KW_STRIP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STRIP, 0); } public KW_XMLPI(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_XMLPI, 0); @@ -103627,11 +79677,32 @@ export class Func_expr_common_subexprContext extends antlr.ParserRuleContext { public KW_XML(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_XML, 0); } - public xml_root_version(): Xml_root_versionContext | null { - return this.getRuleContext(0, Xml_root_versionContext); + public KW_VERSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VERSION, 0); + } + public KW_STANDALONE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STANDALONE, 0); + } + public KW_NO(): antlr.TerminalNode[]; + public KW_NO(i: number): antlr.TerminalNode | null; + public KW_NO(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_NO); + } else { + return this.getToken(PostgreSqlParser.KW_NO, i); + } } - public opt_xml_root_standalone(): Opt_xml_root_standaloneContext | null { - return this.getRuleContext(0, Opt_xml_root_standaloneContext); + public KW_VALUE(): antlr.TerminalNode[]; + public KW_VALUE(i: number): antlr.TerminalNode | null; + public KW_VALUE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_VALUE); + } else { + return this.getToken(PostgreSqlParser.KW_VALUE, i); + } + } + public KW_YES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_YES, 0); } public KW_XMLSERIALIZE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_XMLSERIALIZE, 0); @@ -103662,126 +79733,6 @@ export class Func_expr_common_subexprContext extends antlr.ParserRuleContext { } -export class Xml_root_versionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_VERSION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_VERSION, 0)!; - } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); - } - public KW_VALUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALUE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_xml_root_version; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterXml_root_version) { - listener.enterXml_root_version(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitXml_root_version) { - listener.exitXml_root_version(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitXml_root_version) { - return visitor.visitXml_root_version(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_xml_root_standaloneContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public COMMA(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.COMMA, 0)!; - } - public KW_STANDALONE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_STANDALONE, 0)!; - } - public KW_YES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_YES, 0); - } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); - } - public KW_VALUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALUE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_xml_root_standalone; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_xml_root_standalone) { - listener.enterOpt_xml_root_standalone(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_xml_root_standalone) { - listener.exitOpt_xml_root_standalone(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_xml_root_standalone) { - return visitor.visitOpt_xml_root_standalone(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Xml_attributesContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_XMLATTRIBUTES(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_XMLATTRIBUTES, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public xml_attribute_list(): Xml_attribute_listContext { - return this.getRuleContext(0, Xml_attribute_listContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_xml_attributes; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterXml_attributes) { - listener.enterXml_attributes(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitXml_attributes) { - listener.exitXml_attributes(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitXml_attributes) { - return visitor.visitXml_attributes(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Xml_attribute_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -103831,8 +79782,8 @@ export class Xml_attribute_elContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; } public KW_AS(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_AS, 0); @@ -103896,42 +79847,6 @@ export class Document_or_contentContext extends antlr.ParserRuleContext { } -export class Xml_whitespace_optionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_PRESERVE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRESERVE, 0); - } - public KW_WHITESPACE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WHITESPACE, 0)!; - } - public KW_STRIP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STRIP, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_xml_whitespace_option; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterXml_whitespace_option) { - listener.enterXml_whitespace_option(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitXml_whitespace_option) { - listener.exitXml_whitespace_option(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitXml_whitespace_option) { - return visitor.visitXml_whitespace_option(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Xmlexists_argumentContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -103939,8 +79854,8 @@ export class Xmlexists_argumentContext extends antlr.ParserRuleContext { public KW_PASSING(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_PASSING, 0)!; } - public c_expr(): C_exprContext { - return this.getRuleContext(0, C_exprContext)!; + public primaryExpression(): PrimaryExpressionContext { + return this.getRuleContext(0, PrimaryExpressionContext)!; } public xml_passing_mech(): Xml_passing_mechContext[]; public xml_passing_mech(i: number): Xml_passing_mechContext | null; @@ -104010,90 +79925,6 @@ export class Xml_passing_mechContext extends antlr.ParserRuleContext { } -export class Within_group_clauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_WITHIN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WITHIN, 0)!; - } - public KW_GROUP(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_GROUP, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public sort_clause(): Sort_clauseContext { - return this.getRuleContext(0, Sort_clauseContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_within_group_clause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterWithin_group_clause) { - listener.enterWithin_group_clause(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitWithin_group_clause) { - listener.exitWithin_group_clause(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitWithin_group_clause) { - return visitor.visitWithin_group_clause(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Filter_clauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_FILTER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FILTER, 0)!; - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public KW_WHERE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WHERE, 0)!; - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_filter_clause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFilter_clause) { - listener.enterFilter_clause(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFilter_clause) { - listener.exitFilter_clause(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFilter_clause) { - return visitor.visitFilter_clause(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Window_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -104101,36 +79932,6 @@ export class Window_clauseContext extends antlr.ParserRuleContext { public KW_WINDOW(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_WINDOW, 0)!; } - public window_definition_list(): Window_definition_listContext { - return this.getRuleContext(0, Window_definition_listContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_window_clause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterWindow_clause) { - listener.enterWindow_clause(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitWindow_clause) { - listener.exitWindow_clause(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitWindow_clause) { - return visitor.visitWindow_clause(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Window_definition_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } public window_definition(): Window_definitionContext[]; public window_definition(i: number): Window_definitionContext | null; public window_definition(i?: number): Window_definitionContext[] | Window_definitionContext | null { @@ -104150,21 +79951,21 @@ export class Window_definition_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_window_definition_list; + return PostgreSqlParser.RULE_window_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterWindow_definition_list) { - listener.enterWindow_definition_list(this); + if(listener.enterWindow_clause) { + listener.enterWindow_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitWindow_definition_list) { - listener.exitWindow_definition_list(this); + if(listener.exitWindow_clause) { + listener.exitWindow_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitWindow_definition_list) { - return visitor.visitWindow_definition_list(this); + if (visitor.visitWindow_clause) { + return visitor.visitWindow_clause(this); } else { return visitor.visitChildren(this); } @@ -104254,14 +80055,20 @@ export class Window_specificationContext extends antlr.ParserRuleContext { public CLOSE_PAREN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; } - public opt_existing_window_name(): Opt_existing_window_nameContext | null { - return this.getRuleContext(0, Opt_existing_window_nameContext); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); + } + public KW_PARTITION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARTITION, 0); + } + public KW_BY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BY, 0); } - public opt_partition_clause(): Opt_partition_clauseContext | null { - return this.getRuleContext(0, Opt_partition_clauseContext); + public expr_list(): Expr_listContext | null { + return this.getRuleContext(0, Expr_listContext); } - public opt_sort_clause(): Opt_sort_clauseContext | null { - return this.getRuleContext(0, Opt_sort_clauseContext); + public sort_clause(): Sort_clauseContext | null { + return this.getRuleContext(0, Sort_clauseContext); } public opt_frame_clause(): Opt_frame_clauseContext | null { return this.getRuleContext(0, Opt_frame_clauseContext); @@ -104289,72 +80096,6 @@ export class Window_specificationContext extends antlr.ParserRuleContext { } -export class Opt_existing_window_nameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_existing_window_name; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_existing_window_name) { - listener.enterOpt_existing_window_name(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_existing_window_name) { - listener.exitOpt_existing_window_name(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_existing_window_name) { - return visitor.visitOpt_existing_window_name(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_partition_clauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_PARTITION(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PARTITION, 0)!; - } - public KW_BY(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BY, 0)!; - } - public expr_list(): Expr_listContext { - return this.getRuleContext(0, Expr_listContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_partition_clause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_partition_clause) { - listener.enterOpt_partition_clause(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_partition_clause) { - listener.exitOpt_partition_clause(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_partition_clause) { - return visitor.visitOpt_partition_clause(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Opt_frame_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -104362,45 +80103,12 @@ export class Opt_frame_clauseContext extends antlr.ParserRuleContext { public KW_RANGE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_RANGE, 0); } - public frame_extent(): Frame_extentContext { - return this.getRuleContext(0, Frame_extentContext)!; - } - public opt_window_exclusion_clause(): Opt_window_exclusion_clauseContext | null { - return this.getRuleContext(0, Opt_window_exclusion_clauseContext); - } public KW_ROWS(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_ROWS, 0); } public KW_GROUPS(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_GROUPS, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_frame_clause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_frame_clause) { - listener.enterOpt_frame_clause(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_frame_clause) { - listener.exitOpt_frame_clause(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_frame_clause) { - return visitor.visitOpt_frame_clause(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Frame_extentContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } public frame_bound(): Frame_boundContext[]; public frame_bound(i: number): Frame_boundContext | null; public frame_bound(i?: number): Frame_boundContext[] | Frame_boundContext | null { @@ -104410,28 +80118,49 @@ export class Frame_extentContext extends antlr.ParserRuleContext { return this.getRuleContext(i, Frame_boundContext); } + public KW_EXCLUDE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXCLUDE, 0); + } public KW_BETWEEN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_BETWEEN, 0); } public KW_AND(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_AND, 0); } + public KW_CURRENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT, 0); + } + public KW_ROW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROW, 0); + } + public KW_GROUP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GROUP, 0); + } + public KW_TIES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TIES, 0); + } + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); + } + public KW_OTHERS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OTHERS, 0); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_frame_extent; + return PostgreSqlParser.RULE_opt_frame_clause; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFrame_extent) { - listener.enterFrame_extent(this); + if(listener.enterOpt_frame_clause) { + listener.enterOpt_frame_clause(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFrame_extent) { - listener.exitFrame_extent(this); + if(listener.exitOpt_frame_clause) { + listener.exitOpt_frame_clause(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFrame_extent) { - return visitor.visitFrame_extent(this); + if (visitor.visitOpt_frame_clause) { + return visitor.visitOpt_frame_clause(this); } else { return visitor.visitChildren(this); } @@ -104443,24 +80172,24 @@ export class Frame_boundContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_UNBOUNDED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNBOUNDED, 0); - } public KW_PRECEDING(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_PRECEDING, 0); } public KW_FOLLOWING(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_FOLLOWING, 0); } + public KW_UNBOUNDED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNBOUNDED, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } public KW_CURRENT(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_CURRENT, 0); } public KW_ROW(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_ROW, 0); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } public override get ruleIndex(): number { return PostgreSqlParser.RULE_frame_bound; } @@ -104484,66 +80213,15 @@ export class Frame_boundContext extends antlr.ParserRuleContext { } -export class Opt_window_exclusion_clauseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_EXCLUDE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_EXCLUDE, 0)!; - } - public KW_CURRENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT, 0); - } - public KW_ROW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROW, 0); - } - public KW_GROUP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GROUP, 0); - } - public KW_TIES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TIES, 0); - } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); - } - public KW_OTHERS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OTHERS, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_window_exclusion_clause; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_window_exclusion_clause) { - listener.enterOpt_window_exclusion_clause(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_window_exclusion_clause) { - listener.exitOpt_window_exclusion_clause(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_window_exclusion_clause) { - return visitor.visitOpt_window_exclusion_clause(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class RowContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ROW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROW, 0); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public explicit_row(): Explicit_rowContext | null { + return this.getRuleContext(0, Explicit_rowContext); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } public expr_list(): Expr_listContext | null { return this.getRuleContext(0, Expr_listContext); @@ -104551,8 +80229,11 @@ export class RowContext extends antlr.ParserRuleContext { public COMMA(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.COMMA, 0); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public override get ruleIndex(): number { return PostgreSqlParser.RULE_row; @@ -104616,48 +80297,6 @@ export class Explicit_rowContext extends antlr.ParserRuleContext { } -export class Implicit_rowContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public COMMA(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.COMMA, 0)!; - } - public expr_list(): Expr_listContext { - return this.getRuleContext(0, Expr_listContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_implicit_row; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterImplicit_row) { - listener.enterImplicit_row(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitImplicit_row) { - listener.exitImplicit_row(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitImplicit_row) { - return visitor.visitImplicit_row(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Sub_typeContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -104878,30 +80517,18 @@ export class Subquery_OpContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public all_op(): All_opContext | null { - return this.getRuleContext(0, All_opContext); - } - public KW_OPERATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPERATOR, 0); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public any_operator(): Any_operatorContext | null { - return this.getRuleContext(0, Any_operatorContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public qual_all_op(): Qual_all_opContext | null { + return this.getRuleContext(0, Qual_all_opContext); } public KW_LIKE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_LIKE, 0); } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); - } public KW_ILIKE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_ILIKE, 0); } + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); + } public override get ruleIndex(): number { return PostgreSqlParser.RULE_subquery_Op; } @@ -104929,14 +80556,14 @@ export class Expr_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr(): A_exprContext[]; - public a_expr(i: number): A_exprContext | null; - public a_expr(i?: number): A_exprContext[] | A_exprContext | null { + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(A_exprContext); + return this.getRuleContexts(ExpressionContext); } - return this.getRuleContext(i, A_exprContext); + return this.getRuleContext(i, ExpressionContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -104970,96 +80597,6 @@ export class Expr_listContext extends antlr.ParserRuleContext { } -export class Column_expr_list_noparenContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public column_expr_noparen(): Column_expr_noparenContext[]; - public column_expr_noparen(i: number): Column_expr_noparenContext | null; - public column_expr_noparen(i?: number): Column_expr_noparenContext[] | Column_expr_noparenContext | null { - if (i === undefined) { - return this.getRuleContexts(Column_expr_noparenContext); - } - - return this.getRuleContext(i, Column_expr_noparenContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_column_expr_list_noparen; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterColumn_expr_list_noparen) { - listener.enterColumn_expr_list_noparen(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitColumn_expr_list_noparen) { - listener.exitColumn_expr_list_noparen(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitColumn_expr_list_noparen) { - return visitor.visitColumn_expr_list_noparen(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Column_expr_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public column_expr(): Column_exprContext[]; - public column_expr(i: number): Column_exprContext | null; - public column_expr(i?: number): Column_exprContext[] | Column_exprContext | null { - if (i === undefined) { - return this.getRuleContexts(Column_exprContext); - } - - return this.getRuleContext(i, Column_exprContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_column_expr_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterColumn_expr_list) { - listener.enterColumn_expr_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitColumn_expr_list) { - listener.exitColumn_expr_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitColumn_expr_list) { - return visitor.visitColumn_expr_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Column_exprContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -105067,8 +80604,8 @@ export class Column_exprContext extends antlr.ParserRuleContext { public OPEN_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } public CLOSE_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); @@ -105103,8 +80640,8 @@ export class Column_expr_noparenContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } public column_name(): Column_nameContext | null { return this.getRuleContext(0, Column_nameContext); @@ -105181,11 +80718,11 @@ export class Func_arg_exprContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; } - public param_name(): Param_nameContext | null { - return this.getRuleContext(0, Param_nameContext); + public type_function_name(): Type_function_nameContext | null { + return this.getRuleContext(0, Type_function_nameContext); } public COLON_EQUALS(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.COLON_EQUALS, 0); @@ -105216,51 +80753,6 @@ export class Func_arg_exprContext extends antlr.ParserRuleContext { } -export class Type_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public typename(): TypenameContext[]; - public typename(i: number): TypenameContext | null; - public typename(i?: number): TypenameContext[] | TypenameContext | null { - if (i === undefined) { - return this.getRuleContexts(TypenameContext); - } - - return this.getRuleContext(i, TypenameContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_type_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterType_list) { - listener.enterType_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitType_list) { - listener.exitType_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitType_list) { - return visitor.visitType_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Array_exprContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -105274,36 +80766,6 @@ export class Array_exprContext extends antlr.ParserRuleContext { public expr_list(): Expr_listContext | null { return this.getRuleContext(0, Expr_listContext); } - public array_expr_list(): Array_expr_listContext | null { - return this.getRuleContext(0, Array_expr_listContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_array_expr; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterArray_expr) { - listener.enterArray_expr(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitArray_expr) { - listener.exitArray_expr(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitArray_expr) { - return visitor.visitArray_expr(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Array_expr_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } public array_expr(): Array_exprContext[]; public array_expr(i: number): Array_exprContext | null; public array_expr(i?: number): Array_exprContext[] | Array_exprContext | null { @@ -105323,57 +80785,21 @@ export class Array_expr_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_array_expr_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterArray_expr_list) { - listener.enterArray_expr_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitArray_expr_list) { - listener.exitArray_expr_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitArray_expr_list) { - return visitor.visitArray_expr_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Extract_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public extract_arg(): Extract_argContext { - return this.getRuleContext(0, Extract_argContext)!; - } - public KW_FROM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FROM, 0)!; - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_extract_list; + return PostgreSqlParser.RULE_array_expr; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExtract_list) { - listener.enterExtract_list(this); + if(listener.enterArray_expr) { + listener.enterArray_expr(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExtract_list) { - listener.exitExtract_list(this); + if(listener.exitArray_expr) { + listener.exitArray_expr(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExtract_list) { - return visitor.visitExtract_list(this); + if (visitor.visitArray_expr) { + return visitor.visitArray_expr(this); } else { return visitor.visitChildren(this); } @@ -105471,102 +80897,18 @@ export class Unicode_normal_formContext extends antlr.ParserRuleContext { } -export class Overlay_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public a_expr(): A_exprContext[]; - public a_expr(i: number): A_exprContext | null; - public a_expr(i?: number): A_exprContext[] | A_exprContext | null { - if (i === undefined) { - return this.getRuleContexts(A_exprContext); - } - - return this.getRuleContext(i, A_exprContext); - } - public KW_PLACING(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_PLACING, 0)!; - } - public KW_FROM(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FROM, 0)!; - } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_overlay_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOverlay_list) { - listener.enterOverlay_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOverlay_list) { - listener.exitOverlay_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOverlay_list) { - return visitor.visitOverlay_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Position_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public b_expr(): B_exprContext[]; - public b_expr(i: number): B_exprContext | null; - public b_expr(i?: number): B_exprContext[] | B_exprContext | null { - if (i === undefined) { - return this.getRuleContexts(B_exprContext); - } - - return this.getRuleContext(i, B_exprContext); - } - public KW_IN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_IN, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_position_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPosition_list) { - listener.enterPosition_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPosition_list) { - listener.exitPosition_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPosition_list) { - return visitor.visitPosition_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Substr_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public a_expr(): A_exprContext[]; - public a_expr(i: number): A_exprContext | null; - public a_expr(i?: number): A_exprContext[] | A_exprContext | null { + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(A_exprContext); + return this.getRuleContexts(ExpressionContext); } - return this.getRuleContext(i, A_exprContext); + return this.getRuleContext(i, ExpressionContext); } public KW_FROM(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_FROM, 0); @@ -105606,191 +80948,6 @@ export class Substr_listContext extends antlr.ParserRuleContext { } -export class Trim_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public expr_list(): Expr_listContext { - return this.getRuleContext(0, Expr_listContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_trim_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterTrim_list) { - listener.enterTrim_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitTrim_list) { - listener.exitTrim_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitTrim_list) { - return visitor.visitTrim_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class In_exprContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_in_expr; - } - public override copyFrom(ctx: In_exprContext): void { - super.copyFrom(ctx); - } -} -export class In_expr_listContext extends In_exprContext { - public constructor(ctx: In_exprContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; - } - public expr_list(): Expr_listContext { - return this.getRuleContext(0, Expr_listContext)!; - } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIn_expr_list) { - listener.enterIn_expr_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIn_expr_list) { - listener.exitIn_expr_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIn_expr_list) { - return visitor.visitIn_expr_list(this); - } else { - return visitor.visitChildren(this); - } - } -} -export class In_expr_selectContext extends In_exprContext { - public constructor(ctx: In_exprContext) { - super(ctx.parent, ctx.invokingState); - super.copyFrom(ctx); - } - public select_with_parens(): Select_with_parensContext { - return this.getRuleContext(0, Select_with_parensContext)!; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIn_expr_select) { - listener.enterIn_expr_select(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIn_expr_select) { - listener.exitIn_expr_select(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIn_expr_select) { - return visitor.visitIn_expr_select(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Case_exprContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_CASE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CASE, 0)!; - } - public when_clause_list(): When_clause_listContext { - return this.getRuleContext(0, When_clause_listContext)!; - } - public KW_END(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_END, 0)!; - } - public case_arg(): Case_argContext | null { - return this.getRuleContext(0, Case_argContext); - } - public case_default(): Case_defaultContext | null { - return this.getRuleContext(0, Case_defaultContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_case_expr; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCase_expr) { - listener.enterCase_expr(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCase_expr) { - listener.exitCase_expr(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCase_expr) { - return visitor.visitCase_expr(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class When_clause_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public when_clause(): When_clauseContext[]; - public when_clause(i: number): When_clauseContext | null; - public when_clause(i?: number): When_clauseContext[] | When_clauseContext | null { - if (i === undefined) { - return this.getRuleContexts(When_clauseContext); - } - - return this.getRuleContext(i, When_clauseContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_when_clause_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterWhen_clause_list) { - listener.enterWhen_clause_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitWhen_clause_list) { - listener.exitWhen_clause_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitWhen_clause_list) { - return visitor.visitWhen_clause_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class When_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -105798,14 +80955,14 @@ export class When_clauseContext extends antlr.ParserRuleContext { public KW_WHEN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_WHEN, 0)!; } - public a_expr(): A_exprContext[]; - public a_expr(i: number): A_exprContext | null; - public a_expr(i?: number): A_exprContext[] | A_exprContext | null { + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(A_exprContext); + return this.getRuleContexts(ExpressionContext); } - return this.getRuleContext(i, A_exprContext); + return this.getRuleContext(i, ExpressionContext); } public KW_THEN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_THEN, 0)!; @@ -105833,102 +80990,6 @@ export class When_clauseContext extends antlr.ParserRuleContext { } -export class Case_defaultContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ELSE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ELSE, 0)!; - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_case_default; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCase_default) { - listener.enterCase_default(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCase_default) { - listener.exitCase_default(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCase_default) { - return visitor.visitCase_default(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Case_argContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_case_arg; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCase_arg) { - listener.enterCase_arg(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCase_arg) { - listener.exitCase_arg(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCase_arg) { - return visitor.visitCase_arg(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class ColumnrefContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public indirection(): IndirectionContext | null { - return this.getRuleContext(0, IndirectionContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_columnref; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterColumnref) { - listener.enterColumnref(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitColumnref) { - listener.exitColumnref(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitColumnref) { - return visitor.visitColumnref(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Indirection_elContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -105936,8 +80997,8 @@ export class Indirection_elContext extends antlr.ParserRuleContext { public DOT(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.DOT, 0); } - public attr_name(): Attr_nameContext | null { - return this.getRuleContext(0, Attr_nameContext); + public collabel(): CollabelContext | null { + return this.getRuleContext(0, CollabelContext); } public STAR(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.STAR, 0); @@ -105948,20 +81009,17 @@ export class Indirection_elContext extends antlr.ParserRuleContext { public CLOSE_BRACKET(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.CLOSE_BRACKET, 0); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } - public COLON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.COLON, 0); - } - public opt_slice_bound(): Opt_slice_boundContext[]; - public opt_slice_bound(i: number): Opt_slice_boundContext | null; - public opt_slice_bound(i?: number): Opt_slice_boundContext[] | Opt_slice_boundContext | null { + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(Opt_slice_boundContext); + return this.getRuleContexts(ExpressionContext); } - return this.getRuleContext(i, Opt_slice_boundContext); + return this.getRuleContext(i, ExpressionContext); + } + public COLON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.COLON, 0); } public override get ruleIndex(): number { return PostgreSqlParser.RULE_indirection_el; @@ -105986,36 +81044,6 @@ export class Indirection_elContext extends antlr.ParserRuleContext { } -export class Opt_slice_boundContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_slice_bound; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_slice_bound) { - listener.enterOpt_slice_bound(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_slice_bound) { - listener.exitOpt_slice_bound(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_slice_bound) { - return visitor.visitOpt_slice_bound(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class IndirectionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -106088,36 +81116,6 @@ export class Opt_indirectionContext extends antlr.ParserRuleContext { } -export class Opt_target_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public target_list(): Target_listContext { - return this.getRuleContext(0, Target_listContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_target_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_target_list) { - listener.enterOpt_target_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_target_list) { - listener.exitOpt_target_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_target_list) { - return visitor.visitOpt_target_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Target_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -106417,51 +81415,6 @@ export class Database_nameListContext extends antlr.ParserRuleContext { } -export class Procedure_name_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public procedure_name(): Procedure_nameContext[]; - public procedure_name(i: number): Procedure_nameContext | null; - public procedure_name(i?: number): Procedure_nameContext[] | Procedure_nameContext | null { - if (i === undefined) { - return this.getRuleContexts(Procedure_nameContext); - } - - return this.getRuleContext(i, Procedure_nameContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_procedure_name_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterProcedure_name_list) { - listener.enterProcedure_name_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitProcedure_name_list) { - listener.exitProcedure_name_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitProcedure_name_list) { - return visitor.visitProcedure_name_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Tablespace_name_createContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -106478,11 +81431,8 @@ export class TablespaceNameCreateContext extends Tablespace_name_createContext { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public indirection(): IndirectionContext | null { - return this.getRuleContext(0, IndirectionContext); + public qualified_name(): Qualified_nameContext { + return this.getRuleContext(0, Qualified_nameContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { if(listener.enterTablespaceNameCreate) { @@ -106520,11 +81470,8 @@ export class TablespaceNameContext extends Tablespace_nameContext { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public indirection(): IndirectionContext | null { - return this.getRuleContext(0, IndirectionContext); + public qualified_name(): Qualified_nameContext { + return this.getRuleContext(0, Qualified_nameContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { if(listener.enterTablespaceName) { @@ -106562,11 +81509,8 @@ export class TableNameCreateContext extends Table_name_createContext { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public indirection(): IndirectionContext | null { - return this.getRuleContext(0, IndirectionContext); + public qualified_name(): Qualified_nameContext { + return this.getRuleContext(0, Qualified_nameContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { if(listener.enterTableNameCreate) { @@ -106604,11 +81548,8 @@ export class TableNameContext extends Table_nameContext { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public indirection(): IndirectionContext | null { - return this.getRuleContext(0, IndirectionContext); + public qualified_name(): Qualified_nameContext { + return this.getRuleContext(0, Qualified_nameContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { if(listener.enterTableName) { @@ -106646,11 +81587,8 @@ export class ViewNameCreateContext extends View_name_createContext { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public indirection(): IndirectionContext | null { - return this.getRuleContext(0, IndirectionContext); + public qualified_name(): Qualified_nameContext { + return this.getRuleContext(0, Qualified_nameContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { if(listener.enterViewNameCreate) { @@ -106688,11 +81626,8 @@ export class ViewNameContext extends View_nameContext { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public attrs(): AttrsContext | null { - return this.getRuleContext(0, AttrsContext); + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { if(listener.enterViewName) { @@ -106796,14 +81731,14 @@ export class Name_listContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public name(): NameContext[]; - public name(i: number): NameContext | null; - public name(i?: number): NameContext[] | NameContext | null { + public colid(): ColidContext[]; + public colid(i: number): ColidContext | null; + public colid(i?: number): ColidContext[] | ColidContext | null { if (i === undefined) { - return this.getRuleContexts(NameContext); + return this.getRuleContexts(ColidContext); } - return this.getRuleContext(i, NameContext); + return this.getRuleContext(i, ColidContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -106853,12 +81788,9 @@ export class DatabaseNameCreateContext extends Database_name_createContext { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public attrs(): AttrsContext | null { - return this.getRuleContext(0, AttrsContext); - } + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; + } public override enterRule(listener: PostgreSqlParserListener): void { if(listener.enterDatabaseNameCreate) { listener.enterDatabaseNameCreate(this); @@ -106895,11 +81827,8 @@ export class DatabaseNameContext extends Database_nameContext { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public attrs(): AttrsContext | null { - return this.getRuleContext(0, AttrsContext); + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { if(listener.enterDatabaseName) { @@ -106937,11 +81866,8 @@ export class SchemaNameContext extends Schema_nameContext { super(ctx.parent, ctx.invokingState); super.copyFrom(ctx); } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public attrs(): AttrsContext | null { - return this.getRuleContext(0, AttrsContext); + public any_name(): Any_nameContext { + return this.getRuleContext(0, Any_nameContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { if(listener.enterSchemaName) { @@ -107173,14 +82099,8 @@ export class ColumnNameContext extends Column_nameContext { public colid(): ColidContext { return this.getRuleContext(0, ColidContext)!; } - public indirection_el(): Indirection_elContext[]; - public indirection_el(i: number): Indirection_elContext | null; - public indirection_el(i?: number): Indirection_elContext[] | Indirection_elContext | null { - if (i === undefined) { - return this.getRuleContexts(Indirection_elContext); - } - - return this.getRuleContext(i, Indirection_elContext); + public opt_indirection(): Opt_indirectionContext { + return this.getRuleContext(0, Opt_indirectionContext)!; } public override enterRule(listener: PostgreSqlParserListener): void { if(listener.enterColumnName) { @@ -107241,96 +82161,6 @@ export class ColumnNameCreateContext extends Column_name_createContext { } -export class NameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_name; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterName) { - listener.enterName(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitName) { - listener.exitName(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitName) { - return visitor.visitName(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Attr_nameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public collabel(): CollabelContext { - return this.getRuleContext(0, CollabelContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_attr_name; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAttr_name) { - listener.enterAttr_name(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAttr_name) { - listener.exitAttr_name(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAttr_name) { - return visitor.visitAttr_name(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class File_nameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public sconst(): SconstContext { - return this.getRuleContext(0, SconstContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_file_name; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFile_name) { - listener.enterFile_name(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFile_name) { - listener.exitFile_name(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFile_name) { - return visitor.visitFile_name(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Function_name_createContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -107421,246 +82251,21 @@ export class FunctionNameContext extends Function_nameContext { } -export class Usual_nameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public type_usual_name(): Type_usual_nameContext | null { - return this.getRuleContext(0, Type_usual_nameContext); - } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); - } - public indirection(): IndirectionContext | null { - return this.getRuleContext(0, IndirectionContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_usual_name; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterUsual_name) { - listener.enterUsual_name(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitUsual_name) { - listener.exitUsual_name(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitUsual_name) { - return visitor.visitUsual_name(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class AexprconstContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); - } - public fconst(): FconstContext | null { - return this.getRuleContext(0, FconstContext); - } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); - } - public bconst(): BconstContext | null { - return this.getRuleContext(0, BconstContext); - } - public xconst(): XconstContext | null { - return this.getRuleContext(0, XconstContext); - } - public function_name(): Function_nameContext | null { - return this.getRuleContext(0, Function_nameContext); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public func_arg_list(): Func_arg_listContext | null { - return this.getRuleContext(0, Func_arg_listContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public opt_sort_clause(): Opt_sort_clauseContext | null { - return this.getRuleContext(0, Opt_sort_clauseContext); - } - public consttypename(): ConsttypenameContext | null { - return this.getRuleContext(0, ConsttypenameContext); - } - public constinterval(): ConstintervalContext | null { - return this.getRuleContext(0, ConstintervalContext); - } - public opt_interval(): Opt_intervalContext | null { - return this.getRuleContext(0, Opt_intervalContext); - } - public KW_TRUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRUE, 0); - } - public KW_FALSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FALSE, 0); - } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_aexprconst; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterAexprconst) { - listener.enterAexprconst(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitAexprconst) { - listener.exitAexprconst(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitAexprconst) { - return visitor.visitAexprconst(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class XconstContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public HexadecimalStringConstant(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.HexadecimalStringConstant, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_xconst; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterXconst) { - listener.enterXconst(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitXconst) { - listener.exitXconst(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitXconst) { - return visitor.visitXconst(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class BconstContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public BinaryStringConstant(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.BinaryStringConstant, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_bconst; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterBconst) { - listener.enterBconst(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitBconst) { - listener.exitBconst(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitBconst) { - return visitor.visitBconst(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class FconstContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public Numeric(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.Numeric, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_fconst; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFconst) { - listener.enterFconst(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFconst) { - listener.exitFconst(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFconst) { - return visitor.visitFconst(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class IconstContext extends antlr.ParserRuleContext { +export class SconstContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public Integral(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.Integral, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_iconst; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIconst) { - listener.enterIconst(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIconst) { - listener.exitIconst(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIconst) { - return visitor.visitIconst(this); - } else { - return visitor.visitChildren(this); + public anysconst(): AnysconstContext[]; + public anysconst(i: number): AnysconstContext | null; + public anysconst(i?: number): AnysconstContext[] | AnysconstContext | null { + if (i === undefined) { + return this.getRuleContexts(AnysconstContext); } - } -} - -export class SconstContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, AnysconstContext); } - public anysconst(): AnysconstContext { - return this.getRuleContext(0, AnysconstContext)!; - } - public opt_uescape(): Opt_uescapeContext | null { - return this.getRuleContext(0, Opt_uescapeContext); + public KW_UESCAPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UESCAPE, 0); } public override get ruleIndex(): number { return PostgreSqlParser.RULE_sconst; @@ -107736,45 +82341,12 @@ export class AnysconstContext extends antlr.ParserRuleContext { } -export class Opt_uescapeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_UESCAPE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_UESCAPE, 0)!; - } - public anysconst(): AnysconstContext { - return this.getRuleContext(0, AnysconstContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_uescape; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_uescape) { - listener.enterOpt_uescape(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_uescape) { - listener.exitOpt_uescape(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_uescape) { - return visitor.visitOpt_uescape(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class SignediconstContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public iconst(): IconstContext { - return this.getRuleContext(0, IconstContext)!; + public Integral(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.Integral, 0)!; } public PLUS(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.PLUS, 0); @@ -107805,66 +82377,6 @@ export class SignediconstContext extends antlr.ParserRuleContext { } -export class GroupnameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public rolespec(): RolespecContext { - return this.getRuleContext(0, RolespecContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_groupname; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGroupname) { - listener.enterGroupname(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGroupname) { - listener.exitGroupname(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGroupname) { - return visitor.visitGroupname(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class RoleidContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public rolespec(): RolespecContext { - return this.getRuleContext(0, RolespecContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_roleid; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterRoleid) { - listener.enterRoleid(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitRoleid) { - listener.exitRoleid(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitRoleid) { - return visitor.visitRoleid(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class RolespecContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -107991,120 +82503,6 @@ export class ColidContext extends antlr.ParserRuleContext { } -export class Index_method_choicesContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public identifier(): IdentifierContext { - return this.getRuleContext(0, IdentifierContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_index_method_choices; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIndex_method_choices) { - listener.enterIndex_method_choices(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIndex_method_choices) { - listener.exitIndex_method_choices(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIndex_method_choices) { - return visitor.visitIndex_method_choices(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Exclude_elementContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public opt_definition(): Opt_definitionContext | null { - return this.getRuleContext(0, Opt_definitionContext); - } - public identifier(): IdentifierContext | null { - return this.getRuleContext(0, IdentifierContext); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public opt_asc_desc(): Opt_asc_descContext | null { - return this.getRuleContext(0, Opt_asc_descContext); - } - public opt_nulls_order(): Opt_nulls_orderContext | null { - return this.getRuleContext(0, Opt_nulls_orderContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_exclude_element; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExclude_element) { - listener.enterExclude_element(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExclude_element) { - listener.exitExclude_element(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExclude_element) { - return visitor.visitExclude_element(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Index_paramentersContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); - } - public reloptions(): ReloptionsContext | null { - return this.getRuleContext(0, ReloptionsContext); - } - public optconstablespace(): OptconstablespaceContext | null { - return this.getRuleContext(0, OptconstablespaceContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_index_paramenters; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIndex_paramenters) { - listener.enterIndex_paramenters(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIndex_paramenters) { - listener.exitIndex_paramenters(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIndex_paramenters) { - return visitor.visitIndex_paramenters(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Type_function_nameContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -108144,78 +82542,6 @@ export class Type_function_nameContext extends antlr.ParserRuleContext { } -export class Type_usual_nameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public identifier(): IdentifierContext | null { - return this.getRuleContext(0, IdentifierContext); - } - public unreserved_keyword(): Unreserved_keywordContext | null { - return this.getRuleContext(0, Unreserved_keywordContext); - } - public plsql_unreserved_keyword(): Plsql_unreserved_keywordContext | null { - return this.getRuleContext(0, Plsql_unreserved_keywordContext); - } - public type_func_name_keyword(): Type_func_name_keywordContext | null { - return this.getRuleContext(0, Type_func_name_keywordContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_type_usual_name; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterType_usual_name) { - listener.enterType_usual_name(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitType_usual_name) { - listener.exitType_usual_name(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitType_usual_name) { - return visitor.visitType_usual_name(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Nonreservedword_columnContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public column_name(): Column_nameContext | null { - return this.getRuleContext(0, Column_nameContext); - } - public type_func_name_keyword(): Type_func_name_keywordContext | null { - return this.getRuleContext(0, Type_func_name_keywordContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_nonreservedword_column; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterNonreservedword_column) { - listener.enterNonreservedword_column(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitNonreservedword_column) { - listener.exitNonreservedword_column(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitNonreservedword_column) { - return visitor.visitNonreservedword_column(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class NonreservedwordContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -108259,21 +82585,12 @@ export class CollabelContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public identifier(): IdentifierContext | null { - return this.getRuleContext(0, IdentifierContext); + public nonreservedword(): NonreservedwordContext | null { + return this.getRuleContext(0, NonreservedwordContext); } public plsql_unreserved_keyword(): Plsql_unreserved_keywordContext | null { return this.getRuleContext(0, Plsql_unreserved_keywordContext); } - public unreserved_keyword(): Unreserved_keywordContext | null { - return this.getRuleContext(0, Unreserved_keywordContext); - } - public col_name_keyword(): Col_name_keywordContext | null { - return this.getRuleContext(0, Col_name_keywordContext); - } - public type_func_name_keyword(): Type_func_name_keywordContext | null { - return this.getRuleContext(0, Type_func_name_keywordContext); - } public reserved_keyword(): Reserved_keywordContext | null { return this.getRuleContext(0, Reserved_keywordContext); } @@ -108307,8 +82624,11 @@ export class IdentifierContext extends antlr.ParserRuleContext { public Identifier(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.Identifier, 0); } - public opt_uescape(): Opt_uescapeContext | null { - return this.getRuleContext(0, Opt_uescapeContext); + public KW_UESCAPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UESCAPE, 0); + } + public anysconst(): AnysconstContext | null { + return this.getRuleContext(0, AnysconstContext); } public sconst(): SconstContext | null { return this.getRuleContext(0, SconstContext); @@ -108319,61 +82639,31 @@ export class IdentifierContext extends antlr.ParserRuleContext { public UnicodeQuotedIdentifier(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.UnicodeQuotedIdentifier, 0); } - public plsqlvariablename(): PlsqlvariablenameContext | null { - return this.getRuleContext(0, PlsqlvariablenameContext); + public PLSQLVARIABLENAME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.PLSQLVARIABLENAME, 0); } - public plsqlidentifier(): PlsqlidentifierContext | null { - return this.getRuleContext(0, PlsqlidentifierContext); + public PLSQLIDENTIFIER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.PLSQLIDENTIFIER, 0); } public plsql_unreserved_keyword(): Plsql_unreserved_keywordContext | null { - return this.getRuleContext(0, Plsql_unreserved_keywordContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_identifier; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterIdentifier) { - listener.enterIdentifier(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitIdentifier) { - listener.exitIdentifier(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitIdentifier) { - return visitor.visitIdentifier(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class PlsqlidentifierContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public PLSQLIDENTIFIER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.PLSQLIDENTIFIER, 0)!; + return this.getRuleContext(0, Plsql_unreserved_keywordContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_plsqlidentifier; + return PostgreSqlParser.RULE_identifier; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPlsqlidentifier) { - listener.enterPlsqlidentifier(this); + if(listener.enterIdentifier) { + listener.enterIdentifier(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPlsqlidentifier) { - listener.exitPlsqlidentifier(this); + if(listener.exitIdentifier) { + listener.exitIdentifier(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPlsqlidentifier) { - return visitor.visitPlsqlidentifier(this); + if (visitor.visitIdentifier) { + return visitor.visitIdentifier(this); } else { return visitor.visitChildren(this); } @@ -108916,922 +83206,394 @@ export class Unreserved_keywordContext extends antlr.ParserRuleContext { public KW_PARSER(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_PARSER, 0); } - public KW_PARTIAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARTIAL, 0); - } - public KW_PARTITION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PARTITION, 0); - } - public KW_PASSING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PASSING, 0); - } - public KW_PASSWORD(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PASSWORD, 0); - } - public KW_PLANS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PLANS, 0); - } - public KW_POLICY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_POLICY, 0); - } - public KW_PRECEDING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRECEDING, 0); - } - public KW_PREPARE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PREPARE, 0); - } - public KW_PREPARED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PREPARED, 0); - } - public KW_PRESERVE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRESERVE, 0); - } - public KW_PRIOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRIOR, 0); - } - public KW_PRIVILEGES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRIVILEGES, 0); - } - public KW_PROCEDURAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURAL, 0); - } - public KW_PROCEDURE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); - } - public KW_PROCEDURES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROCEDURES, 0); - } - public KW_PROGRAM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PROGRAM, 0); - } - public KW_PUBLICATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); - } - public KW_QUOTE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_QUOTE, 0); - } - public KW_RANGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RANGE, 0); - } - public KW_READ(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_READ, 0); - } - public KW_REASSIGN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REASSIGN, 0); - } - public KW_RECHECK(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RECHECK, 0); - } - public KW_RECURSIVE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RECURSIVE, 0); - } - public KW_REF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REF, 0); - } - public KW_REFERENCING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REFERENCING, 0); - } - public KW_REFRESH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REFRESH, 0); - } - public KW_REINDEX(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REINDEX, 0); - } - public KW_RELATIVE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RELATIVE, 0); - } - public KW_RELEASE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RELEASE, 0); - } - public KW_RENAME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RENAME, 0); - } - public KW_REPEATABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REPEATABLE, 0); - } - public KW_REPLACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REPLACE, 0); - } - public KW_REPLICA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REPLICA, 0); - } - public KW_RESET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESET, 0); - } - public KW_RESTART(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESTART, 0); - } - public KW_RESTRICT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RESTRICT, 0); - } - public KW_RETURNS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RETURNS, 0); - } - public KW_REVOKE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REVOKE, 0); - } - public KW_ROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLE, 0); - } - public KW_ROLLBACK(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLLBACK, 0); - } - public KW_ROLLUP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROLLUP, 0); - } - public KW_ROUTINE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); - } - public KW_ROUTINES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROUTINES, 0); - } - public KW_ROWS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROWS, 0); - } - public KW_RULE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RULE, 0); - } - public KW_SAVEPOINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SAVEPOINT, 0); - } - public KW_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); - } - public KW_SCHEMAS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCHEMAS, 0); - } - public KW_SCROLL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCROLL, 0); - } - public KW_SEARCH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEARCH, 0); - } - public KW_SECOND(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SECOND, 0); - } - public KW_SECURITY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SECURITY, 0); - } - public KW_SEQUENCE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); - } - public KW_SEQUENCES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SEQUENCES, 0); - } - public KW_SERIALIZABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SERIALIZABLE, 0); - } - public KW_SERVER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SERVER, 0); - } - public KW_SESSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SESSION, 0); - } - public KW_SET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SET, 0); - } - public KW_SETS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SETS, 0); - } - public KW_SHARE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SHARE, 0); - } - public KW_SHOW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SHOW, 0); - } - public KW_SIMPLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SIMPLE, 0); - } - public KW_SKIP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SKIP, 0); - } - public KW_SKIP_LOCKED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SKIP_LOCKED, 0); - } - public KW_SNAPSHOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SNAPSHOT, 0); - } - public KW_SQL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SQL, 0); - } - public KW_STABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STABLE, 0); - } - public KW_STANDALONE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STANDALONE, 0); - } - public KW_START(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_START, 0); - } - public KW_STATEMENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STATEMENT, 0); - } - public KW_STATISTICS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); - } - public KW_STDIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STDIN, 0); - } - public KW_STDOUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STDOUT, 0); - } - public KW_STORAGE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STORAGE, 0); - } - public KW_STORED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STORED, 0); - } - public KW_STRICT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STRICT, 0); - } - public KW_STRIP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STRIP, 0); - } - public KW_SUBSCRIPTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0); - } - public KW_SUPPORT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SUPPORT, 0); - } - public KW_SYSID(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SYSID, 0); - } - public KW_SYSTEM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SYSTEM, 0); - } - public KW_TABLES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLES, 0); - } - public KW_TABLESPACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); - } - public KW_TEMP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMP, 0); - } - public KW_TEMPLATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); - } - public KW_TEMPORARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEMPORARY, 0); - } - public KW_TEXT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TEXT, 0); - } - public KW_TIES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TIES, 0); - } - public KW_TRANSACTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); - } - public KW_TRANSFORM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0); - } - public KW_TRIGGER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); - } - public KW_TRUNCATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRUNCATE, 0); - } - public KW_TRUSTED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRUSTED, 0); - } - public KW_TYPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPE, 0); - } - public KW_TYPES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TYPES, 0); - } - public KW_UESCAPE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UESCAPE, 0); - } - public KW_UNBOUNDED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNBOUNDED, 0); - } - public KW_UNCOMMITTED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNCOMMITTED, 0); - } - public KW_UNENCRYPTED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNENCRYPTED, 0); - } - public KW_UNKNOWN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNKNOWN, 0); - } - public KW_UNLISTEN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNLISTEN, 0); - } - public KW_UNLOGGED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNLOGGED, 0); - } - public KW_UNTIL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNTIL, 0); - } - public KW_UPDATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UPDATE, 0); - } - public KW_VACUUM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VACUUM, 0); - } - public KW_VALID(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALID, 0); - } - public KW_VALIDATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALIDATE, 0); - } - public KW_VALIDATOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALIDATOR, 0); - } - public KW_VALUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALUE, 0); - } - public KW_VARYING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VARYING, 0); - } - public KW_VERSION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VERSION, 0); - } - public KW_VIEW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VIEW, 0); - } - public KW_VIEWS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VIEWS, 0); - } - public KW_VOLATILE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VOLATILE, 0); - } - public KW_WHITESPACE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WHITESPACE, 0); - } - public KW_WITHIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITHIN, 0); - } - public KW_WITHOUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); - } - public KW_WORK(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WORK, 0); - } - public KW_WRAPPER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); - } - public KW_WRITE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WRITE, 0); - } - public KW_XML(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XML, 0); - } - public KW_YEAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_YEAR, 0); - } - public KW_YES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_YES, 0); - } - public KW_ZONE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ZONE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_unreserved_keyword; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterUnreserved_keyword) { - listener.enterUnreserved_keyword(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitUnreserved_keyword) { - listener.exitUnreserved_keyword(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitUnreserved_keyword) { - return visitor.visitUnreserved_keyword(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Col_name_keywordContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_BETWEEN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BETWEEN, 0); - } - public KW_BIGINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BIGINT, 0); - } - public bit(): BitContext | null { - return this.getRuleContext(0, BitContext); - } - public KW_BOOLEAN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BOOLEAN, 0); - } - public KW_CHAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CHAR, 0); - } - public character(): CharacterContext | null { - return this.getRuleContext(0, CharacterContext); - } - public KW_COALESCE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COALESCE, 0); - } - public KW_DEC(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEC, 0); - } - public KW_DECIMAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DECIMAL, 0); - } - public KW_EXISTS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXISTS, 0); - } - public KW_EXTRACT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXTRACT, 0); - } - public KW_FLOAT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FLOAT, 0); - } - public KW_GREATEST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GREATEST, 0); - } - public KW_GROUPING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GROUPING, 0); - } - public KW_INOUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INOUT, 0); - } - public KW_INT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INT, 0); - } - public KW_INTEGER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INTEGER, 0); - } - public KW_INTERVAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INTERVAL, 0); - } - public KW_LEAST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LEAST, 0); - } - public KW_NATIONAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NATIONAL, 0); - } - public KW_NCHAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NCHAR, 0); - } - public KW_NONE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NONE, 0); - } - public KW_NORMALIZE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NORMALIZE, 0); - } - public KW_NULLIF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULLIF, 0); - } - public numeric(): NumericContext | null { - return this.getRuleContext(0, NumericContext); - } - public KW_OUT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OUT, 0); - } - public KW_OVERLAY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OVERLAY, 0); - } - public KW_POSITION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_POSITION, 0); - } - public KW_PRECISION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRECISION, 0); - } - public KW_REAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REAL, 0); - } - public KW_ROW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ROW, 0); - } - public KW_SETOF(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SETOF, 0); - } - public KW_SMALLINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SMALLINT, 0); - } - public KW_SUBSTRING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SUBSTRING, 0); - } - public KW_TIME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TIME, 0); - } - public KW_TIMESTAMP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TIMESTAMP, 0); + public KW_PARTIAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARTIAL, 0); } - public KW_TREAT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TREAT, 0); + public KW_PARTITION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PARTITION, 0); } - public KW_TRIM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRIM, 0); + public KW_PASSING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PASSING, 0); } - public KW_VALUES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VALUES, 0); + public KW_PASSWORD(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PASSWORD, 0); } - public KW_VARCHAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VARCHAR, 0); + public KW_PLANS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PLANS, 0); } - public KW_XMLATTRIBUTES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLATTRIBUTES, 0); + public KW_POLICY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_POLICY, 0); } - public KW_XMLCONCAT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLCONCAT, 0); + public KW_PRECEDING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRECEDING, 0); } - public KW_XMLELEMENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLELEMENT, 0); + public KW_PREPARE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PREPARE, 0); } - public KW_XMLEXISTS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLEXISTS, 0); + public KW_PREPARED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PREPARED, 0); } - public KW_XMLFOREST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLFOREST, 0); + public KW_PRESERVE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRESERVE, 0); } - public KW_XMLNAMESPACES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLNAMESPACES, 0); + public KW_PRIOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRIOR, 0); } - public KW_XMLPARSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLPARSE, 0); + public KW_PRIVILEGES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRIVILEGES, 0); } - public KW_XMLPI(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLPI, 0); + public KW_PROCEDURAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURAL, 0); } - public KW_XMLROOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLROOT, 0); + public KW_PROCEDURE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURE, 0); } - public KW_XMLSERIALIZE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLSERIALIZE, 0); + public KW_PROCEDURES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROCEDURES, 0); } - public KW_XMLTABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_XMLTABLE, 0); + public KW_PROGRAM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PROGRAM, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_col_name_keyword; + public KW_PUBLICATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PUBLICATION, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCol_name_keyword) { - listener.enterCol_name_keyword(this); - } + public KW_QUOTE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_QUOTE, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCol_name_keyword) { - listener.exitCol_name_keyword(this); - } + public KW_RANGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RANGE, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCol_name_keyword) { - return visitor.visitCol_name_keyword(this); - } else { - return visitor.visitChildren(this); - } + public KW_READ(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_READ, 0); } -} - - -export class Type_func_name_keywordContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_REASSIGN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REASSIGN, 0); } - public KW_AUTHORIZATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AUTHORIZATION, 0); + public KW_RECHECK(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RECHECK, 0); } - public KW_BINARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BINARY, 0); + public KW_RECURSIVE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RECURSIVE, 0); } - public KW_COLLATION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLLATION, 0); + public KW_REF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REF, 0); } - public KW_CONCURRENTLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONCURRENTLY, 0); + public KW_REFERENCING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REFERENCING, 0); } - public KW_CROSS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CROSS, 0); + public KW_REFRESH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REFRESH, 0); } - public KW_CURRENT_SCHEMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT_SCHEMA, 0); + public KW_REINDEX(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REINDEX, 0); } - public KW_FREEZE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FREEZE, 0); + public KW_RELATIVE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RELATIVE, 0); } - public KW_FULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FULL, 0); + public KW_RELEASE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RELEASE, 0); } - public KW_ILIKE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ILIKE, 0); + public KW_RENAME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RENAME, 0); } - public KW_INNER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INNER, 0); + public KW_REPEATABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REPEATABLE, 0); } - public KW_IS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IS, 0); + public KW_REPLACE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REPLACE, 0); } - public KW_ISNULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ISNULL, 0); + public KW_REPLICA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REPLICA, 0); } - public KW_JOIN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_JOIN, 0); + public KW_RESET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESET, 0); } - public KW_LEFT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LEFT, 0); + public KW_RESTART(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESTART, 0); } - public KW_LIKE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LIKE, 0); + public KW_RESTRICT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RESTRICT, 0); } - public KW_NATURAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NATURAL, 0); + public KW_RETURNS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RETURNS, 0); } - public KW_NOTNULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOTNULL, 0); + public KW_REVOKE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REVOKE, 0); } - public KW_OUTER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OUTER, 0); + public KW_ROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLE, 0); } - public KW_OVERLAPS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OVERLAPS, 0); + public KW_ROLLBACK(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLLBACK, 0); } - public KW_RIGHT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RIGHT, 0); + public KW_ROLLUP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLLUP, 0); } - public KW_SIMILAR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SIMILAR, 0); + public KW_ROUTINE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINE, 0); } - public KW_TABLESAMPLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLESAMPLE, 0); + public KW_ROUTINES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROUTINES, 0); } - public KW_VERBOSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VERBOSE, 0); + public KW_ROWS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROWS, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_type_func_name_keyword; + public KW_RULE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RULE, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterType_func_name_keyword) { - listener.enterType_func_name_keyword(this); - } + public KW_SAVEPOINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SAVEPOINT, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitType_func_name_keyword) { - listener.exitType_func_name_keyword(this); - } + public KW_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMA, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitType_func_name_keyword) { - return visitor.visitType_func_name_keyword(this); - } else { - return visitor.visitChildren(this); - } + public KW_SCHEMAS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCHEMAS, 0); } -} - - -export class Reserved_keywordContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_SCROLL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCROLL, 0); } - public KW_ALL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALL, 0); + public KW_SEARCH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEARCH, 0); } - public KW_ANALYSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ANALYSE, 0); + public KW_SECOND(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SECOND, 0); } - public KW_ANALYZE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ANALYZE, 0); + public KW_SECURITY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SECURITY, 0); } - public KW_AND(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AND, 0); + public KW_SEQUENCE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCE, 0); } - public KW_ANY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ANY, 0); + public KW_SEQUENCES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SEQUENCES, 0); } - public KW_ARRAY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ARRAY, 0); + public KW_SERIALIZABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SERIALIZABLE, 0); } - public KW_AS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_AS, 0); + public KW_SERVER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SERVER, 0); } - public KW_ASC(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ASC, 0); + public KW_SESSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SESSION, 0); } - public KW_ASYMMETRIC(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ASYMMETRIC, 0); + public KW_SET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SET, 0); } - public KW_BOTH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_BOTH, 0); + public KW_SETS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SETS, 0); } - public KW_CASE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CASE, 0); + public KW_SHARE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SHARE, 0); } - public KW_CAST(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CAST, 0); + public KW_SHOW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SHOW, 0); } - public KW_CHECK(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CHECK, 0); + public KW_SIMPLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SIMPLE, 0); } - public KW_COLLATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLLATE, 0); + public KW_SKIP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SKIP, 0); } - public KW_COLUMN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLUMN, 0); + public KW_SKIP_LOCKED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SKIP_LOCKED, 0); } - public KW_CONSTRAINT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); + public KW_SNAPSHOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SNAPSHOT, 0); } - public KW_CREATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CREATE, 0); + public KW_SQL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SQL, 0); } - public KW_CURRENT_CATALOG(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT_CATALOG, 0); + public KW_STABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STABLE, 0); } - public KW_CURRENT_DATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT_DATE, 0); + public KW_STANDALONE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STANDALONE, 0); } - public KW_CURRENT_ROLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT_ROLE, 0); + public KW_START(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_START, 0); } - public KW_CURRENT_TIME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT_TIME, 0); + public KW_STATEMENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STATEMENT, 0); } - public KW_CURRENT_TIMESTAMP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT_TIMESTAMP, 0); + public KW_STATISTICS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STATISTICS, 0); } - public KW_CURRENT_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT_USER, 0); + public KW_STDIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STDIN, 0); } - public KW_DEFERRABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFERRABLE, 0); + public KW_STDOUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STDOUT, 0); } - public KW_DESC(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DESC, 0); + public KW_STORAGE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STORAGE, 0); } - public KW_DISTINCT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DISTINCT, 0); + public KW_STORED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STORED, 0); } - public KW_DO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DO, 0); + public KW_STRICT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STRICT, 0); } - public KW_ELSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ELSE, 0); + public KW_STRIP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STRIP, 0); } - public KW_END(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_END, 0); + public KW_SUBSCRIPTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SUBSCRIPTION, 0); } - public KW_EXCEPT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXCEPT, 0); + public KW_SUPPORT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SUPPORT, 0); } - public KW_FALSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FALSE, 0); + public KW_SYSID(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SYSID, 0); } - public KW_FETCH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FETCH, 0); + public KW_SYSTEM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SYSTEM, 0); } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); + public KW_TABLES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLES, 0); } - public KW_FOREIGN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); + public KW_TABLESPACE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLESPACE, 0); } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); + public KW_TEMP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMP, 0); } - public KW_GRANT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GRANT, 0); + public KW_TEMPLATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPLATE, 0); } - public KW_GROUP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_GROUP, 0); + public KW_TEMPORARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEMPORARY, 0); } - public KW_HAVING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_HAVING, 0); + public KW_TEXT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TEXT, 0); } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); + public KW_TIES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TIES, 0); } - public KW_INITIALLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INITIALLY, 0); + public KW_TRANSACTION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSACTION, 0); } - public KW_INTERSECT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INTERSECT, 0); + public KW_TRANSFORM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRANSFORM, 0); } - public KW_LATERAL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LATERAL, 0); + public KW_TRIGGER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRIGGER, 0); } - public KW_LEADING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LEADING, 0); + public KW_TRUNCATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRUNCATE, 0); } - public KW_LIMIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LIMIT, 0); + public KW_TRUSTED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRUSTED, 0); } - public KW_LOCALTIME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LOCALTIME, 0); + public KW_TYPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPE, 0); } - public KW_LOCALTIMESTAMP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_LOCALTIMESTAMP, 0); + public KW_TYPES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TYPES, 0); } - public KW_NOT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NOT, 0); + public KW_UESCAPE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UESCAPE, 0); } - public KW_NULL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NULL, 0); + public KW_UNBOUNDED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNBOUNDED, 0); } - public KW_OFFSET(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OFFSET, 0); + public KW_UNCOMMITTED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNCOMMITTED, 0); } - public KW_ON(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ON, 0); + public KW_UNENCRYPTED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNENCRYPTED, 0); } - public KW_ONLY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ONLY, 0); + public KW_UNKNOWN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNKNOWN, 0); } - public KW_OR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OR, 0); + public KW_UNLISTEN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNLISTEN, 0); } - public KW_ORDER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ORDER, 0); + public KW_UNLOGGED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNLOGGED, 0); } - public KW_PLACING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PLACING, 0); + public KW_UNTIL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNTIL, 0); } - public KW_PRIMARY(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRIMARY, 0); + public KW_UPDATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UPDATE, 0); } - public KW_REFERENCES(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_REFERENCES, 0); + public KW_VACUUM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VACUUM, 0); } - public KW_RETURNING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_RETURNING, 0); + public KW_VALID(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALID, 0); } - public KW_SELECT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SELECT, 0); + public KW_VALIDATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALIDATE, 0); } - public KW_SESSION_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SESSION_USER, 0); + public KW_VALIDATOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALIDATOR, 0); } - public KW_SOME(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SOME, 0); + public KW_VALUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALUE, 0); } - public KW_SYMMETRIC(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SYMMETRIC, 0); + public KW_VARYING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VARYING, 0); } - public KW_TABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TABLE, 0); + public KW_VERSION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VERSION, 0); } - public KW_THEN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_THEN, 0); + public KW_VIEW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VIEW, 0); } - public KW_TO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TO, 0); + public KW_VIEWS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VIEWS, 0); } - public KW_TRAILING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRAILING, 0); + public KW_VOLATILE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VOLATILE, 0); } - public KW_TRUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_TRUE, 0); + public KW_WHITESPACE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WHITESPACE, 0); } - public KW_UNION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNION, 0); + public KW_WITHIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITHIN, 0); } - public KW_UNIQUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_UNIQUE, 0); + public KW_WITHOUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITHOUT, 0); } - public KW_USER(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USER, 0); + public KW_WORK(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WORK, 0); } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); + public KW_WRAPPER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WRAPPER, 0); } - public KW_VARIADIC(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VARIADIC, 0); + public KW_WRITE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WRITE, 0); } - public KW_WHEN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WHEN, 0); + public KW_XML(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XML, 0); } - public KW_WHERE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WHERE, 0); + public KW_YEAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_YEAR, 0); } - public KW_WINDOW(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WINDOW, 0); + public KW_YES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_YES, 0); } - public KW_WITH(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_WITH, 0); + public KW_ZONE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ZONE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_reserved_keyword; + return PostgreSqlParser.RULE_unreserved_keyword; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterReserved_keyword) { - listener.enterReserved_keyword(this); + if(listener.enterUnreserved_keyword) { + listener.enterUnreserved_keyword(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitReserved_keyword) { - listener.exitReserved_keyword(this); + if(listener.exitUnreserved_keyword) { + listener.exitUnreserved_keyword(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitReserved_keyword) { - return visitor.visitReserved_keyword(this); + if (visitor.visitUnreserved_keyword) { + return visitor.visitUnreserved_keyword(this); } else { return visitor.visitChildren(this); } @@ -109839,224 +83601,179 @@ export class Reserved_keywordContext extends antlr.ParserRuleContext { } -export class Pl_functionContext extends antlr.ParserRuleContext { +export class Col_name_keywordContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public comp_options(): Comp_optionsContext { - return this.getRuleContext(0, Comp_optionsContext)!; + public KW_BETWEEN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BETWEEN, 0); } - public pl_block(): Pl_blockContext { - return this.getRuleContext(0, Pl_blockContext)!; + public KW_BIGINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BIGINT, 0); } - public opt_semi(): Opt_semiContext { - return this.getRuleContext(0, Opt_semiContext)!; + public bit(): BitContext | null { + return this.getRuleContext(0, BitContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_pl_function; + public KW_BOOLEAN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BOOLEAN, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPl_function) { - listener.enterPl_function(this); - } + public KW_CHAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CHAR, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPl_function) { - listener.exitPl_function(this); - } + public character(): CharacterContext | null { + return this.getRuleContext(0, CharacterContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPl_function) { - return visitor.visitPl_function(this); - } else { - return visitor.visitChildren(this); - } + public KW_COALESCE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COALESCE, 0); } -} - - -export class Comp_optionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_DEC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEC, 0); } - public comp_option(): Comp_optionContext[]; - public comp_option(i: number): Comp_optionContext | null; - public comp_option(i?: number): Comp_optionContext[] | Comp_optionContext | null { - if (i === undefined) { - return this.getRuleContexts(Comp_optionContext); - } - - return this.getRuleContext(i, Comp_optionContext); + public KW_DECIMAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DECIMAL, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_comp_options; + public KW_EXISTS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXISTS, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterComp_options) { - listener.enterComp_options(this); - } + public KW_EXTRACT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXTRACT, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitComp_options) { - listener.exitComp_options(this); - } + public KW_FLOAT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FLOAT, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitComp_options) { - return visitor.visitComp_options(this); - } else { - return visitor.visitChildren(this); - } + public KW_GREATEST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GREATEST, 0); } -} - - -export class Comp_optionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_GROUPING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GROUPING, 0); } - public sharp(): SharpContext { - return this.getRuleContext(0, SharpContext)!; + public KW_INOUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INOUT, 0); } - public KW_OPTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_OPTION, 0); + public KW_INT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INT, 0); } - public KW_DUMP(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DUMP, 0); + public KW_INTEGER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INTEGER, 0); } - public KW_PRINT_STRICT_PARAMS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_PRINT_STRICT_PARAMS, 0); + public KW_INTERVAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INTERVAL, 0); } - public option_value(): Option_valueContext | null { - return this.getRuleContext(0, Option_valueContext); + public KW_LEAST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LEAST, 0); } - public KW_VARIABLE_CONFLICT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_VARIABLE_CONFLICT, 0); + public KW_NATIONAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NATIONAL, 0); } - public KW_ERROR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ERROR, 0); + public KW_NCHAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NCHAR, 0); } - public KW_USE_VARIABLE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USE_VARIABLE, 0); + public KW_NONE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NONE, 0); } - public KW_USE_COLUMN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USE_COLUMN, 0); + public KW_NORMALIZE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NORMALIZE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_comp_option; + public KW_NULLIF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULLIF, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterComp_option) { - listener.enterComp_option(this); - } + public numeric(): NumericContext | null { + return this.getRuleContext(0, NumericContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitComp_option) { - listener.exitComp_option(this); - } + public KW_OUT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OUT, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitComp_option) { - return visitor.visitComp_option(this); - } else { - return visitor.visitChildren(this); - } + public KW_OVERLAY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OVERLAY, 0); } -} - - -export class SharpContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_POSITION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_POSITION, 0); } - public Operator(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.Operator, 0)!; + public KW_PRECISION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRECISION, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_sharp; + public KW_REAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REAL, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterSharp) { - listener.enterSharp(this); - } + public KW_ROW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROW, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitSharp) { - listener.exitSharp(this); - } + public KW_SETOF(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SETOF, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitSharp) { - return visitor.visitSharp(this); - } else { - return visitor.visitChildren(this); - } + public KW_SMALLINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SMALLINT, 0); } -} - - -export class Option_valueContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_SUBSTRING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SUBSTRING, 0); } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); + public KW_TIME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TIME, 0); } - public reserved_keyword(): Reserved_keywordContext | null { - return this.getRuleContext(0, Reserved_keywordContext); + public KW_TIMESTAMP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TIMESTAMP, 0); } - public plsql_unreserved_keyword(): Plsql_unreserved_keywordContext | null { - return this.getRuleContext(0, Plsql_unreserved_keywordContext); + public KW_TREAT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TREAT, 0); } - public unreserved_keyword(): Unreserved_keywordContext | null { - return this.getRuleContext(0, Unreserved_keywordContext); + public KW_TRIM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRIM, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_option_value; + public KW_VALUES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VALUES, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOption_value) { - listener.enterOption_value(this); - } + public KW_VARCHAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VARCHAR, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOption_value) { - listener.exitOption_value(this); - } + public KW_XMLATTRIBUTES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLATTRIBUTES, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOption_value) { - return visitor.visitOption_value(this); - } else { - return visitor.visitChildren(this); - } + public KW_XMLCONCAT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLCONCAT, 0); } -} - - -export class Opt_semiContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_XMLELEMENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLELEMENT, 0); } - public SEMI(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.SEMI, 0); + public KW_XMLEXISTS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLEXISTS, 0); + } + public KW_XMLFOREST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLFOREST, 0); + } + public KW_XMLNAMESPACES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLNAMESPACES, 0); + } + public KW_XMLPARSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLPARSE, 0); + } + public KW_XMLPI(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLPI, 0); + } + public KW_XMLROOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLROOT, 0); + } + public KW_XMLSERIALIZE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLSERIALIZE, 0); + } + public KW_XMLTABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_XMLTABLE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_semi; + return PostgreSqlParser.RULE_col_name_keyword; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_semi) { - listener.enterOpt_semi(this); + if(listener.enterCol_name_keyword) { + listener.enterCol_name_keyword(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_semi) { - listener.exitOpt_semi(this); + if(listener.exitCol_name_keyword) { + listener.exitCol_name_keyword(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_semi) { - return visitor.visitOpt_semi(this); + if (visitor.visitCol_name_keyword) { + return visitor.visitCol_name_keyword(this); } else { return visitor.visitChildren(this); } @@ -110064,146 +83781,95 @@ export class Opt_semiContext extends antlr.ParserRuleContext { } -export class Pl_blockContext extends antlr.ParserRuleContext { +export class Type_func_name_keywordContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public decl_sect(): Decl_sectContext { - return this.getRuleContext(0, Decl_sectContext)!; - } - public KW_BEGIN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_BEGIN, 0)!; - } - public proc_sect(): Proc_sectContext { - return this.getRuleContext(0, Proc_sectContext)!; - } - public exception_sect(): Exception_sectContext { - return this.getRuleContext(0, Exception_sectContext)!; + public KW_AUTHORIZATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AUTHORIZATION, 0); } - public KW_END(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_END, 0)!; + public KW_BINARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BINARY, 0); } - public opt_label(): Opt_labelContext { - return this.getRuleContext(0, Opt_labelContext)!; + public KW_COLLATION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLLATION, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_pl_block; + public KW_CONCURRENTLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONCURRENTLY, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPl_block) { - listener.enterPl_block(this); - } + public KW_CROSS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CROSS, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPl_block) { - listener.exitPl_block(this); - } + public KW_CURRENT_SCHEMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT_SCHEMA, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPl_block) { - return visitor.visitPl_block(this); - } else { - return visitor.visitChildren(this); - } + public KW_FREEZE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FREEZE, 0); } -} - - -export class Decl_sectContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_FULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FULL, 0); } - public opt_block_label(): Opt_block_labelContext { - return this.getRuleContext(0, Opt_block_labelContext)!; + public KW_ILIKE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ILIKE, 0); } - public decl_start(): Decl_startContext | null { - return this.getRuleContext(0, Decl_startContext); + public KW_INNER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INNER, 0); } - public decl_stmts(): Decl_stmtsContext | null { - return this.getRuleContext(0, Decl_stmtsContext); + public KW_IS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IS, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_sect; + public KW_ISNULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ISNULL, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_sect) { - listener.enterDecl_sect(this); - } + public KW_JOIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_JOIN, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_sect) { - listener.exitDecl_sect(this); - } + public KW_LEFT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LEFT, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_sect) { - return visitor.visitDecl_sect(this); - } else { - return visitor.visitChildren(this); - } + public KW_LIKE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LIKE, 0); } -} - - -export class Decl_startContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_NATURAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NATURAL, 0); } - public KW_DECLARE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DECLARE, 0)!; + public KW_NOTNULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOTNULL, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_start; + public KW_OUTER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OUTER, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_start) { - listener.enterDecl_start(this); - } + public KW_OVERLAPS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OVERLAPS, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_start) { - listener.exitDecl_start(this); - } + public KW_RIGHT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RIGHT, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_start) { - return visitor.visitDecl_start(this); - } else { - return visitor.visitChildren(this); - } + public KW_SIMILAR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SIMILAR, 0); } -} - - -export class Decl_stmtsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_TABLESAMPLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLESAMPLE, 0); } - public decl_stmt(): Decl_stmtContext[]; - public decl_stmt(i: number): Decl_stmtContext | null; - public decl_stmt(i?: number): Decl_stmtContext[] | Decl_stmtContext | null { - if (i === undefined) { - return this.getRuleContexts(Decl_stmtContext); - } - - return this.getRuleContext(i, Decl_stmtContext); + public KW_VERBOSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VERBOSE, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_stmts; + return PostgreSqlParser.RULE_type_func_name_keyword; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_stmts) { - listener.enterDecl_stmts(this); + if(listener.enterType_func_name_keyword) { + listener.enterType_func_name_keyword(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_stmts) { - listener.exitDecl_stmts(this); + if(listener.exitType_func_name_keyword) { + listener.exitType_func_name_keyword(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_stmts) { - return visitor.visitDecl_stmts(this); + if (visitor.visitType_func_name_keyword) { + return visitor.visitType_func_name_keyword(this); } else { return visitor.visitChildren(this); } @@ -110211,353 +83877,251 @@ export class Decl_stmtsContext extends antlr.ParserRuleContext { } -export class Label_declContext extends antlr.ParserRuleContext { +export class Reserved_keywordContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public LESS_LESS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.LESS_LESS, 0)!; + public KW_ALL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALL, 0); } - public any_identifier(): Any_identifierContext { - return this.getRuleContext(0, Any_identifierContext)!; + public KW_ANALYSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ANALYSE, 0); } - public GREATER_GREATER(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.GREATER_GREATER, 0)!; + public KW_ANALYZE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ANALYZE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_label_decl; + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AND, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterLabel_decl) { - listener.enterLabel_decl(this); - } + public KW_ANY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ANY, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitLabel_decl) { - listener.exitLabel_decl(this); - } + public KW_ARRAY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ARRAY, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitLabel_decl) { - return visitor.visitLabel_decl(this); - } else { - return visitor.visitChildren(this); - } + public KW_AS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AS, 0); } -} - - -export class Decl_stmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_ASC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ASC, 0); } - public decl_statement(): Decl_statementContext | null { - return this.getRuleContext(0, Decl_statementContext); + public KW_ASYMMETRIC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ASYMMETRIC, 0); } - public KW_DECLARE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DECLARE, 0); + public KW_BOTH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_BOTH, 0); } - public label_decl(): Label_declContext | null { - return this.getRuleContext(0, Label_declContext); + public KW_CASE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CASE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_stmt; + public KW_CAST(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CAST, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_stmt) { - listener.enterDecl_stmt(this); - } + public KW_CHECK(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CHECK, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_stmt) { - listener.exitDecl_stmt(this); - } + public KW_COLLATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLLATE, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_stmt) { - return visitor.visitDecl_stmt(this); - } else { - return visitor.visitChildren(this); - } + public KW_COLUMN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COLUMN, 0); } -} - - -export class Decl_statementContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_CONSTRAINT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTRAINT, 0); } - public decl_varname(): Decl_varnameContext { - return this.getRuleContext(0, Decl_varnameContext)!; + public KW_CREATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CREATE, 0); } - public SEMI(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.SEMI, 0)!; + public KW_CURRENT_CATALOG(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT_CATALOG, 0); } - public KW_ALIAS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ALIAS, 0); + public KW_CURRENT_DATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT_DATE, 0); } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); + public KW_CURRENT_ROLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT_ROLE, 0); } - public decl_aliasitem(): Decl_aliasitemContext | null { - return this.getRuleContext(0, Decl_aliasitemContext); + public KW_CURRENT_TIME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT_TIME, 0); } - public decl_const(): Decl_constContext | null { - return this.getRuleContext(0, Decl_constContext); + public KW_CURRENT_TIMESTAMP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT_TIMESTAMP, 0); } - public decl_datatype(): Decl_datatypeContext | null { - return this.getRuleContext(0, Decl_datatypeContext); + public KW_CURRENT_USER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT_USER, 0); } - public decl_collate(): Decl_collateContext | null { - return this.getRuleContext(0, Decl_collateContext); + public KW_DEFERRABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFERRABLE, 0); } - public decl_notnull(): Decl_notnullContext | null { - return this.getRuleContext(0, Decl_notnullContext); + public KW_DESC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DESC, 0); } - public decl_defval(): Decl_defvalContext | null { - return this.getRuleContext(0, Decl_defvalContext); + public KW_DISTINCT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DISTINCT, 0); } - public opt_scrollable(): Opt_scrollableContext | null { - return this.getRuleContext(0, Opt_scrollableContext); + public KW_DO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DO, 0); } - public KW_CURSOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURSOR, 0); + public KW_ELSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ELSE, 0); } - public decl_cursor_args(): Decl_cursor_argsContext | null { - return this.getRuleContext(0, Decl_cursor_argsContext); + public KW_END(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_END, 0); } - public decl_is_for(): Decl_is_forContext | null { - return this.getRuleContext(0, Decl_is_forContext); + public KW_EXCEPT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXCEPT, 0); } - public decl_cursor_query(): Decl_cursor_queryContext | null { - return this.getRuleContext(0, Decl_cursor_queryContext); + public KW_FALSE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FALSE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_statement; + public KW_FETCH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FETCH, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_statement) { - listener.enterDecl_statement(this); - } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_statement) { - listener.exitDecl_statement(this); - } + public KW_FOREIGN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOREIGN, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_statement) { - return visitor.visitDecl_statement(this); - } else { - return visitor.visitChildren(this); - } + public KW_FROM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FROM, 0); } -} - - -export class Opt_scrollableContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_GRANT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GRANT, 0); } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); + public KW_GROUP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_GROUP, 0); + } + public KW_HAVING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_HAVING, 0); + } + public KW_IN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IN, 0); } - public KW_SCROLL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCROLL, 0); + public KW_INITIALLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INITIALLY, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_scrollable; + public KW_INTERSECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_INTERSECT, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_scrollable) { - listener.enterOpt_scrollable(this); - } + public KW_LATERAL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LATERAL, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_scrollable) { - listener.exitOpt_scrollable(this); - } + public KW_LEADING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LEADING, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_scrollable) { - return visitor.visitOpt_scrollable(this); - } else { - return visitor.visitChildren(this); - } + public KW_LIMIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LIMIT, 0); } -} - - -export class Decl_cursor_queryContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_LOCALTIME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LOCALTIME, 0); } - public selectstmt(): SelectstmtContext { - return this.getRuleContext(0, SelectstmtContext)!; + public KW_LOCALTIMESTAMP(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_LOCALTIMESTAMP, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_cursor_query; + public KW_NOT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NOT, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_cursor_query) { - listener.enterDecl_cursor_query(this); - } + public KW_NULL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NULL, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_cursor_query) { - listener.exitDecl_cursor_query(this); - } + public KW_OFFSET(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OFFSET, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_cursor_query) { - return visitor.visitDecl_cursor_query(this); - } else { - return visitor.visitChildren(this); - } + public KW_ON(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ON, 0); } -} - - -export class Decl_cursor_argsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_ONLY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ONLY, 0); } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); + public KW_OR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_OR, 0); } - public decl_cursor_arglist(): Decl_cursor_arglistContext | null { - return this.getRuleContext(0, Decl_cursor_arglistContext); + public KW_ORDER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ORDER, 0); } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public KW_PLACING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PLACING, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_cursor_args; + public KW_PRIMARY(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_PRIMARY, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_cursor_args) { - listener.enterDecl_cursor_args(this); - } + public KW_REFERENCES(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_REFERENCES, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_cursor_args) { - listener.exitDecl_cursor_args(this); - } + public KW_RETURNING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_RETURNING, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_cursor_args) { - return visitor.visitDecl_cursor_args(this); - } else { - return visitor.visitChildren(this); - } + public KW_SELECT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SELECT, 0); } -} - - -export class Decl_cursor_arglistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_SESSION_USER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SESSION_USER, 0); } - public decl_cursor_arg(): Decl_cursor_argContext[]; - public decl_cursor_arg(i: number): Decl_cursor_argContext | null; - public decl_cursor_arg(i?: number): Decl_cursor_argContext[] | Decl_cursor_argContext | null { - if (i === undefined) { - return this.getRuleContexts(Decl_cursor_argContext); - } - - return this.getRuleContext(i, Decl_cursor_argContext); + public KW_SOME(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SOME, 0); } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } + public KW_SYMMETRIC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SYMMETRIC, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_cursor_arglist; + public KW_TABLE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TABLE, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_cursor_arglist) { - listener.enterDecl_cursor_arglist(this); - } + public KW_THEN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_THEN, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_cursor_arglist) { - listener.exitDecl_cursor_arglist(this); - } + public KW_TO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TO, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_cursor_arglist) { - return visitor.visitDecl_cursor_arglist(this); - } else { - return visitor.visitChildren(this); - } + public KW_TRAILING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRAILING, 0); } -} - - -export class Decl_cursor_argContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_TRUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_TRUE, 0); } - public decl_varname(): Decl_varnameContext { - return this.getRuleContext(0, Decl_varnameContext)!; + public KW_UNION(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNION, 0); } - public decl_datatype(): Decl_datatypeContext { - return this.getRuleContext(0, Decl_datatypeContext)!; + public KW_UNIQUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_UNIQUE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_cursor_arg; + public KW_USER(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USER, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_cursor_arg) { - listener.enterDecl_cursor_arg(this); - } + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USING, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_cursor_arg) { - listener.exitDecl_cursor_arg(this); - } + public KW_VARIADIC(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_VARIADIC, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_cursor_arg) { - return visitor.visitDecl_cursor_arg(this); - } else { - return visitor.visitChildren(this); - } + public KW_WHEN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WHEN, 0); } -} - - -export class Decl_is_forContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_WHERE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WHERE, 0); } - public KW_IS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IS, 0); + public KW_WINDOW(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WINDOW, 0); } - public KW_FOR(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FOR, 0); + public KW_WITH(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WITH, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_is_for; + return PostgreSqlParser.RULE_reserved_keyword; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_is_for) { - listener.enterDecl_is_for(this); + if(listener.enterReserved_keyword) { + listener.enterReserved_keyword(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_is_for) { - listener.exitDecl_is_for(this); + if(listener.exitReserved_keyword) { + listener.exitReserved_keyword(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_is_for) { - return visitor.visitDecl_is_for(this); + if (visitor.visitReserved_keyword) { + return visitor.visitReserved_keyword(this); } else { return visitor.visitChildren(this); } @@ -110565,62 +84129,74 @@ export class Decl_is_forContext extends antlr.ParserRuleContext { } -export class Decl_aliasitemContext extends antlr.ParserRuleContext { +export class Pl_blockContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public PARAM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.PARAM, 0); - } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); + public KW_BEGIN(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_BEGIN, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_aliasitem; + public KW_END(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_END, 0)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_aliasitem) { - listener.enterDecl_aliasitem(this); + public proc_stmt(): Proc_stmtContext[]; + public proc_stmt(i: number): Proc_stmtContext | null; + public proc_stmt(i?: number): Proc_stmtContext[] | Proc_stmtContext | null { + if (i === undefined) { + return this.getRuleContexts(Proc_stmtContext); } + + return this.getRuleContext(i, Proc_stmtContext); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_aliasitem) { - listener.exitDecl_aliasitem(this); - } + public exception_sect(): Exception_sectContext | null { + return this.getRuleContext(0, Exception_sectContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_aliasitem) { - return visitor.visitDecl_aliasitem(this); - } else { - return visitor.visitChildren(this); - } + public any_identifier(): Any_identifierContext | null { + return this.getRuleContext(0, Any_identifierContext); } -} - + public label_decl(): Label_declContext[]; + public label_decl(i: number): Label_declContext | null; + public label_decl(i?: number): Label_declContext[] | Label_declContext | null { + if (i === undefined) { + return this.getRuleContexts(Label_declContext); + } -export class Decl_varnameContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, Label_declContext); } - public any_identifier(): Any_identifierContext { - return this.getRuleContext(0, Any_identifierContext)!; + public KW_DECLARE(): antlr.TerminalNode[]; + public KW_DECLARE(i: number): antlr.TerminalNode | null; + public KW_DECLARE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_DECLARE); + } else { + return this.getToken(PostgreSqlParser.KW_DECLARE, i); + } + } + public decl_statement(): Decl_statementContext[]; + public decl_statement(i: number): Decl_statementContext | null; + public decl_statement(i?: number): Decl_statementContext[] | Decl_statementContext | null { + if (i === undefined) { + return this.getRuleContexts(Decl_statementContext); + } + + return this.getRuleContext(i, Decl_statementContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_varname; + return PostgreSqlParser.RULE_pl_block; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_varname) { - listener.enterDecl_varname(this); + if(listener.enterPl_block) { + listener.enterPl_block(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_varname) { - listener.exitDecl_varname(this); + if(listener.exitPl_block) { + listener.exitPl_block(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_varname) { - return visitor.visitDecl_varname(this); + if (visitor.visitPl_block) { + return visitor.visitPl_block(this); } else { return visitor.visitChildren(this); } @@ -110628,29 +84204,35 @@ export class Decl_varnameContext extends antlr.ParserRuleContext { } -export class Decl_constContext extends antlr.ParserRuleContext { +export class Label_declContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_CONSTANT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONSTANT, 0); + public LESS_LESS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.LESS_LESS, 0)!; + } + public any_identifier(): Any_identifierContext { + return this.getRuleContext(0, Any_identifierContext)!; + } + public GREATER_GREATER(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.GREATER_GREATER, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_const; + return PostgreSqlParser.RULE_label_decl; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_const) { - listener.enterDecl_const(this); + if(listener.enterLabel_decl) { + listener.enterLabel_decl(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_const) { - listener.exitDecl_const(this); + if(listener.exitLabel_decl) { + listener.exitLabel_decl(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_const) { - return visitor.visitDecl_const(this); + if (visitor.visitLabel_decl) { + return visitor.visitLabel_decl(this); } else { return visitor.visitChildren(this); } @@ -110658,72 +84240,45 @@ export class Decl_constContext extends antlr.ParserRuleContext { } -export class Decl_datatypeContext extends antlr.ParserRuleContext { +export class Decl_statementContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public typename(): TypenameContext { - return this.getRuleContext(0, TypenameContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_datatype; + public any_identifier(): Any_identifierContext { + return this.getRuleContext(0, Any_identifierContext)!; } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_datatype) { - listener.enterDecl_datatype(this); - } + public SEMI(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.SEMI, 0)!; } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_datatype) { - listener.exitDecl_datatype(this); - } + public KW_ALIAS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ALIAS, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_datatype) { - return visitor.visitDecl_datatype(this); - } else { - return visitor.visitChildren(this); - } + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } -} - - -export class Decl_collateContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public typename(): TypenameContext | null { + return this.getRuleContext(0, TypenameContext); } - public KW_COLLATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_COLLATE, 0); + public KW_CURSOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURSOR, 0); } - public any_name(): Any_nameContext | null { - return this.getRuleContext(0, Any_nameContext); + public selectstmt(): SelectstmtContext | null { + return this.getRuleContext(0, SelectstmtContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_collate; + public KW_IS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_IS, 0); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_collate) { - listener.enterDecl_collate(this); - } + public PARAM(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.PARAM, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_collate) { - listener.exitDecl_collate(this); - } + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_collate) { - return visitor.visitDecl_collate(this); - } else { - return visitor.visitChildren(this); - } + public KW_CONSTANT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONSTANT, 0); } -} - - -export class Decl_notnullContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public opt_collate_clause(): Opt_collate_clauseContext | null { + return this.getRuleContext(0, Opt_collate_clauseContext); } public KW_NOT(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_NOT, 0); @@ -110731,55 +84286,61 @@ export class Decl_notnullContext extends antlr.ParserRuleContext { public KW_NULL(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_NULL, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_notnull; + public sql_expression(): Sql_expressionContext | null { + return this.getRuleContext(0, Sql_expressionContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_notnull) { - listener.enterDecl_notnull(this); - } + public KW_SCROLL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCROLL, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_notnull) { - listener.exitDecl_notnull(this); - } + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_notnull) { - return visitor.visitDecl_notnull(this); - } else { - return visitor.visitChildren(this); + public decl_cursor_arg(): Decl_cursor_argContext[]; + public decl_cursor_arg(i: number): Decl_cursor_argContext | null; + public decl_cursor_arg(i?: number): Decl_cursor_argContext[] | Decl_cursor_argContext | null { + if (i === undefined) { + return this.getRuleContexts(Decl_cursor_argContext); } - } -} - -export class Decl_defvalContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, Decl_cursor_argContext); } - public decl_defkey(): Decl_defkeyContext | null { - return this.getRuleContext(0, Decl_defkeyContext); + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public sql_expression(): Sql_expressionContext | null { - return this.getRuleContext(0, Sql_expressionContext); + public assign_operator(): Assign_operatorContext | null { + return this.getRuleContext(0, Assign_operatorContext); + } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); + } + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); + } + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_defval; + return PostgreSqlParser.RULE_decl_statement; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_defval) { - listener.enterDecl_defval(this); + if(listener.enterDecl_statement) { + listener.enterDecl_statement(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_defval) { - listener.exitDecl_defval(this); + if(listener.exitDecl_statement) { + listener.exitDecl_statement(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_defval) { - return visitor.visitDecl_defval(this); + if (visitor.visitDecl_statement) { + return visitor.visitDecl_statement(this); } else { return visitor.visitChildren(this); } @@ -110787,32 +84348,32 @@ export class Decl_defvalContext extends antlr.ParserRuleContext { } -export class Decl_defkeyContext extends antlr.ParserRuleContext { +export class Decl_cursor_argContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public assign_operator(): Assign_operatorContext | null { - return this.getRuleContext(0, Assign_operatorContext); + public any_identifier(): Any_identifierContext { + return this.getRuleContext(0, Any_identifierContext)!; } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); + public typename(): TypenameContext { + return this.getRuleContext(0, TypenameContext)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_decl_defkey; + return PostgreSqlParser.RULE_decl_cursor_arg; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDecl_defkey) { - listener.enterDecl_defkey(this); + if(listener.enterDecl_cursor_arg) { + listener.enterDecl_cursor_arg(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDecl_defkey) { - listener.exitDecl_defkey(this); + if(listener.exitDecl_cursor_arg) { + listener.exitDecl_cursor_arg(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDecl_defkey) { - return visitor.visitDecl_defkey(this); + if (visitor.visitDecl_cursor_arg) { + return visitor.visitDecl_cursor_arg(this); } else { return visitor.visitChildren(this); } @@ -110853,42 +84414,6 @@ export class Assign_operatorContext extends antlr.ParserRuleContext { } -export class Proc_sectContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public proc_stmt(): Proc_stmtContext[]; - public proc_stmt(i: number): Proc_stmtContext | null; - public proc_stmt(i?: number): Proc_stmtContext[] | Proc_stmtContext | null { - if (i === undefined) { - return this.getRuleContexts(Proc_stmtContext); - } - - return this.getRuleContext(i, Proc_stmtContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_proc_sect; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterProc_sect) { - listener.enterProc_sect(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitProc_sect) { - listener.exitProc_sect(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitProc_sect) { - return visitor.visitProc_sect(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Proc_stmtContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -110914,14 +84439,8 @@ export class Proc_stmtContext extends antlr.ParserRuleContext { public stmt_case(): Stmt_caseContext | null { return this.getRuleContext(0, Stmt_caseContext); } - public stmt_loop(): Stmt_loopContext | null { - return this.getRuleContext(0, Stmt_loopContext); - } - public stmt_while(): Stmt_whileContext | null { - return this.getRuleContext(0, Stmt_whileContext); - } - public stmt_for(): Stmt_forContext | null { - return this.getRuleContext(0, Stmt_forContext); + public stmt_loop_while_for(): Stmt_loop_while_forContext | null { + return this.getRuleContext(0, Stmt_loop_while_forContext); } public stmt_foreach_a(): Stmt_foreach_aContext | null { return this.getRuleContext(0, Stmt_foreach_aContext); @@ -110962,11 +84481,8 @@ export class Proc_stmtContext extends antlr.ParserRuleContext { public stmt_null(): Stmt_nullContext | null { return this.getRuleContext(0, Stmt_nullContext); } - public stmt_commit(): Stmt_commitContext | null { - return this.getRuleContext(0, Stmt_commitContext); - } - public stmt_rollback(): Stmt_rollbackContext | null { - return this.getRuleContext(0, Stmt_rollbackContext); + public stmt_commit_or_rollback(): Stmt_commit_or_rollbackContext | null { + return this.getRuleContext(0, Stmt_commit_or_rollbackContext); } public stmt_set(): Stmt_setContext | null { return this.getRuleContext(0, Stmt_setContext); @@ -111001,8 +84517,8 @@ export class Stmt_performContext extends antlr.ParserRuleContext { public KW_PERFORM(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_PERFORM, 0)!; } - public expr_until_semi(): Expr_until_semiContext { - return this.getRuleContext(0, Expr_until_semiContext)!; + public sql_expression(): Sql_expressionContext { + return this.getRuleContext(0, Sql_expressionContext)!; } public SEMI(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.SEMI, 0)!; @@ -111043,15 +84559,15 @@ export class Stmt_callContext extends antlr.ParserRuleContext { public OPEN_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public opt_expr_list(): Opt_expr_listContext | null { - return this.getRuleContext(0, Opt_expr_listContext); - } public CLOSE_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public SEMI(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.SEMI, 0); } + public expr_list(): Expr_listContext | null { + return this.getRuleContext(0, Expr_listContext); + } public KW_DO(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_DO, 0); } @@ -111078,36 +84594,6 @@ export class Stmt_callContext extends antlr.ParserRuleContext { } -export class Opt_expr_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public expr_list(): Expr_listContext | null { - return this.getRuleContext(0, Expr_listContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_expr_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_expr_list) { - listener.enterOpt_expr_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_expr_list) { - listener.exitOpt_expr_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_expr_list) { - return visitor.visitOpt_expr_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Stmt_assignContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -111116,105 +84602,30 @@ export class Stmt_assignContext extends antlr.ParserRuleContext { return this.getRuleContext(0, Assign_varContext)!; } public assign_operator(): Assign_operatorContext { - return this.getRuleContext(0, Assign_operatorContext)!; - } - public sql_expression(): Sql_expressionContext { - return this.getRuleContext(0, Sql_expressionContext)!; - } - public SEMI(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.SEMI, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_assign; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_assign) { - listener.enterStmt_assign(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_assign) { - listener.exitStmt_assign(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_assign) { - return visitor.visitStmt_assign(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Stmt_getdiagContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_GET(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_GET, 0)!; - } - public getdiag_area_opt(): Getdiag_area_optContext { - return this.getRuleContext(0, Getdiag_area_optContext)!; - } - public KW_DIAGNOSTICS(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_DIAGNOSTICS, 0)!; - } - public getdiag_list(): Getdiag_listContext { - return this.getRuleContext(0, Getdiag_listContext)!; - } - public SEMI(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.SEMI, 0)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_getdiag; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_getdiag) { - listener.enterStmt_getdiag(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_getdiag) { - listener.exitStmt_getdiag(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_getdiag) { - return visitor.visitStmt_getdiag(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Getdiag_area_optContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(0, Assign_operatorContext)!; } - public KW_CURRENT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CURRENT, 0); + public sql_expression(): Sql_expressionContext { + return this.getRuleContext(0, Sql_expressionContext)!; } - public KW_STACKED(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_STACKED, 0); + public SEMI(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.SEMI, 0)!; } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_getdiag_area_opt; + return PostgreSqlParser.RULE_stmt_assign; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGetdiag_area_opt) { - listener.enterGetdiag_area_opt(this); + if(listener.enterStmt_assign) { + listener.enterStmt_assign(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGetdiag_area_opt) { - listener.exitGetdiag_area_opt(this); + if(listener.exitStmt_assign) { + listener.exitStmt_assign(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGetdiag_area_opt) { - return visitor.visitGetdiag_area_opt(this); + if (visitor.visitStmt_assign) { + return visitor.visitStmt_assign(this); } else { return visitor.visitChildren(this); } @@ -111222,10 +84633,19 @@ export class Getdiag_area_optContext extends antlr.ParserRuleContext { } -export class Getdiag_listContext extends antlr.ParserRuleContext { +export class Stmt_getdiagContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } + public KW_GET(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_GET, 0)!; + } + public KW_DIAGNOSTICS(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_DIAGNOSTICS, 0)!; + } + public SEMI(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.SEMI, 0)!; + } public getdiag_list_item(): Getdiag_list_itemContext[]; public getdiag_list_item(i: number): Getdiag_list_itemContext | null; public getdiag_list_item(i?: number): Getdiag_list_itemContext[] | Getdiag_list_itemContext | null { @@ -111235,6 +84655,12 @@ export class Getdiag_listContext extends antlr.ParserRuleContext { return this.getRuleContext(i, Getdiag_list_itemContext); } + public KW_CURRENT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CURRENT, 0); + } + public KW_STACKED(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_STACKED, 0); + } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { @@ -111245,21 +84671,21 @@ export class Getdiag_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_getdiag_list; + return PostgreSqlParser.RULE_stmt_getdiag; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGetdiag_list) { - listener.enterGetdiag_list(this); + if(listener.enterStmt_getdiag) { + listener.enterStmt_getdiag(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGetdiag_list) { - listener.exitGetdiag_list(this); + if(listener.exitStmt_getdiag) { + listener.exitStmt_getdiag(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGetdiag_list) { - return visitor.visitGetdiag_list(this); + if (visitor.visitStmt_getdiag) { + return visitor.visitStmt_getdiag(this); } else { return visitor.visitChildren(this); } @@ -111271,14 +84697,14 @@ export class Getdiag_list_itemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public getdiag_target(): Getdiag_targetContext { - return this.getRuleContext(0, Getdiag_targetContext)!; + public assign_var(): Assign_varContext { + return this.getRuleContext(0, Assign_varContext)!; } public assign_operator(): Assign_operatorContext { return this.getRuleContext(0, Assign_operatorContext)!; } - public getdiag_item(): Getdiag_itemContext { - return this.getRuleContext(0, Getdiag_itemContext)!; + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext)!; } public override get ruleIndex(): number { return PostgreSqlParser.RULE_getdiag_list_item; @@ -111303,66 +84729,6 @@ export class Getdiag_list_itemContext extends antlr.ParserRuleContext { } -export class Getdiag_itemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public colid(): ColidContext { - return this.getRuleContext(0, ColidContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_getdiag_item; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGetdiag_item) { - listener.enterGetdiag_item(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGetdiag_item) { - listener.exitGetdiag_item(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGetdiag_item) { - return visitor.visitGetdiag_item(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Getdiag_targetContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public assign_var(): Assign_varContext { - return this.getRuleContext(0, Assign_varContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_getdiag_target; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterGetdiag_target) { - listener.enterGetdiag_target(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitGetdiag_target) { - listener.exitGetdiag_target(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitGetdiag_target) { - return visitor.visitGetdiag_target(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Assign_varContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -111382,14 +84748,14 @@ export class Assign_varContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.OPEN_BRACKET, i); } } - public expr_until_rightbracket(): Expr_until_rightbracketContext[]; - public expr_until_rightbracket(i: number): Expr_until_rightbracketContext | null; - public expr_until_rightbracket(i?: number): Expr_until_rightbracketContext[] | Expr_until_rightbracketContext | null { + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(Expr_until_rightbracketContext); + return this.getRuleContexts(ExpressionContext); } - return this.getRuleContext(i, Expr_until_rightbracketContext); + return this.getRuleContext(i, ExpressionContext); } public CLOSE_BRACKET(): antlr.TerminalNode[]; public CLOSE_BRACKET(i: number): antlr.TerminalNode | null; @@ -111436,20 +84802,17 @@ export class Stmt_ifContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.KW_IF, i); } } - public expr_until_then(): Expr_until_thenContext { - return this.getRuleContext(0, Expr_until_thenContext)!; - } - public KW_THEN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_THEN, 0)!; - } - public proc_sect(): Proc_sectContext { - return this.getRuleContext(0, Proc_sectContext)!; - } - public stmt_elsifs(): Stmt_elsifsContext { - return this.getRuleContext(0, Stmt_elsifsContext)!; + public sql_expression(): Sql_expressionContext { + return this.getRuleContext(0, Sql_expressionContext)!; } - public stmt_else(): Stmt_elseContext { - return this.getRuleContext(0, Stmt_elseContext)!; + public KW_THEN(): antlr.TerminalNode[]; + public KW_THEN(i: number): antlr.TerminalNode | null; + public KW_THEN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_THEN); + } else { + return this.getToken(PostgreSqlParser.KW_THEN, i); + } } public KW_END(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_END, 0)!; @@ -111457,32 +84820,17 @@ export class Stmt_ifContext extends antlr.ParserRuleContext { public SEMI(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.SEMI, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_if; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_if) { - listener.enterStmt_if(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_if) { - listener.exitStmt_if(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_if) { - return visitor.visitStmt_if(this); - } else { - return visitor.visitChildren(this); + public proc_stmt(): Proc_stmtContext[]; + public proc_stmt(i: number): Proc_stmtContext | null; + public proc_stmt(i?: number): Proc_stmtContext[] | Proc_stmtContext | null { + if (i === undefined) { + return this.getRuleContexts(Proc_stmtContext); } - } -} - -export class Stmt_elsifsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, Proc_stmtContext); + } + public stmt_else(): Stmt_elseContext | null { + return this.getRuleContext(0, Stmt_elseContext); } public KW_ELSIF(): antlr.TerminalNode[]; public KW_ELSIF(i: number): antlr.TerminalNode | null; @@ -111493,49 +84841,31 @@ export class Stmt_elsifsContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.KW_ELSIF, i); } } - public a_expr(): A_exprContext[]; - public a_expr(i: number): A_exprContext | null; - public a_expr(i?: number): A_exprContext[] | A_exprContext | null { - if (i === undefined) { - return this.getRuleContexts(A_exprContext); - } - - return this.getRuleContext(i, A_exprContext); - } - public KW_THEN(): antlr.TerminalNode[]; - public KW_THEN(i: number): antlr.TerminalNode | null; - public KW_THEN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.KW_THEN); - } else { - return this.getToken(PostgreSqlParser.KW_THEN, i); - } - } - public proc_sect(): Proc_sectContext[]; - public proc_sect(i: number): Proc_sectContext | null; - public proc_sect(i?: number): Proc_sectContext[] | Proc_sectContext | null { + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(Proc_sectContext); + return this.getRuleContexts(ExpressionContext); } - return this.getRuleContext(i, Proc_sectContext); + return this.getRuleContext(i, ExpressionContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_elsifs; + return PostgreSqlParser.RULE_stmt_if; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_elsifs) { - listener.enterStmt_elsifs(this); + if(listener.enterStmt_if) { + listener.enterStmt_if(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_elsifs) { - listener.exitStmt_elsifs(this); + if(listener.exitStmt_if) { + listener.exitStmt_if(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_elsifs) { - return visitor.visitStmt_elsifs(this); + if (visitor.visitStmt_if) { + return visitor.visitStmt_if(this); } else { return visitor.visitChildren(this); } @@ -111547,11 +84877,17 @@ export class Stmt_elseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_ELSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ELSE, 0); + public KW_ELSE(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_ELSE, 0)!; } - public proc_sect(): Proc_sectContext | null { - return this.getRuleContext(0, Proc_sectContext); + public proc_stmt(): Proc_stmtContext[]; + public proc_stmt(i: number): Proc_stmtContext | null; + public proc_stmt(i?: number): Proc_stmtContext[] | Proc_stmtContext | null { + if (i === undefined) { + return this.getRuleContexts(Proc_stmtContext); + } + + return this.getRuleContext(i, Proc_stmtContext); } public override get ruleIndex(): number { return PostgreSqlParser.RULE_stmt_else; @@ -111589,208 +84925,70 @@ export class Stmt_caseContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.KW_CASE, i); } } - public opt_expr_until_when(): Opt_expr_until_whenContext { - return this.getRuleContext(0, Opt_expr_until_whenContext)!; - } - public case_when_list(): Case_when_listContext { - return this.getRuleContext(0, Case_when_listContext)!; - } - public opt_case_else(): Opt_case_elseContext { - return this.getRuleContext(0, Opt_case_elseContext)!; - } public KW_END(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_END, 0)!; } public SEMI(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.SEMI, 0)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_case; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_case) { - listener.enterStmt_case(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_case) { - listener.exitStmt_case(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_case) { - return visitor.visitStmt_case(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_expr_until_whenContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } public sql_expression(): Sql_expressionContext | null { return this.getRuleContext(0, Sql_expressionContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_expr_until_when; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_expr_until_when) { - listener.enterOpt_expr_until_when(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_expr_until_when) { - listener.exitOpt_expr_until_when(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_expr_until_when) { - return visitor.visitOpt_expr_until_when(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Case_when_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_WHEN(): antlr.TerminalNode[]; + public KW_WHEN(i: number): antlr.TerminalNode | null; + public KW_WHEN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_WHEN); + } else { + return this.getToken(PostgreSqlParser.KW_WHEN, i); + } } - public case_when(): Case_whenContext[]; - public case_when(i: number): Case_whenContext | null; - public case_when(i?: number): Case_whenContext[] | Case_whenContext | null { + public expr_list(): Expr_listContext[]; + public expr_list(i: number): Expr_listContext | null; + public expr_list(i?: number): Expr_listContext[] | Expr_listContext | null { if (i === undefined) { - return this.getRuleContexts(Case_whenContext); - } - - return this.getRuleContext(i, Case_whenContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_case_when_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCase_when_list) { - listener.enterCase_when_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCase_when_list) { - listener.exitCase_when_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCase_when_list) { - return visitor.visitCase_when_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Case_whenContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_WHEN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WHEN, 0)!; - } - public expr_list(): Expr_listContext { - return this.getRuleContext(0, Expr_listContext)!; - } - public KW_THEN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_THEN, 0)!; - } - public proc_sect(): Proc_sectContext { - return this.getRuleContext(0, Proc_sectContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_case_when; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterCase_when) { - listener.enterCase_when(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitCase_when) { - listener.exitCase_when(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitCase_when) { - return visitor.visitCase_when(this); - } else { - return visitor.visitChildren(this); + return this.getRuleContexts(Expr_listContext); } - } -} - -export class Opt_case_elseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ELSE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_ELSE, 0); - } - public proc_sect(): Proc_sectContext | null { - return this.getRuleContext(0, Proc_sectContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_case_else; + return this.getRuleContext(i, Expr_listContext); } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_case_else) { - listener.enterOpt_case_else(this); - } + public KW_THEN(): antlr.TerminalNode[]; + public KW_THEN(i: number): antlr.TerminalNode | null; + public KW_THEN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_THEN); + } else { + return this.getToken(PostgreSqlParser.KW_THEN, i); + } } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_case_else) { - listener.exitOpt_case_else(this); - } + public stmt_else(): Stmt_elseContext | null { + return this.getRuleContext(0, Stmt_elseContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_case_else) { - return visitor.visitOpt_case_else(this); - } else { - return visitor.visitChildren(this); + public proc_stmt(): Proc_stmtContext[]; + public proc_stmt(i: number): Proc_stmtContext | null; + public proc_stmt(i?: number): Proc_stmtContext[] | Proc_stmtContext | null { + if (i === undefined) { + return this.getRuleContexts(Proc_stmtContext); } - } -} - -export class Stmt_loopContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public opt_loop_label(): Opt_loop_labelContext { - return this.getRuleContext(0, Opt_loop_labelContext)!; - } - public loop_body(): Loop_bodyContext { - return this.getRuleContext(0, Loop_bodyContext)!; + return this.getRuleContext(i, Proc_stmtContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_loop; + return PostgreSqlParser.RULE_stmt_case; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_loop) { - listener.enterStmt_loop(this); + if(listener.enterStmt_case) { + listener.enterStmt_case(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_loop) { - listener.exitStmt_loop(this); + if(listener.exitStmt_case) { + listener.exitStmt_case(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_loop) { - return visitor.visitStmt_loop(this); + if (visitor.visitStmt_case) { + return visitor.visitStmt_case(this); } else { return visitor.visitChildren(this); } @@ -111798,77 +84996,44 @@ export class Stmt_loopContext extends antlr.ParserRuleContext { } -export class Stmt_whileContext extends antlr.ParserRuleContext { +export class Stmt_loop_while_forContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public opt_loop_label(): Opt_loop_labelContext { - return this.getRuleContext(0, Opt_loop_labelContext)!; - } - public KW_WHILE(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WHILE, 0)!; - } - public expr_until_loop(): Expr_until_loopContext { - return this.getRuleContext(0, Expr_until_loopContext)!; - } public loop_body(): Loop_bodyContext { return this.getRuleContext(0, Loop_bodyContext)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_while; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_while) { - listener.enterStmt_while(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_while) { - listener.exitStmt_while(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_while) { - return visitor.visitStmt_while(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Stmt_forContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public label_decl(): Label_declContext | null { + return this.getRuleContext(0, Label_declContext); } - public opt_loop_label(): Opt_loop_labelContext { - return this.getRuleContext(0, Opt_loop_labelContext)!; + public KW_WHILE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WHILE, 0); } - public KW_FOR(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_FOR, 0)!; + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } - public for_control(): For_controlContext { - return this.getRuleContext(0, For_controlContext)!; + public KW_FOR(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_FOR, 0); } - public loop_body(): Loop_bodyContext { - return this.getRuleContext(0, Loop_bodyContext)!; + public for_control(): For_controlContext | null { + return this.getRuleContext(0, For_controlContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_for; + return PostgreSqlParser.RULE_stmt_loop_while_for; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_for) { - listener.enterStmt_for(this); + if(listener.enterStmt_loop_while_for) { + listener.enterStmt_loop_while_for(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_for) { - listener.exitStmt_for(this); + if(listener.exitStmt_loop_while_for) { + listener.exitStmt_loop_while_for(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_for) { - return visitor.visitStmt_for(this); + if (visitor.visitStmt_loop_while_for) { + return visitor.visitStmt_loop_while_for(this); } else { return visitor.visitChildren(this); } @@ -111880,17 +85045,14 @@ export class For_controlContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public for_variable(): For_variableContext { - return this.getRuleContext(0, For_variableContext)!; + public any_name_list(): Any_name_listContext { + return this.getRuleContext(0, Any_name_listContext)!; } public KW_IN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_IN, 0)!; } - public cursor_name(): Cursor_nameContext | null { - return this.getRuleContext(0, Cursor_nameContext); - } - public opt_cursor_parameters(): Opt_cursor_parametersContext | null { - return this.getRuleContext(0, Opt_cursor_parametersContext); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } public selectstmt(): SelectstmtContext | null { return this.getRuleContext(0, SelectstmtContext); @@ -111901,53 +85063,20 @@ export class For_controlContext extends antlr.ParserRuleContext { public KW_EXECUTE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_EXECUTE, 0); } - public a_expr(): A_exprContext[]; - public a_expr(i: number): A_exprContext | null; - public a_expr(i?: number): A_exprContext[] | A_exprContext | null { + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(A_exprContext); + return this.getRuleContexts(ExpressionContext); } - return this.getRuleContext(i, A_exprContext); - } - public opt_for_using_expression(): Opt_for_using_expressionContext | null { - return this.getRuleContext(0, Opt_for_using_expressionContext); - } - public opt_reverse(): Opt_reverseContext | null { - return this.getRuleContext(0, Opt_reverseContext); + return this.getRuleContext(i, ExpressionContext); } public DOT_DOT(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.DOT_DOT, 0); } - public opt_by_expression(): Opt_by_expressionContext | null { - return this.getRuleContext(0, Opt_by_expressionContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_for_control; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFor_control) { - listener.enterFor_control(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFor_control) { - listener.exitFor_control(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFor_control) { - return visitor.visitFor_control(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_for_using_expressionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public execute_param_clause(): Execute_param_clauseContext | null { + return this.getRuleContext(0, Execute_param_clauseContext); } public KW_USING(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_USING, 0); @@ -111955,166 +85084,28 @@ export class Opt_for_using_expressionContext extends antlr.ParserRuleContext { public expr_list(): Expr_listContext | null { return this.getRuleContext(0, Expr_listContext); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_for_using_expression; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_for_using_expression) { - listener.enterOpt_for_using_expression(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_for_using_expression) { - listener.exitOpt_for_using_expression(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_for_using_expression) { - return visitor.visitOpt_for_using_expression(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_cursor_parametersContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public a_expr(): A_exprContext[]; - public a_expr(i: number): A_exprContext | null; - public a_expr(i?: number): A_exprContext[] | A_exprContext | null { - if (i === undefined) { - return this.getRuleContexts(A_exprContext); - } - - return this.getRuleContext(i, A_exprContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_cursor_parameters; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_cursor_parameters) { - listener.enterOpt_cursor_parameters(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_cursor_parameters) { - listener.exitOpt_cursor_parameters(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_cursor_parameters) { - return visitor.visitOpt_cursor_parameters(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_reverseContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } public KW_REVERSE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_REVERSE, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_reverse; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_reverse) { - listener.enterOpt_reverse(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_reverse) { - listener.exitOpt_reverse(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_reverse) { - return visitor.visitOpt_reverse(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_by_expressionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } public KW_BY(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_BY, 0); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_by_expression; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_by_expression) { - listener.enterOpt_by_expression(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_by_expression) { - listener.exitOpt_by_expression(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_by_expression) { - return visitor.visitOpt_by_expression(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class For_variableContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public any_name_list(): Any_name_listContext { - return this.getRuleContext(0, Any_name_listContext)!; - } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_for_variable; + return PostgreSqlParser.RULE_for_control; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterFor_variable) { - listener.enterFor_variable(this); + if(listener.enterFor_control) { + listener.enterFor_control(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitFor_variable) { - listener.exitFor_variable(this); + if(listener.exitFor_control) { + listener.exitFor_control(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitFor_variable) { - return visitor.visitFor_variable(this); + if (visitor.visitFor_control) { + return visitor.visitFor_control(this); } else { return visitor.visitChildren(this); } @@ -112126,17 +85117,11 @@ export class Stmt_foreach_aContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public opt_loop_label(): Opt_loop_labelContext { - return this.getRuleContext(0, Opt_loop_labelContext)!; - } public KW_FOREACH(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_FOREACH, 0)!; } - public for_variable(): For_variableContext { - return this.getRuleContext(0, For_variableContext)!; - } - public foreach_slice(): Foreach_sliceContext { - return this.getRuleContext(0, Foreach_sliceContext)!; + public any_name_list(): Any_name_listContext { + return this.getRuleContext(0, Any_name_listContext)!; } public KW_IN(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_IN, 0)!; @@ -112144,61 +85129,37 @@ export class Stmt_foreach_aContext extends antlr.ParserRuleContext { public KW_ARRAY(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_ARRAY, 0)!; } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; } public loop_body(): Loop_bodyContext { return this.getRuleContext(0, Loop_bodyContext)!; } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_foreach_a; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_foreach_a) { - listener.enterStmt_foreach_a(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_foreach_a) { - listener.exitStmt_foreach_a(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_foreach_a) { - return visitor.visitStmt_foreach_a(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Foreach_sliceContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public label_decl(): Label_declContext | null { + return this.getRuleContext(0, Label_declContext); } public KW_SLICE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_SLICE, 0); } - public iconst(): IconstContext | null { - return this.getRuleContext(0, IconstContext); + public Integral(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.Integral, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_foreach_slice; + return PostgreSqlParser.RULE_stmt_foreach_a; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterForeach_slice) { - listener.enterForeach_slice(this); + if(listener.enterStmt_foreach_a) { + listener.enterStmt_foreach_a(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitForeach_slice) { - listener.exitForeach_slice(this); + if(listener.exitStmt_foreach_a) { + listener.exitStmt_foreach_a(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitForeach_slice) { - return visitor.visitForeach_slice(this); + if (visitor.visitStmt_foreach_a) { + return visitor.visitStmt_foreach_a(this); } else { return visitor.visitChildren(this); } @@ -112210,17 +85171,23 @@ export class Stmt_exitContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public exit_type(): Exit_typeContext { - return this.getRuleContext(0, Exit_typeContext)!; - } - public opt_label(): Opt_labelContext { - return this.getRuleContext(0, Opt_labelContext)!; - } public SEMI(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.SEMI, 0)!; } - public opt_exitcond(): Opt_exitcondContext | null { - return this.getRuleContext(0, Opt_exitcondContext); + public KW_EXIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_EXIT, 0); + } + public KW_CONTINUE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CONTINUE, 0); + } + public any_identifier(): Any_identifierContext | null { + return this.getRuleContext(0, Any_identifierContext); + } + public KW_WHEN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_WHEN, 0); + } + public sql_expression(): Sql_expressionContext | null { + return this.getRuleContext(0, Sql_expressionContext); } public override get ruleIndex(): number { return PostgreSqlParser.RULE_stmt_exit; @@ -112245,39 +85212,6 @@ export class Stmt_exitContext extends antlr.ParserRuleContext { } -export class Exit_typeContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_EXIT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXIT, 0); - } - public KW_CONTINUE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_CONTINUE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_exit_type; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExit_type) { - listener.enterExit_type(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExit_type) { - listener.exitExit_type(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExit_type) { - return visitor.visitExit_type(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Stmt_returnContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -112297,17 +85231,17 @@ export class Stmt_returnContext extends antlr.ParserRuleContext { public KW_QUERY(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_QUERY, 0); } - public opt_return_result(): Opt_return_resultContext | null { - return this.getRuleContext(0, Opt_return_resultContext); - } public KW_EXECUTE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_EXECUTE, 0); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USING, 0); } - public opt_for_using_expression(): Opt_for_using_expressionContext | null { - return this.getRuleContext(0, Opt_for_using_expressionContext); + public expr_list(): Expr_listContext | null { + return this.getRuleContext(0, Expr_listContext); } public selectstmt(): SelectstmtContext | null { return this.getRuleContext(0, SelectstmtContext); @@ -112335,36 +85269,6 @@ export class Stmt_returnContext extends antlr.ParserRuleContext { } -export class Opt_return_resultContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public sql_expression(): Sql_expressionContext | null { - return this.getRuleContext(0, Sql_expressionContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_return_result; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_return_result) { - listener.enterOpt_return_result(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_return_result) { - listener.exitOpt_return_result(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_return_result) { - return visitor.visitOpt_return_result(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Stmt_raiseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -112372,53 +85276,14 @@ export class Stmt_raiseContext extends antlr.ParserRuleContext { public KW_RAISE(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_RAISE, 0)!; } - public sconst(): SconstContext | null { - return this.getRuleContext(0, SconstContext); - } - public opt_raise_list(): Opt_raise_listContext | null { - return this.getRuleContext(0, Opt_raise_listContext); - } - public opt_raise_using(): Opt_raise_usingContext | null { - return this.getRuleContext(0, Opt_raise_usingContext); - } public SEMI(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.SEMI, 0); } - public opt_stmt_raise_level(): Opt_stmt_raise_levelContext | null { - return this.getRuleContext(0, Opt_stmt_raise_levelContext); - } public identifier(): IdentifierContext | null { return this.getRuleContext(0, IdentifierContext); } - public KW_SQLSTATE(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SQLSTATE, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_raise; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_raise) { - listener.enterStmt_raise(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_raise) { - listener.exitStmt_raise(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_raise) { - return visitor.visitStmt_raise(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_stmt_raise_levelContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USING, 0); } public KW_DEBUG(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_DEBUG, 0); @@ -112438,32 +85303,20 @@ export class Opt_stmt_raise_levelContext extends antlr.ParserRuleContext { public KW_EXCEPTION(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_EXCEPTION, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_stmt_raise_level; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_stmt_raise_level) { - listener.enterOpt_stmt_raise_level(this); - } + public KW_SQLSTATE(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SQLSTATE, 0); } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_stmt_raise_level) { - listener.exitOpt_stmt_raise_level(this); - } + public sconst(): SconstContext | null { + return this.getRuleContext(0, SconstContext); } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_stmt_raise_level) { - return visitor.visitOpt_stmt_raise_level(this); - } else { - return visitor.visitChildren(this); + public opt_raise_using_elem(): Opt_raise_using_elemContext[]; + public opt_raise_using_elem(i: number): Opt_raise_using_elemContext | null; + public opt_raise_using_elem(i?: number): Opt_raise_using_elemContext[] | Opt_raise_using_elemContext | null { + if (i === undefined) { + return this.getRuleContexts(Opt_raise_using_elemContext); } - } -} - -export class Opt_raise_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + return this.getRuleContext(i, Opt_raise_using_elemContext); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -112474,64 +85327,31 @@ export class Opt_raise_listContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.COMMA, i); } } - public a_expr(): A_exprContext[]; - public a_expr(i: number): A_exprContext | null; - public a_expr(i?: number): A_exprContext[] | A_exprContext | null { + public expression(): ExpressionContext[]; + public expression(i: number): ExpressionContext | null; + public expression(i?: number): ExpressionContext[] | ExpressionContext | null { if (i === undefined) { - return this.getRuleContexts(A_exprContext); - } - - return this.getRuleContext(i, A_exprContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_raise_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_raise_list) { - listener.enterOpt_raise_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_raise_list) { - listener.exitOpt_raise_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_raise_list) { - return visitor.visitOpt_raise_list(this); - } else { - return visitor.visitChildren(this); + return this.getRuleContexts(ExpressionContext); } - } -} - -export class Opt_raise_usingContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); - } - public opt_raise_using_elem_list(): Opt_raise_using_elem_listContext | null { - return this.getRuleContext(0, Opt_raise_using_elem_listContext); + return this.getRuleContext(i, ExpressionContext); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_raise_using; + return PostgreSqlParser.RULE_stmt_raise; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_raise_using) { - listener.enterOpt_raise_using(this); + if(listener.enterStmt_raise) { + listener.enterStmt_raise(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_raise_using) { - listener.exitOpt_raise_using(this); + if(listener.exitStmt_raise) { + listener.exitStmt_raise(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_raise_using) { - return visitor.visitOpt_raise_using(this); + if (visitor.visitStmt_raise) { + return visitor.visitStmt_raise(this); } else { return visitor.visitChildren(this); } @@ -112549,8 +85369,8 @@ export class Opt_raise_using_elemContext extends antlr.ParserRuleContext { public EQUAL(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.EQUAL, 0)!; } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; } public override get ruleIndex(): number { return PostgreSqlParser.RULE_opt_raise_using_elem; @@ -112575,51 +85395,6 @@ export class Opt_raise_using_elemContext extends antlr.ParserRuleContext { } -export class Opt_raise_using_elem_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public opt_raise_using_elem(): Opt_raise_using_elemContext[]; - public opt_raise_using_elem(i: number): Opt_raise_using_elemContext | null; - public opt_raise_using_elem(i?: number): Opt_raise_using_elemContext[] | Opt_raise_using_elemContext | null { - if (i === undefined) { - return this.getRuleContexts(Opt_raise_using_elemContext); - } - - return this.getRuleContext(i, Opt_raise_using_elemContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_raise_using_elem_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_raise_using_elem_list) { - listener.enterOpt_raise_using_elem_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_raise_using_elem_list) { - listener.exitOpt_raise_using_elem_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_raise_using_elem_list) { - return visitor.visitOpt_raise_using_elem_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Stmt_assertContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -112627,15 +85402,21 @@ export class Stmt_assertContext extends antlr.ParserRuleContext { public KW_ASSERT(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_ASSERT, 0)!; } - public sql_expression(): Sql_expressionContext { - return this.getRuleContext(0, Sql_expressionContext)!; - } - public opt_stmt_assert_message(): Opt_stmt_assert_messageContext { - return this.getRuleContext(0, Opt_stmt_assert_messageContext)!; + public sql_expression(): Sql_expressionContext[]; + public sql_expression(i: number): Sql_expressionContext | null; + public sql_expression(i?: number): Sql_expressionContext[] | Sql_expressionContext | null { + if (i === undefined) { + return this.getRuleContexts(Sql_expressionContext); + } + + return this.getRuleContext(i, Sql_expressionContext); } public SEMI(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.SEMI, 0)!; } + public COMMA(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.COMMA, 0); + } public override get ruleIndex(): number { return PostgreSqlParser.RULE_stmt_assert; } @@ -112659,39 +85440,6 @@ export class Stmt_assertContext extends antlr.ParserRuleContext { } -export class Opt_stmt_assert_messageContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public COMMA(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.COMMA, 0); - } - public sql_expression(): Sql_expressionContext | null { - return this.getRuleContext(0, Sql_expressionContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_stmt_assert_message; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_stmt_assert_message) { - listener.enterOpt_stmt_assert_message(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_stmt_assert_message) { - listener.exitOpt_stmt_assert_message(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_stmt_assert_message) { - return visitor.visitOpt_stmt_assert_message(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Loop_bodyContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -112705,18 +85453,24 @@ export class Loop_bodyContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.KW_LOOP, i); } } - public proc_sect(): Proc_sectContext { - return this.getRuleContext(0, Proc_sectContext)!; - } public KW_END(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_END, 0)!; } - public opt_label(): Opt_labelContext { - return this.getRuleContext(0, Opt_labelContext)!; - } public SEMI(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.SEMI, 0)!; } + public proc_stmt(): Proc_stmtContext[]; + public proc_stmt(i: number): Proc_stmtContext | null; + public proc_stmt(i?: number): Proc_stmtContext[] | Proc_stmtContext | null { + if (i === undefined) { + return this.getRuleContexts(Proc_stmtContext); + } + + return this.getRuleContext(i, Proc_stmtContext); + } + public any_identifier(): Any_identifierContext | null { + return this.getRuleContext(0, Any_identifierContext); + } public override get ruleIndex(): number { return PostgreSqlParser.RULE_loop_body; } @@ -112744,12 +85498,15 @@ export class Stmt_execsqlContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public make_execsql_stmt(): Make_execsql_stmtContext { - return this.getRuleContext(0, Make_execsql_stmtContext)!; + public stmt(): StmtContext { + return this.getRuleContext(0, StmtContext)!; } public SEMI(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.SEMI, 0)!; } + public opt_execute_into(): Opt_execute_intoContext | null { + return this.getRuleContext(0, Opt_execute_intoContext); + } public override get ruleIndex(): number { return PostgreSqlParser.RULE_stmt_execsql; } @@ -112780,8 +85537,8 @@ export class Stmt_dynexecuteContext extends antlr.ParserRuleContext { public KW_EXECUTE(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_EXECUTE, 0)!; } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; } public SEMI(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.SEMI, 0)!; @@ -112789,8 +85546,11 @@ export class Stmt_dynexecuteContext extends antlr.ParserRuleContext { public opt_execute_into(): Opt_execute_intoContext | null { return this.getRuleContext(0, Opt_execute_intoContext); } - public opt_execute_using(): Opt_execute_usingContext | null { - return this.getRuleContext(0, Opt_execute_usingContext); + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USING, 0); + } + public expr_list(): Expr_listContext | null { + return this.getRuleContext(0, Expr_listContext); } public override get ruleIndex(): number { return PostgreSqlParser.RULE_stmt_dynexecute; @@ -112815,93 +85575,15 @@ export class Stmt_dynexecuteContext extends antlr.ParserRuleContext { } -export class Opt_execute_usingContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); - } - public opt_execute_using_list(): Opt_execute_using_listContext | null { - return this.getRuleContext(0, Opt_execute_using_listContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_execute_using; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_execute_using) { - listener.enterOpt_execute_using(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_execute_using) { - listener.exitOpt_execute_using(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_execute_using) { - return visitor.visitOpt_execute_using(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_execute_using_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public a_expr(): A_exprContext[]; - public a_expr(i: number): A_exprContext | null; - public a_expr(i?: number): A_exprContext[] | A_exprContext | null { - if (i === undefined) { - return this.getRuleContexts(A_exprContext); - } - - return this.getRuleContext(i, A_exprContext); - } - public COMMA(): antlr.TerminalNode[]; - public COMMA(i: number): antlr.TerminalNode | null; - public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { - if (i === undefined) { - return this.getTokens(PostgreSqlParser.COMMA); - } else { - return this.getToken(PostgreSqlParser.COMMA, i); - } - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_execute_using_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_execute_using_list) { - listener.enterOpt_execute_using_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_execute_using_list) { - listener.exitOpt_execute_using_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_execute_using_list) { - return visitor.visitOpt_execute_using_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Opt_execute_intoContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_INTO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_INTO, 0); + public KW_INTO(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_INTO, 0)!; } - public into_target(): Into_targetContext | null { - return this.getRuleContext(0, Into_targetContext); + public expr_list(): Expr_listContext { + return this.getRuleContext(0, Expr_listContext)!; } public KW_STRICT(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_STRICT, 0); @@ -112942,9 +85624,6 @@ export class Stmt_openContext extends antlr.ParserRuleContext { public cursor_variable(): Cursor_variableContext | null { return this.getRuleContext(0, Cursor_variableContext); } - public opt_scroll_option(): Opt_scroll_optionContext | null { - return this.getRuleContext(0, Opt_scroll_optionContext); - } public KW_FOR(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_FOR, 0); } @@ -112960,80 +85639,20 @@ export class Stmt_openContext extends antlr.ParserRuleContext { public sql_expression(): Sql_expressionContext | null { return this.getRuleContext(0, Sql_expressionContext); } - public opt_open_using(): Opt_open_usingContext | null { - return this.getRuleContext(0, Opt_open_usingContext); + public KW_SCROLL(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_SCROLL, 0); } public OPEN_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } - public opt_open_bound_list(): Opt_open_bound_listContext | null { - return this.getRuleContext(0, Opt_open_bound_listContext); - } public CLOSE_PAREN(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_open; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_open) { - listener.enterStmt_open(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_open) { - listener.exitStmt_open(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_open) { - return visitor.visitStmt_open(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_open_bound_list_itemContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public colid(): ColidContext | null { - return this.getRuleContext(0, ColidContext); - } - public COLON_EQUALS(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.COLON_EQUALS, 0); - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_open_bound_list_item; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_open_bound_list_item) { - listener.enterOpt_open_bound_list_item(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_open_bound_list_item) { - listener.exitOpt_open_bound_list_item(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_open_bound_list_item) { - return visitor.visitOpt_open_bound_list_item(this); - } else { - return visitor.visitChildren(this); - } + public KW_USING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_USING, 0); } -} - - -export class Opt_open_bound_listContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public expr_list(): Expr_listContext | null { + return this.getRuleContext(0, Expr_listContext); } public opt_open_bound_list_item(): Opt_open_bound_list_itemContext[]; public opt_open_bound_list_item(i: number): Opt_open_bound_list_itemContext | null; @@ -113044,6 +85663,9 @@ export class Opt_open_bound_listContext extends antlr.ParserRuleContext { return this.getRuleContext(i, Opt_open_bound_list_itemContext); } + public KW_NO(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_NO, 0); + } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { @@ -113054,54 +85676,21 @@ export class Opt_open_bound_listContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_open_bound_list; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_open_bound_list) { - listener.enterOpt_open_bound_list(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_open_bound_list) { - listener.exitOpt_open_bound_list(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_open_bound_list) { - return visitor.visitOpt_open_bound_list(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_open_usingContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_USING(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_USING, 0); - } - public expr_list(): Expr_listContext | null { - return this.getRuleContext(0, Expr_listContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_open_using; + return PostgreSqlParser.RULE_stmt_open; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_open_using) { - listener.enterOpt_open_using(this); + if(listener.enterStmt_open) { + listener.enterStmt_open(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_open_using) { - listener.exitOpt_open_using(this); + if(listener.exitStmt_open) { + listener.exitStmt_open(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_open_using) { - return visitor.visitOpt_open_using(this); + if (visitor.visitStmt_open) { + return visitor.visitStmt_open(this); } else { return visitor.visitChildren(this); } @@ -113109,62 +85698,35 @@ export class Opt_open_usingContext extends antlr.ParserRuleContext { } -export class Opt_scroll_optionContext extends antlr.ParserRuleContext { +export class Opt_open_bound_list_itemContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public opt_scroll_option_no(): Opt_scroll_option_noContext | null { - return this.getRuleContext(0, Opt_scroll_option_noContext); - } - public KW_SCROLL(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_SCROLL, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_scroll_option; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_scroll_option) { - listener.enterOpt_scroll_option(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_scroll_option) { - listener.exitOpt_scroll_option(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_scroll_option) { - return visitor.visitOpt_scroll_option(this); - } else { - return visitor.visitChildren(this); - } + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; } -} - - -export class Opt_scroll_option_noContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public colid(): ColidContext | null { + return this.getRuleContext(0, ColidContext); } - public KW_NO(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_NO, 0); + public COLON_EQUALS(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.COLON_EQUALS, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_scroll_option_no; + return PostgreSqlParser.RULE_opt_open_bound_list_item; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_scroll_option_no) { - listener.enterOpt_scroll_option_no(this); + if(listener.enterOpt_open_bound_list_item) { + listener.enterOpt_open_bound_list_item(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_scroll_option_no) { - listener.exitOpt_scroll_option_no(this); + if(listener.exitOpt_open_bound_list_item) { + listener.exitOpt_open_bound_list_item(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_scroll_option_no) { - return visitor.visitOpt_scroll_option_no(this); + if (visitor.visitOpt_open_bound_list_item) { + return visitor.visitOpt_open_bound_list_item(this); } else { return visitor.visitChildren(this); } @@ -113180,21 +85742,21 @@ export class Stmt_fetchContext extends antlr.ParserRuleContext { public KW_FETCH(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_FETCH, 0)!; } - public opt_cursor_from(): Opt_cursor_fromContext { - return this.getRuleContext(0, Opt_cursor_fromContext)!; - } public cursor_variable(): Cursor_variableContext { return this.getRuleContext(0, Cursor_variableContext)!; } public KW_INTO(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_INTO, 0)!; } - public into_target(): Into_targetContext { - return this.getRuleContext(0, Into_targetContext)!; + public expr_list(): Expr_listContext { + return this.getRuleContext(0, Expr_listContext)!; } public SEMI(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.SEMI, 0)!; } + public from_in(): From_inContext | null { + return this.getRuleContext(0, From_inContext); + } public opt_fetch_direction(): Opt_fetch_directionContext | null { return this.getRuleContext(0, Opt_fetch_directionContext); } @@ -113221,69 +85783,6 @@ export class Stmt_fetchContext extends antlr.ParserRuleContext { } -export class Into_targetContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public expr_list(): Expr_listContext { - return this.getRuleContext(0, Expr_listContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_into_target; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterInto_target) { - listener.enterInto_target(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitInto_target) { - listener.exitInto_target(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitInto_target) { - return visitor.visitInto_target(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_cursor_fromContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_FROM(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_FROM, 0); - } - public KW_IN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_IN, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_cursor_from; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_cursor_from) { - listener.enterOpt_cursor_from(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_cursor_from) { - listener.exitOpt_cursor_from(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_cursor_from) { - return visitor.visitOpt_cursor_from(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Opt_fetch_directionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -113300,12 +85799,12 @@ export class Opt_fetch_directionContext extends antlr.ParserRuleContext { public KW_LAST(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_LAST, 0); } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); + } public KW_ABSOLUTE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_ABSOLUTE, 0); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); - } public KW_RELATIVE(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_RELATIVE, 0); } @@ -113402,8 +85901,8 @@ export class MergestmtContext extends antlr.ParserRuleContext { public KW_ON(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_ON, 0)!; } - public join_condition(): Join_conditionContext { - return this.getRuleContext(0, Join_conditionContext)!; + public expression(): ExpressionContext { + return this.getRuleContext(0, ExpressionContext)!; } public with_clause(): With_clauseContext | null { return this.getRuleContext(0, With_clauseContext); @@ -113500,36 +85999,6 @@ export class Data_sourceContext extends antlr.ParserRuleContext { } -export class Join_conditionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_join_condition; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterJoin_condition) { - listener.enterJoin_condition(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitJoin_condition) { - listener.exitJoin_condition(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitJoin_condition) { - return visitor.visitJoin_condition(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Merge_when_clauseContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -113558,8 +86027,8 @@ export class Merge_when_clauseContext extends antlr.ParserRuleContext { public KW_AND(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_AND, 0); } - public a_expr(): A_exprContext | null { - return this.getRuleContext(0, A_exprContext); + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } public KW_NOT(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_NOT, 0); @@ -113600,14 +86069,8 @@ export class Merge_insertContext extends antlr.ParserRuleContext { public default_values_or_values(): Default_values_or_valuesContext { return this.getRuleContext(0, Default_values_or_valuesContext)!; } - public OPEN_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); - } - public column_list(): Column_listContext | null { - return this.getRuleContext(0, Column_listContext); - } - public CLOSE_PAREN(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); + public opt_column_list(): Opt_column_listContext | null { + return this.getRuleContext(0, Opt_column_listContext); } public KW_OVERRIDING(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_OVERRIDING, 0); @@ -113681,6 +86144,15 @@ export class Merge_updateContext extends antlr.ParserRuleContext { return this.getRuleContext(i, ExprofdefaultContext); } + public opt_column_list(): Opt_column_listContext[]; + public opt_column_list(i: number): Opt_column_listContext | null; + public opt_column_list(i?: number): Opt_column_listContext[] | Opt_column_listContext | null { + if (i === undefined) { + return this.getRuleContexts(Opt_column_listContext); + } + + return this.getRuleContext(i, Opt_column_listContext); + } public OPEN_PAREN(): antlr.TerminalNode[]; public OPEN_PAREN(i: number): antlr.TerminalNode | null; public OPEN_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { @@ -113690,15 +86162,6 @@ export class Merge_updateContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.OPEN_PAREN, i); } } - public column_list(): Column_listContext[]; - public column_list(i: number): Column_listContext | null; - public column_list(i?: number): Column_listContext[] | Column_listContext | null { - if (i === undefined) { - return this.getRuleContexts(Column_listContext); - } - - return this.getRuleContext(i, Column_listContext); - } public CLOSE_PAREN(): antlr.TerminalNode[]; public CLOSE_PAREN(i: number): antlr.TerminalNode | null; public CLOSE_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { @@ -113708,14 +86171,14 @@ export class Merge_updateContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.CLOSE_PAREN, i); } } - public exprofdefaultlist(): ExprofdefaultlistContext[]; - public exprofdefaultlist(i: number): ExprofdefaultlistContext | null; - public exprofdefaultlist(i?: number): ExprofdefaultlistContext[] | ExprofdefaultlistContext | null { - if (i === undefined) { - return this.getRuleContexts(ExprofdefaultlistContext); - } - - return this.getRuleContext(i, ExprofdefaultlistContext); + public COMMA(): antlr.TerminalNode[]; + public COMMA(i: number): antlr.TerminalNode | null; + public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.COMMA); + } else { + return this.getToken(PostgreSqlParser.COMMA, i); + } } public override get ruleIndex(): number { return PostgreSqlParser.RULE_merge_update; @@ -113747,41 +86210,8 @@ export class Default_values_or_valuesContext extends antlr.ParserRuleContext { public KW_VALUES(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.KW_VALUES, 0)!; } - public exprofdefaultlist(): ExprofdefaultlistContext | null { - return this.getRuleContext(0, ExprofdefaultlistContext); - } - public KW_DEFAULT(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_default_values_or_values; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterDefault_values_or_values) { - listener.enterDefault_values_or_values(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitDefault_values_or_values) { - listener.exitDefault_values_or_values(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitDefault_values_or_values) { - return visitor.visitDefault_values_or_values(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class ExprofdefaultlistContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public OPEN_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.OPEN_PAREN, 0)!; + public OPEN_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.OPEN_PAREN, 0); } public exprofdefault(): ExprofdefaultContext[]; public exprofdefault(i: number): ExprofdefaultContext | null; @@ -113792,8 +86222,8 @@ export class ExprofdefaultlistContext extends antlr.ParserRuleContext { return this.getRuleContext(i, ExprofdefaultContext); } - public CLOSE_PAREN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0)!; + public CLOSE_PAREN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.CLOSE_PAREN, 0); } public COMMA(): antlr.TerminalNode[]; public COMMA(i: number): antlr.TerminalNode | null; @@ -113804,22 +86234,25 @@ export class ExprofdefaultlistContext extends antlr.ParserRuleContext { return this.getToken(PostgreSqlParser.COMMA, i); } } + public KW_DEFAULT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_DEFAULT, 0); + } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_exprofdefaultlist; + return PostgreSqlParser.RULE_default_values_or_values; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExprofdefaultlist) { - listener.enterExprofdefaultlist(this); + if(listener.enterDefault_values_or_values) { + listener.enterDefault_values_or_values(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExprofdefaultlist) { - listener.exitExprofdefaultlist(this); + if(listener.exitDefault_values_or_values) { + listener.exitDefault_values_or_values(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExprofdefaultlist) { - return visitor.visitExprofdefaultlist(this); + if (visitor.visitDefault_values_or_values) { + return visitor.visitDefault_values_or_values(this); } else { return visitor.visitChildren(this); } @@ -113929,107 +86362,44 @@ export class Stmt_nullContext extends antlr.ParserRuleContext { } -export class Stmt_commitContext extends antlr.ParserRuleContext { +export class Stmt_commit_or_rollbackContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_COMMIT(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_COMMIT, 0)!; - } public SEMI(): antlr.TerminalNode { return this.getToken(PostgreSqlParser.SEMI, 0)!; } - public plsql_opt_transaction_chain(): Plsql_opt_transaction_chainContext | null { - return this.getRuleContext(0, Plsql_opt_transaction_chainContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_commit; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_commit) { - listener.enterStmt_commit(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_commit) { - listener.exitStmt_commit(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_commit) { - return visitor.visitStmt_commit(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Stmt_rollbackContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_ROLLBACK(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_ROLLBACK, 0)!; - } - public SEMI(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.SEMI, 0)!; - } - public plsql_opt_transaction_chain(): Plsql_opt_transaction_chainContext | null { - return this.getRuleContext(0, Plsql_opt_transaction_chainContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_stmt_rollback; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterStmt_rollback) { - listener.enterStmt_rollback(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitStmt_rollback) { - listener.exitStmt_rollback(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitStmt_rollback) { - return visitor.visitStmt_rollback(this); - } else { - return visitor.visitChildren(this); - } + public KW_COMMIT(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_COMMIT, 0); } -} - - -export class Plsql_opt_transaction_chainContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_ROLLBACK(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_ROLLBACK, 0); } - public KW_AND(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_AND, 0)!; + public KW_AND(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_AND, 0); } - public KW_CHAIN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_CHAIN, 0)!; + public KW_CHAIN(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_CHAIN, 0); } public KW_NO(): antlr.TerminalNode | null { return this.getToken(PostgreSqlParser.KW_NO, 0); } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_plsql_opt_transaction_chain; + return PostgreSqlParser.RULE_stmt_commit_or_rollback; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterPlsql_opt_transaction_chain) { - listener.enterPlsql_opt_transaction_chain(this); + if(listener.enterStmt_commit_or_rollback) { + listener.enterStmt_commit_or_rollback(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitPlsql_opt_transaction_chain) { - listener.exitPlsql_opt_transaction_chain(this); + if(listener.exitStmt_commit_or_rollback) { + listener.exitStmt_commit_or_rollback(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitPlsql_opt_transaction_chain) { - return visitor.visitPlsql_opt_transaction_chain(this); + if (visitor.visitStmt_commit_or_rollback) { + return visitor.visitStmt_commit_or_rollback(this); } else { return visitor.visitChildren(this); } @@ -114122,113 +86492,26 @@ export class Exception_sectContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public KW_EXCEPTION(): antlr.TerminalNode | null { - return this.getToken(PostgreSqlParser.KW_EXCEPTION, 0); - } - public proc_exceptions(): Proc_exceptionsContext | null { - return this.getRuleContext(0, Proc_exceptionsContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_exception_sect; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterException_sect) { - listener.enterException_sect(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitException_sect) { - listener.exitException_sect(this); - } + public KW_EXCEPTION(): antlr.TerminalNode { + return this.getToken(PostgreSqlParser.KW_EXCEPTION, 0)!; } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitException_sect) { - return visitor.visitException_sect(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Proc_exceptionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public proc_exception(): Proc_exceptionContext[]; - public proc_exception(i: number): Proc_exceptionContext | null; - public proc_exception(i?: number): Proc_exceptionContext[] | Proc_exceptionContext | null { - if (i === undefined) { - return this.getRuleContexts(Proc_exceptionContext); - } - - return this.getRuleContext(i, Proc_exceptionContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_proc_exceptions; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterProc_exceptions) { - listener.enterProc_exceptions(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitProc_exceptions) { - listener.exitProc_exceptions(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitProc_exceptions) { - return visitor.visitProc_exceptions(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Proc_exceptionContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_WHEN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WHEN, 0)!; - } - public proc_conditions(): Proc_conditionsContext { - return this.getRuleContext(0, Proc_conditionsContext)!; - } - public KW_THEN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_THEN, 0)!; - } - public proc_sect(): Proc_sectContext { - return this.getRuleContext(0, Proc_sectContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_proc_exception; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterProc_exception) { - listener.enterProc_exception(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitProc_exception) { - listener.exitProc_exception(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitProc_exception) { - return visitor.visitProc_exception(this); - } else { - return visitor.visitChildren(this); - } + public KW_WHEN(): antlr.TerminalNode[]; + public KW_WHEN(i: number): antlr.TerminalNode | null; + public KW_WHEN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_WHEN); + } else { + return this.getToken(PostgreSqlParser.KW_WHEN, i); + } } -} - - -export class Proc_conditionsContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); + public KW_THEN(): antlr.TerminalNode[]; + public KW_THEN(i: number): antlr.TerminalNode | null; + public KW_THEN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSqlParser.KW_THEN); + } else { + return this.getToken(PostgreSqlParser.KW_THEN, i); + } } public proc_condition(): Proc_conditionContext[]; public proc_condition(i: number): Proc_conditionContext | null; @@ -114239,6 +86522,15 @@ export class Proc_conditionsContext extends antlr.ParserRuleContext { return this.getRuleContext(i, Proc_conditionContext); } + public proc_stmt(): Proc_stmtContext[]; + public proc_stmt(i: number): Proc_stmtContext | null; + public proc_stmt(i?: number): Proc_stmtContext[] | Proc_stmtContext | null { + if (i === undefined) { + return this.getRuleContexts(Proc_stmtContext); + } + + return this.getRuleContext(i, Proc_stmtContext); + } public KW_OR(): antlr.TerminalNode[]; public KW_OR(i: number): antlr.TerminalNode | null; public KW_OR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] { @@ -114249,21 +86541,21 @@ export class Proc_conditionsContext extends antlr.ParserRuleContext { } } public override get ruleIndex(): number { - return PostgreSqlParser.RULE_proc_conditions; + return PostgreSqlParser.RULE_exception_sect; } public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterProc_conditions) { - listener.enterProc_conditions(this); + if(listener.enterException_sect) { + listener.enterException_sect(this); } } public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitProc_conditions) { - listener.exitProc_conditions(this); + if(listener.exitException_sect) { + listener.exitException_sect(this); } } public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitProc_conditions) { - return visitor.visitProc_conditions(this); + if (visitor.visitException_sect) { + return visitor.visitException_sect(this); } else { return visitor.visitChildren(this); } @@ -114307,129 +86599,6 @@ export class Proc_conditionContext extends antlr.ParserRuleContext { } -export class Opt_block_labelContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public label_decl(): Label_declContext | null { - return this.getRuleContext(0, Label_declContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_block_label; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_block_label) { - listener.enterOpt_block_label(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_block_label) { - listener.exitOpt_block_label(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_block_label) { - return visitor.visitOpt_block_label(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_loop_labelContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public label_decl(): Label_declContext | null { - return this.getRuleContext(0, Label_declContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_loop_label; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_loop_label) { - listener.enterOpt_loop_label(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_loop_label) { - listener.exitOpt_loop_label(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_loop_label) { - return visitor.visitOpt_loop_label(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_labelContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public any_identifier(): Any_identifierContext | null { - return this.getRuleContext(0, Any_identifierContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_label; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_label) { - listener.enterOpt_label(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_label) { - listener.exitOpt_label(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_label) { - return visitor.visitOpt_label(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_exitcondContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_WHEN(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_WHEN, 0)!; - } - public expr_until_semi(): Expr_until_semiContext { - return this.getRuleContext(0, Expr_until_semiContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_exitcond; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_exitcond) { - listener.enterOpt_exitcond(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_exitcond) { - listener.exitOpt_exitcond(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_exitcond) { - return visitor.visitOpt_exitcond(this); - } else { - return visitor.visitChildren(this); - } - } -} - - export class Any_identifierContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); @@ -114683,8 +86852,8 @@ export class Sql_expressionContext extends antlr.ParserRuleContext { public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { super(parent, invokingState); } - public opt_target_list(): Opt_target_listContext | null { - return this.getRuleContext(0, Opt_target_listContext); + public target_list(): Target_listContext | null { + return this.getRuleContext(0, Target_listContext); } public into_clause(): Into_clauseContext | null { return this.getRuleContext(0, Into_clauseContext); @@ -114698,8 +86867,11 @@ export class Sql_expressionContext extends antlr.ParserRuleContext { public group_clause(): Group_clauseContext | null { return this.getRuleContext(0, Group_clauseContext); } - public having_clause(): Having_clauseContext | null { - return this.getRuleContext(0, Having_clauseContext); + public KW_HAVING(): antlr.TerminalNode | null { + return this.getToken(PostgreSqlParser.KW_HAVING, 0); + } + public expression(): ExpressionContext | null { + return this.getRuleContext(0, ExpressionContext); } public window_clause(): Window_clauseContext | null { return this.getRuleContext(0, Window_clauseContext); @@ -114725,192 +86897,3 @@ export class Sql_expressionContext extends antlr.ParserRuleContext { } } } - - -export class Expr_until_thenContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public sql_expression(): Sql_expressionContext { - return this.getRuleContext(0, Sql_expressionContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_expr_until_then; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExpr_until_then) { - listener.enterExpr_until_then(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExpr_until_then) { - listener.exitExpr_until_then(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExpr_until_then) { - return visitor.visitExpr_until_then(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Expr_until_semiContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public sql_expression(): Sql_expressionContext { - return this.getRuleContext(0, Sql_expressionContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_expr_until_semi; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExpr_until_semi) { - listener.enterExpr_until_semi(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExpr_until_semi) { - listener.exitExpr_until_semi(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExpr_until_semi) { - return visitor.visitExpr_until_semi(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Expr_until_rightbracketContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_expr_until_rightbracket; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExpr_until_rightbracket) { - listener.enterExpr_until_rightbracket(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExpr_until_rightbracket) { - listener.exitExpr_until_rightbracket(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExpr_until_rightbracket) { - return visitor.visitExpr_until_rightbracket(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Expr_until_loopContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public a_expr(): A_exprContext { - return this.getRuleContext(0, A_exprContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_expr_until_loop; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterExpr_until_loop) { - listener.enterExpr_until_loop(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitExpr_until_loop) { - listener.exitExpr_until_loop(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitExpr_until_loop) { - return visitor.visitExpr_until_loop(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Make_execsql_stmtContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public stmt(): StmtContext { - return this.getRuleContext(0, StmtContext)!; - } - public opt_returning_clause_into(): Opt_returning_clause_intoContext | null { - return this.getRuleContext(0, Opt_returning_clause_intoContext); - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_make_execsql_stmt; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterMake_execsql_stmt) { - listener.enterMake_execsql_stmt(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitMake_execsql_stmt) { - listener.exitMake_execsql_stmt(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitMake_execsql_stmt) { - return visitor.visitMake_execsql_stmt(this); - } else { - return visitor.visitChildren(this); - } - } -} - - -export class Opt_returning_clause_intoContext extends antlr.ParserRuleContext { - public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) { - super(parent, invokingState); - } - public KW_INTO(): antlr.TerminalNode { - return this.getToken(PostgreSqlParser.KW_INTO, 0)!; - } - public opt_strict(): Opt_strictContext { - return this.getRuleContext(0, Opt_strictContext)!; - } - public into_target(): Into_targetContext { - return this.getRuleContext(0, Into_targetContext)!; - } - public override get ruleIndex(): number { - return PostgreSqlParser.RULE_opt_returning_clause_into; - } - public override enterRule(listener: PostgreSqlParserListener): void { - if(listener.enterOpt_returning_clause_into) { - listener.enterOpt_returning_clause_into(this); - } - } - public override exitRule(listener: PostgreSqlParserListener): void { - if(listener.exitOpt_returning_clause_into) { - listener.exitOpt_returning_clause_into(this); - } - } - public override accept(visitor: PostgreSqlParserVisitor): Result | null { - if (visitor.visitOpt_returning_clause_into) { - return visitor.visitOpt_returning_clause_into(this); - } else { - return visitor.visitChildren(this); - } - } -} diff --git a/src/lib/postgresql/PostgreSqlParserListener.ts b/src/lib/postgresql/PostgreSqlParserListener.ts index c3c837e6..b2e80b98 100644 --- a/src/lib/postgresql/PostgreSqlParserListener.ts +++ b/src/lib/postgresql/PostgreSqlParserListener.ts @@ -9,31 +9,22 @@ import { SQLParserBase } from '../SQLParserBase'; import { ProgramContext } from "./PostgreSqlParser.js"; -import { PlsqlrootContext } from "./PostgreSqlParser.js"; import { SingleStmtContext } from "./PostgreSqlParser.js"; import { StmtContext } from "./PostgreSqlParser.js"; -import { PlsqlconsolecommandContext } from "./PostgreSqlParser.js"; import { CallstmtContext } from "./PostgreSqlParser.js"; import { CreaterolestmtContext } from "./PostgreSqlParser.js"; -import { Opt_withContext } from "./PostgreSqlParser.js"; -import { OptrolelistContext } from "./PostgreSqlParser.js"; -import { AlteroptrolelistContext } from "./PostgreSqlParser.js"; import { AlteroptroleelemContext } from "./PostgreSqlParser.js"; import { CreateoptroleelemContext } from "./PostgreSqlParser.js"; import { CreateuserstmtContext } from "./PostgreSqlParser.js"; import { AlterrolestmtContext } from "./PostgreSqlParser.js"; -import { Opt_in_databaseContext } from "./PostgreSqlParser.js"; import { AlterrolesetstmtContext } from "./PostgreSqlParser.js"; import { AlterroutinestmtContext } from "./PostgreSqlParser.js"; import { Alter_routine_cluaseContext } from "./PostgreSqlParser.js"; -import { Routine_action_listContext } from "./PostgreSqlParser.js"; import { Routine_actionContext } from "./PostgreSqlParser.js"; import { CreategroupstmtContext } from "./PostgreSqlParser.js"; import { AltergroupstmtContext } from "./PostgreSqlParser.js"; -import { Add_dropContext } from "./PostgreSqlParser.js"; import { CreateschemastmtContext } from "./PostgreSqlParser.js"; import { SchemaNameCreateContext } from "./PostgreSqlParser.js"; -import { OptschemaeltlistContext } from "./PostgreSqlParser.js"; import { Schema_stmtContext } from "./PostgreSqlParser.js"; import { VariablesetstmtContext } from "./PostgreSqlParser.js"; import { Set_restContext } from "./PostgreSqlParser.js"; @@ -46,18 +37,13 @@ import { Iso_levelContext } from "./PostgreSqlParser.js"; import { Opt_boolean_or_string_columnContext } from "./PostgreSqlParser.js"; import { Opt_boolean_or_stringContext } from "./PostgreSqlParser.js"; import { Zone_valueContext } from "./PostgreSqlParser.js"; -import { Opt_encodingContext } from "./PostgreSqlParser.js"; -import { Nonreservedword_or_sconst_columnContext } from "./PostgreSqlParser.js"; import { Nonreservedword_or_sconstContext } from "./PostgreSqlParser.js"; import { VariableresetstmtContext } from "./PostgreSqlParser.js"; import { Reset_restContext } from "./PostgreSqlParser.js"; -import { Generic_resetContext } from "./PostgreSqlParser.js"; import { SetresetclauseContext } from "./PostgreSqlParser.js"; import { FunctionsetresetclauseContext } from "./PostgreSqlParser.js"; import { VariableshowstmtContext } from "./PostgreSqlParser.js"; import { ConstraintssetstmtContext } from "./PostgreSqlParser.js"; -import { Constraints_set_listContext } from "./PostgreSqlParser.js"; -import { Constraints_set_modeContext } from "./PostgreSqlParser.js"; import { CheckpointstmtContext } from "./PostgreSqlParser.js"; import { DiscardstmtContext } from "./PostgreSqlParser.js"; import { AltertablestmtContext } from "./PostgreSqlParser.js"; @@ -72,85 +58,45 @@ import { Alter_table_cmdContext } from "./PostgreSqlParser.js"; import { Alter_column_defaultContext } from "./PostgreSqlParser.js"; import { Opt_drop_behaviorContext } from "./PostgreSqlParser.js"; import { Opt_collate_clauseContext } from "./PostgreSqlParser.js"; -import { Alter_usingContext } from "./PostgreSqlParser.js"; -import { Replica_identityContext } from "./PostgreSqlParser.js"; import { ReloptionsContext } from "./PostgreSqlParser.js"; import { Opt_reloptionsContext } from "./PostgreSqlParser.js"; -import { Reloption_listContext } from "./PostgreSqlParser.js"; import { Reloption_elemContext } from "./PostgreSqlParser.js"; -import { Alter_identity_column_option_listContext } from "./PostgreSqlParser.js"; -import { Alter_identity_column_optionContext } from "./PostgreSqlParser.js"; import { PartitionboundspecContext } from "./PostgreSqlParser.js"; -import { Hash_partbound_elemContext } from "./PostgreSqlParser.js"; -import { Hash_partboundContext } from "./PostgreSqlParser.js"; import { AltercompositetypestmtContext } from "./PostgreSqlParser.js"; -import { Alter_type_cmdsContext } from "./PostgreSqlParser.js"; import { Alter_type_cmdContext } from "./PostgreSqlParser.js"; import { CloseportalstmtContext } from "./PostgreSqlParser.js"; import { CopystmtContext } from "./PostgreSqlParser.js"; -import { Copy_fromContext } from "./PostgreSqlParser.js"; -import { Opt_programContext } from "./PostgreSqlParser.js"; -import { Copy_file_nameContext } from "./PostgreSqlParser.js"; import { Copy_optionsContext } from "./PostgreSqlParser.js"; -import { Copy_opt_listContext } from "./PostgreSqlParser.js"; -import { Copy_opt_itemContext } from "./PostgreSqlParser.js"; -import { Opt_binaryContext } from "./PostgreSqlParser.js"; -import { Copy_delimiterContext } from "./PostgreSqlParser.js"; -import { Opt_usingContext } from "./PostgreSqlParser.js"; -import { Copy_generic_opt_listContext } from "./PostgreSqlParser.js"; import { Copy_generic_opt_elemContext } from "./PostgreSqlParser.js"; -import { Copy_generic_opt_argContext } from "./PostgreSqlParser.js"; -import { Copy_generic_opt_arg_listContext } from "./PostgreSqlParser.js"; -import { Copy_generic_opt_arg_list_itemContext } from "./PostgreSqlParser.js"; import { ColumnCreateTableContext } from "./PostgreSqlParser.js"; import { OpttempContext } from "./PostgreSqlParser.js"; -import { Table_column_listContext } from "./PostgreSqlParser.js"; -import { OpttableelementlistContext } from "./PostgreSqlParser.js"; import { OpttypedtableelementlistContext } from "./PostgreSqlParser.js"; import { TableelementlistContext } from "./PostgreSqlParser.js"; -import { TypedtableelementlistContext } from "./PostgreSqlParser.js"; import { TableelementContext } from "./PostgreSqlParser.js"; import { TypedtableelementContext } from "./PostgreSqlParser.js"; import { Column_defContext } from "./PostgreSqlParser.js"; -import { CompressionCluaseContext } from "./PostgreSqlParser.js"; -import { StorageCluaseContext } from "./PostgreSqlParser.js"; -import { ColumnOptionsContext } from "./PostgreSqlParser.js"; -import { ColquallistContext } from "./PostgreSqlParser.js"; import { ColconstraintContext } from "./PostgreSqlParser.js"; import { ColconstraintelemContext } from "./PostgreSqlParser.js"; -import { Nulls_distinctContext } from "./PostgreSqlParser.js"; import { Generated_whenContext } from "./PostgreSqlParser.js"; -import { Deferrable_triggerContext } from "./PostgreSqlParser.js"; -import { Initially_triggerContext } from "./PostgreSqlParser.js"; -import { TablelikeclauseContext } from "./PostgreSqlParser.js"; -import { TablelikeoptionlistContext } from "./PostgreSqlParser.js"; import { TablelikeoptionContext } from "./PostgreSqlParser.js"; -import { TableconstraintContext } from "./PostgreSqlParser.js"; import { ConstraintelemContext } from "./PostgreSqlParser.js"; -import { Opt_no_inheritContext } from "./PostgreSqlParser.js"; import { Opt_column_listContext } from "./PostgreSqlParser.js"; import { Opt_column_list_createContext } from "./PostgreSqlParser.js"; import { Column_listContext } from "./PostgreSqlParser.js"; -import { Column_list_createContext } from "./PostgreSqlParser.js"; import { Opt_c_includeContext } from "./PostgreSqlParser.js"; import { Key_matchContext } from "./PostgreSqlParser.js"; -import { ExclusionconstraintlistContext } from "./PostgreSqlParser.js"; import { ExclusionconstraintelemContext } from "./PostgreSqlParser.js"; -import { ExclusionwhereclauseContext } from "./PostgreSqlParser.js"; import { Key_actionsContext } from "./PostgreSqlParser.js"; import { Key_updateContext } from "./PostgreSqlParser.js"; import { Key_deleteContext } from "./PostgreSqlParser.js"; import { Key_actionContext } from "./PostgreSqlParser.js"; import { OptinheritContext } from "./PostgreSqlParser.js"; -import { OptpartitionspecContext } from "./PostgreSqlParser.js"; import { PartitionspecContext } from "./PostgreSqlParser.js"; -import { Part_paramsContext } from "./PostgreSqlParser.js"; import { Part_elemContext } from "./PostgreSqlParser.js"; import { Table_access_method_clauseContext } from "./PostgreSqlParser.js"; import { OptwithContext } from "./PostgreSqlParser.js"; import { OncommitoptionContext } from "./PostgreSqlParser.js"; import { OpttablespaceContext } from "./PostgreSqlParser.js"; -import { Index_paramenters_createContext } from "./PostgreSqlParser.js"; import { OptconstablespaceContext } from "./PostgreSqlParser.js"; import { ExistingindexContext } from "./PostgreSqlParser.js"; import { CreatestatsstmtContext } from "./PostgreSqlParser.js"; @@ -159,185 +105,93 @@ import { QueryCreateTableContext } from "./PostgreSqlParser.js"; import { Create_as_targetContext } from "./PostgreSqlParser.js"; import { Opt_with_dataContext } from "./PostgreSqlParser.js"; import { CreateMaterializedViewContext } from "./PostgreSqlParser.js"; -import { Create_mv_targetContext } from "./PostgreSqlParser.js"; -import { OptnologContext } from "./PostgreSqlParser.js"; import { RefreshmatviewstmtContext } from "./PostgreSqlParser.js"; import { CreateseqstmtContext } from "./PostgreSqlParser.js"; import { AlterseqstmtContext } from "./PostgreSqlParser.js"; -import { OptseqoptlistContext } from "./PostgreSqlParser.js"; -import { OptparenthesizedseqoptlistContext } from "./PostgreSqlParser.js"; -import { SeqoptlistContext } from "./PostgreSqlParser.js"; import { SeqoptelemContext } from "./PostgreSqlParser.js"; -import { Opt_byContext } from "./PostgreSqlParser.js"; import { NumericonlyContext } from "./PostgreSqlParser.js"; -import { Numericonly_listContext } from "./PostgreSqlParser.js"; import { CreateplangstmtContext } from "./PostgreSqlParser.js"; -import { Opt_trustedContext } from "./PostgreSqlParser.js"; -import { Handler_nameContext } from "./PostgreSqlParser.js"; -import { Opt_inline_handlerContext } from "./PostgreSqlParser.js"; -import { Validator_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_validatorContext } from "./PostgreSqlParser.js"; -import { Opt_proceduralContext } from "./PostgreSqlParser.js"; import { CreatetablespacestmtContext } from "./PostgreSqlParser.js"; -import { OpttablespaceownerContext } from "./PostgreSqlParser.js"; import { CreateextensionstmtContext } from "./PostgreSqlParser.js"; -import { Create_extension_opt_listContext } from "./PostgreSqlParser.js"; -import { Create_extension_opt_itemContext } from "./PostgreSqlParser.js"; import { AlterextensionstmtContext } from "./PostgreSqlParser.js"; -import { Alter_extension_opt_listContext } from "./PostgreSqlParser.js"; -import { Alter_extension_opt_itemContext } from "./PostgreSqlParser.js"; import { AlterextensioncontentsstmtContext } from "./PostgreSqlParser.js"; import { CreatefdwstmtContext } from "./PostgreSqlParser.js"; import { Fdw_optionContext } from "./PostgreSqlParser.js"; -import { Fdw_optionsContext } from "./PostgreSqlParser.js"; -import { Opt_fdw_optionsContext } from "./PostgreSqlParser.js"; import { AlterfdwstmtContext } from "./PostgreSqlParser.js"; import { Create_generic_optionsContext } from "./PostgreSqlParser.js"; -import { Generic_option_listContext } from "./PostgreSqlParser.js"; import { Alter_generic_optionsContext } from "./PostgreSqlParser.js"; -import { Alter_generic_option_listContext } from "./PostgreSqlParser.js"; import { Alter_generic_option_elemContext } from "./PostgreSqlParser.js"; import { Generic_option_elemContext } from "./PostgreSqlParser.js"; -import { Generic_option_nameContext } from "./PostgreSqlParser.js"; -import { Generic_option_argContext } from "./PostgreSqlParser.js"; import { CreateforeignserverstmtContext } from "./PostgreSqlParser.js"; -import { Opt_typeContext } from "./PostgreSqlParser.js"; import { Foreign_server_versionContext } from "./PostgreSqlParser.js"; -import { Opt_foreign_server_versionContext } from "./PostgreSqlParser.js"; import { AlterforeignserverstmtContext } from "./PostgreSqlParser.js"; import { CreateForeignTableContext } from "./PostgreSqlParser.js"; import { CreatePartitionForeignTableContext } from "./PostgreSqlParser.js"; import { ImportforeignschemastmtContext } from "./PostgreSqlParser.js"; -import { Import_qualification_typeContext } from "./PostgreSqlParser.js"; -import { Import_qualificationContext } from "./PostgreSqlParser.js"; import { CreateusermappingstmtContext } from "./PostgreSqlParser.js"; -import { Auth_identContext } from "./PostgreSqlParser.js"; import { AlterusermappingstmtContext } from "./PostgreSqlParser.js"; import { CreatepolicystmtContext } from "./PostgreSqlParser.js"; import { AlterpolicystmtContext } from "./PostgreSqlParser.js"; import { AlterprocedurestmtContext } from "./PostgreSqlParser.js"; -import { Procedure_cluaseContext } from "./PostgreSqlParser.js"; import { Procedure_actionContext } from "./PostgreSqlParser.js"; import { RowsecurityoptionalexprContext } from "./PostgreSqlParser.js"; import { RowsecurityoptionalwithcheckContext } from "./PostgreSqlParser.js"; -import { RowsecuritydefaulttoroleContext } from "./PostgreSqlParser.js"; -import { RowsecurityoptionaltoroleContext } from "./PostgreSqlParser.js"; -import { RowsecuritydefaultpermissiveContext } from "./PostgreSqlParser.js"; -import { RowsecuritydefaultforcmdContext } from "./PostgreSqlParser.js"; -import { Row_security_cmdContext } from "./PostgreSqlParser.js"; import { CreateamstmtContext } from "./PostgreSqlParser.js"; -import { Am_typeContext } from "./PostgreSqlParser.js"; import { CreatetrigstmtContext } from "./PostgreSqlParser.js"; import { TriggeractiontimeContext } from "./PostgreSqlParser.js"; -import { ForeachrowContext } from "./PostgreSqlParser.js"; -import { RoworstatmentContext } from "./PostgreSqlParser.js"; import { TriggereventsContext } from "./PostgreSqlParser.js"; import { TriggeroneeventContext } from "./PostgreSqlParser.js"; -import { TriggerreferencingContext } from "./PostgreSqlParser.js"; -import { TriggertransitionsContext } from "./PostgreSqlParser.js"; -import { TriggertransitionContext } from "./PostgreSqlParser.js"; -import { TransitionoldornewContext } from "./PostgreSqlParser.js"; -import { TransitionrowortableContext } from "./PostgreSqlParser.js"; -import { TransitionrelnameContext } from "./PostgreSqlParser.js"; -import { TriggerforspecContext } from "./PostgreSqlParser.js"; -import { TriggerforopteachContext } from "./PostgreSqlParser.js"; -import { TriggerfortypeContext } from "./PostgreSqlParser.js"; import { TriggerwhenContext } from "./PostgreSqlParser.js"; import { Function_or_procedureContext } from "./PostgreSqlParser.js"; import { TriggerfuncargsContext } from "./PostgreSqlParser.js"; import { TriggerfuncargContext } from "./PostgreSqlParser.js"; -import { OptconstrfromtableContext } from "./PostgreSqlParser.js"; -import { ConstraintattributespecContext } from "./PostgreSqlParser.js"; import { ConstraintattributeElemContext } from "./PostgreSqlParser.js"; import { CreateeventtrigstmtContext } from "./PostgreSqlParser.js"; -import { Event_trigger_when_listContext } from "./PostgreSqlParser.js"; import { Event_trigger_when_itemContext } from "./PostgreSqlParser.js"; -import { Event_trigger_value_listContext } from "./PostgreSqlParser.js"; import { AltereventtrigstmtContext } from "./PostgreSqlParser.js"; -import { Enable_triggerContext } from "./PostgreSqlParser.js"; import { CreateassertionstmtContext } from "./PostgreSqlParser.js"; import { DefinestmtContext } from "./PostgreSqlParser.js"; import { DefinitionContext } from "./PostgreSqlParser.js"; -import { Def_listContext } from "./PostgreSqlParser.js"; import { Def_elemContext } from "./PostgreSqlParser.js"; import { Def_argContext } from "./PostgreSqlParser.js"; -import { Old_aggr_definitionContext } from "./PostgreSqlParser.js"; -import { Old_aggr_listContext } from "./PostgreSqlParser.js"; import { Old_aggr_elemContext } from "./PostgreSqlParser.js"; -import { Opt_enum_val_listContext } from "./PostgreSqlParser.js"; -import { Enum_val_listContext } from "./PostgreSqlParser.js"; import { AlterenumstmtContext } from "./PostgreSqlParser.js"; import { Opt_if_not_existsContext } from "./PostgreSqlParser.js"; import { CreateopclassstmtContext } from "./PostgreSqlParser.js"; -import { Opclass_item_listContext } from "./PostgreSqlParser.js"; import { Opclass_itemContext } from "./PostgreSqlParser.js"; -import { Opt_defaultContext } from "./PostgreSqlParser.js"; -import { Opt_opfamilyContext } from "./PostgreSqlParser.js"; -import { Opclass_purposeContext } from "./PostgreSqlParser.js"; -import { Opt_recheckContext } from "./PostgreSqlParser.js"; import { CreateopfamilystmtContext } from "./PostgreSqlParser.js"; import { AlteropfamilystmtContext } from "./PostgreSqlParser.js"; -import { Opclass_drop_listContext } from "./PostgreSqlParser.js"; import { Opclass_dropContext } from "./PostgreSqlParser.js"; import { ReassignownedstmtContext } from "./PostgreSqlParser.js"; import { DropstmtContext } from "./PostgreSqlParser.js"; -import { View_nameListContext } from "./PostgreSqlParser.js"; import { Object_type_any_nameContext } from "./PostgreSqlParser.js"; import { Object_type_nameContext } from "./PostgreSqlParser.js"; -import { Object_type_name_on_any_nameContext } from "./PostgreSqlParser.js"; import { Any_name_listContext } from "./PostgreSqlParser.js"; -import { Relation_column_nameContext } from "./PostgreSqlParser.js"; -import { Relation_nameContext } from "./PostgreSqlParser.js"; import { Any_nameContext } from "./PostgreSqlParser.js"; import { AttrsContext } from "./PostgreSqlParser.js"; -import { Type_name_listContext } from "./PostgreSqlParser.js"; import { TruncatestmtContext } from "./PostgreSqlParser.js"; import { Truncate_tableContext } from "./PostgreSqlParser.js"; import { CommentstmtContext } from "./PostgreSqlParser.js"; -import { Comment_textContext } from "./PostgreSqlParser.js"; import { SeclabelstmtContext } from "./PostgreSqlParser.js"; -import { Opt_providerContext } from "./PostgreSqlParser.js"; -import { Security_labelContext } from "./PostgreSqlParser.js"; import { FetchstmtContext } from "./PostgreSqlParser.js"; import { Fetch_argsContext } from "./PostgreSqlParser.js"; import { From_inContext } from "./PostgreSqlParser.js"; -import { Opt_from_inContext } from "./PostgreSqlParser.js"; import { GrantstmtContext } from "./PostgreSqlParser.js"; import { RevokestmtContext } from "./PostgreSqlParser.js"; import { PrivilegesContext } from "./PostgreSqlParser.js"; -import { BeforeprivilegeselectlistContext } from "./PostgreSqlParser.js"; import { BeforeprivilegeselectContext } from "./PostgreSqlParser.js"; -import { Privilege_listContext } from "./PostgreSqlParser.js"; import { PrivilegeContext } from "./PostgreSqlParser.js"; import { Privilege_targetContext } from "./PostgreSqlParser.js"; import { Grantee_listContext } from "./PostgreSqlParser.js"; -import { GranteeContext } from "./PostgreSqlParser.js"; -import { Opt_grant_grant_optionContext } from "./PostgreSqlParser.js"; import { GrantrolestmtContext } from "./PostgreSqlParser.js"; import { RevokerolestmtContext } from "./PostgreSqlParser.js"; -import { Opt_grant_admin_optionContext } from "./PostgreSqlParser.js"; -import { Opt_granted_byContext } from "./PostgreSqlParser.js"; import { AlterdefaultprivilegesstmtContext } from "./PostgreSqlParser.js"; -import { DefacloptionlistContext } from "./PostgreSqlParser.js"; -import { DefacloptionContext } from "./PostgreSqlParser.js"; import { DefaclactionContext } from "./PostgreSqlParser.js"; import { Defacl_privilege_targetContext } from "./PostgreSqlParser.js"; import { IndexstmtContext } from "./PostgreSqlParser.js"; -import { Opt_uniqueContext } from "./PostgreSqlParser.js"; -import { Opt_concurrentlyContext } from "./PostgreSqlParser.js"; -import { Opt_index_nameContext } from "./PostgreSqlParser.js"; -import { Access_method_clauseContext } from "./PostgreSqlParser.js"; import { Index_paramsContext } from "./PostgreSqlParser.js"; -import { Index_elem_optionsContext } from "./PostgreSqlParser.js"; import { Index_elemContext } from "./PostgreSqlParser.js"; -import { Opt_includeContext } from "./PostgreSqlParser.js"; -import { Index_including_paramsContext } from "./PostgreSqlParser.js"; -import { Opt_collateContext } from "./PostgreSqlParser.js"; -import { Opt_classContext } from "./PostgreSqlParser.js"; -import { Opt_asc_descContext } from "./PostgreSqlParser.js"; -import { Opt_nulls_orderContext } from "./PostgreSqlParser.js"; import { CreatefunctionstmtContext } from "./PostgreSqlParser.js"; -import { AttrilistContext } from "./PostgreSqlParser.js"; import { Opt_or_replaceContext } from "./PostgreSqlParser.js"; import { Func_argsContext } from "./PostgreSqlParser.js"; import { Func_args_listContext } from "./PostgreSqlParser.js"; @@ -347,77 +201,44 @@ import { Procedure_with_argtypes_listContext } from "./PostgreSqlParser.js"; import { Procedure_with_argtypesContext } from "./PostgreSqlParser.js"; import { Function_with_argtypes_listContext } from "./PostgreSqlParser.js"; import { Function_with_argtypesContext } from "./PostgreSqlParser.js"; -import { Func_args_with_defaultsContext } from "./PostgreSqlParser.js"; -import { Func_args_with_defaults_listContext } from "./PostgreSqlParser.js"; import { Func_argContext } from "./PostgreSqlParser.js"; import { Arg_classContext } from "./PostgreSqlParser.js"; -import { Param_nameContext } from "./PostgreSqlParser.js"; -import { Func_returnContext } from "./PostgreSqlParser.js"; import { Func_typeContext } from "./PostgreSqlParser.js"; import { Func_arg_with_defaultContext } from "./PostgreSqlParser.js"; -import { Aggr_argContext } from "./PostgreSqlParser.js"; import { Aggr_argsContext } from "./PostgreSqlParser.js"; -import { Aggr_args_listContext } from "./PostgreSqlParser.js"; import { Aggregate_with_argtypesContext } from "./PostgreSqlParser.js"; -import { Aggregate_with_argtypes_listContext } from "./PostgreSqlParser.js"; -import { Createfunc_opt_listContext } from "./PostgreSqlParser.js"; import { Common_func_opt_itemContext } from "./PostgreSqlParser.js"; import { Createfunc_opt_itemContext } from "./PostgreSqlParser.js"; -import { Transform_type_listContext } from "./PostgreSqlParser.js"; import { Opt_definitionContext } from "./PostgreSqlParser.js"; import { Table_func_columnContext } from "./PostgreSqlParser.js"; -import { Table_func_column_listContext } from "./PostgreSqlParser.js"; import { AlterfunctionstmtContext } from "./PostgreSqlParser.js"; -import { AlterFunctionTypeClauseContext } from "./PostgreSqlParser.js"; -import { Alterfunc_opt_listContext } from "./PostgreSqlParser.js"; -import { Opt_restrictContext } from "./PostgreSqlParser.js"; import { RemovefuncstmtContext } from "./PostgreSqlParser.js"; import { RemoveaggrstmtContext } from "./PostgreSqlParser.js"; import { RemoveoperstmtContext } from "./PostgreSqlParser.js"; import { Oper_argtypesContext } from "./PostgreSqlParser.js"; import { Any_operatorContext } from "./PostgreSqlParser.js"; -import { Operator_with_argtypes_listContext } from "./PostgreSqlParser.js"; import { Operator_with_argtypesContext } from "./PostgreSqlParser.js"; import { DostmtContext } from "./PostgreSqlParser.js"; -import { Dostmt_opt_listContext } from "./PostgreSqlParser.js"; -import { Dostmt_opt_itemContext } from "./PostgreSqlParser.js"; import { CreatecaststmtContext } from "./PostgreSqlParser.js"; -import { Cast_contextContext } from "./PostgreSqlParser.js"; import { Opt_if_existsContext } from "./PostgreSqlParser.js"; import { CreatetransformstmtContext } from "./PostgreSqlParser.js"; -import { Transform_element_listContext } from "./PostgreSqlParser.js"; +import { Sql_with_functionContext } from "./PostgreSqlParser.js"; import { ReindexstmtContext } from "./PostgreSqlParser.js"; -import { Reindex_target_typeContext } from "./PostgreSqlParser.js"; -import { Reindex_target_multitableContext } from "./PostgreSqlParser.js"; -import { Reindex_option_listContext } from "./PostgreSqlParser.js"; -import { Reindex_option_elemContext } from "./PostgreSqlParser.js"; import { AltertblspcstmtContext } from "./PostgreSqlParser.js"; import { RenamestmtContext } from "./PostgreSqlParser.js"; -import { Opt_set_dataContext } from "./PostgreSqlParser.js"; import { AlterobjectdependsstmtContext } from "./PostgreSqlParser.js"; -import { Opt_noContext } from "./PostgreSqlParser.js"; import { AlterobjectschemastmtContext } from "./PostgreSqlParser.js"; import { AlteroperatorstmtContext } from "./PostgreSqlParser.js"; import { Operator_def_listContext } from "./PostgreSqlParser.js"; import { Operator_def_elemContext } from "./PostgreSqlParser.js"; -import { Operator_def_argContext } from "./PostgreSqlParser.js"; import { AltertypestmtContext } from "./PostgreSqlParser.js"; import { AlterownerstmtContext } from "./PostgreSqlParser.js"; import { CreatepublicationstmtContext } from "./PostgreSqlParser.js"; -import { Opt_publication_for_tablesContext } from "./PostgreSqlParser.js"; -import { Publication_for_tablesContext } from "./PostgreSqlParser.js"; import { AlterpublicationstmtContext } from "./PostgreSqlParser.js"; import { CreatesubscriptionstmtContext } from "./PostgreSqlParser.js"; -import { Publication_name_listContext } from "./PostgreSqlParser.js"; -import { Publication_name_itemContext } from "./PostgreSqlParser.js"; import { AltersubscriptionstmtContext } from "./PostgreSqlParser.js"; import { RulestmtContext } from "./PostgreSqlParser.js"; -import { RuleactionlistContext } from "./PostgreSqlParser.js"; -import { RuleactionmultiContext } from "./PostgreSqlParser.js"; import { RuleactionstmtContext } from "./PostgreSqlParser.js"; -import { RuleactionstmtOrEmptyContext } from "./PostgreSqlParser.js"; -import { EventContext } from "./PostgreSqlParser.js"; -import { Opt_insteadContext } from "./PostgreSqlParser.js"; import { NotifystmtContext } from "./PostgreSqlParser.js"; import { Notify_payloadContext } from "./PostgreSqlParser.js"; import { ListenstmtContext } from "./PostgreSqlParser.js"; @@ -426,58 +247,31 @@ import { TransactionstmtContext } from "./PostgreSqlParser.js"; import { Opt_transactionContext } from "./PostgreSqlParser.js"; import { Transaction_mode_itemContext } from "./PostgreSqlParser.js"; import { Transaction_mode_listContext } from "./PostgreSqlParser.js"; -import { Transaction_mode_list_or_emptyContext } from "./PostgreSqlParser.js"; -import { Opt_transaction_chainContext } from "./PostgreSqlParser.js"; import { CreateViewContext } from "./PostgreSqlParser.js"; -import { Opt_check_optionContext } from "./PostgreSqlParser.js"; import { LoadstmtContext } from "./PostgreSqlParser.js"; import { CreateDatabaseContext } from "./PostgreSqlParser.js"; -import { Createdb_opt_listContext } from "./PostgreSqlParser.js"; -import { Createdb_opt_itemsContext } from "./PostgreSqlParser.js"; import { Createdb_opt_itemContext } from "./PostgreSqlParser.js"; -import { Createdb_opt_nameContext } from "./PostgreSqlParser.js"; -import { Opt_equalContext } from "./PostgreSqlParser.js"; import { AlterdatabasestmtContext } from "./PostgreSqlParser.js"; import { AlterdatabasesetstmtContext } from "./PostgreSqlParser.js"; -import { Drop_option_listContext } from "./PostgreSqlParser.js"; -import { Drop_optionContext } from "./PostgreSqlParser.js"; import { AltercollationstmtContext } from "./PostgreSqlParser.js"; import { AltersystemstmtContext } from "./PostgreSqlParser.js"; import { CreatedomainstmtContext } from "./PostgreSqlParser.js"; import { AlterdomainstmtContext } from "./PostgreSqlParser.js"; -import { Opt_asContext } from "./PostgreSqlParser.js"; import { AltertsdictionarystmtContext } from "./PostgreSqlParser.js"; import { AltertsconfigurationstmtContext } from "./PostgreSqlParser.js"; -import { Any_withContext } from "./PostgreSqlParser.js"; import { CreateconversionstmtContext } from "./PostgreSqlParser.js"; import { ClusterstmtContext } from "./PostgreSqlParser.js"; -import { Opt_verbose_listContext } from "./PostgreSqlParser.js"; -import { Cluster_index_specificationContext } from "./PostgreSqlParser.js"; import { VacuumstmtContext } from "./PostgreSqlParser.js"; import { AnalyzestmtContext } from "./PostgreSqlParser.js"; -import { Vac_analyze_option_listContext } from "./PostgreSqlParser.js"; import { Analyze_keywordContext } from "./PostgreSqlParser.js"; import { Vac_analyze_option_elemContext } from "./PostgreSqlParser.js"; -import { Vac_analyze_option_nameContext } from "./PostgreSqlParser.js"; -import { Vac_analyze_option_argContext } from "./PostgreSqlParser.js"; -import { Opt_analyzeContext } from "./PostgreSqlParser.js"; -import { Analyze_options_listContext } from "./PostgreSqlParser.js"; import { Analyze_option_elemContext } from "./PostgreSqlParser.js"; import { Opt_verboseContext } from "./PostgreSqlParser.js"; -import { Opt_skiplockContext } from "./PostgreSqlParser.js"; -import { Opt_buffer_usage_limitContext } from "./PostgreSqlParser.js"; -import { Opt_fullContext } from "./PostgreSqlParser.js"; -import { Opt_freezeContext } from "./PostgreSqlParser.js"; -import { Opt_name_listContext } from "./PostgreSqlParser.js"; import { Vacuum_relationContext } from "./PostgreSqlParser.js"; import { Vacuum_relation_listContext } from "./PostgreSqlParser.js"; -import { Opt_vacuum_relation_listContext } from "./PostgreSqlParser.js"; import { ExplainstmtContext } from "./PostgreSqlParser.js"; import { ExplainablestmtContext } from "./PostgreSqlParser.js"; import { Explain_option_listContext } from "./PostgreSqlParser.js"; -import { Explain_option_elemContext } from "./PostgreSqlParser.js"; -import { Explain_option_nameContext } from "./PostgreSqlParser.js"; -import { Explain_option_argContext } from "./PostgreSqlParser.js"; import { PreparestmtContext } from "./PostgreSqlParser.js"; import { Prep_type_clauseContext } from "./PostgreSqlParser.js"; import { PreparablestmtContext } from "./PostgreSqlParser.js"; @@ -485,192 +279,108 @@ import { ExecutestmtContext } from "./PostgreSqlParser.js"; import { Execute_param_clauseContext } from "./PostgreSqlParser.js"; import { DeallocatestmtContext } from "./PostgreSqlParser.js"; import { InsertStatementContext } from "./PostgreSqlParser.js"; -import { Insert_targetContext } from "./PostgreSqlParser.js"; import { Insert_restContext } from "./PostgreSqlParser.js"; -import { Override_kindContext } from "./PostgreSqlParser.js"; import { Insert_column_listContext } from "./PostgreSqlParser.js"; import { Insert_column_itemContext } from "./PostgreSqlParser.js"; -import { Opt_on_conflictContext } from "./PostgreSqlParser.js"; -import { Opt_conf_exprContext } from "./PostgreSqlParser.js"; import { Returning_clauseContext } from "./PostgreSqlParser.js"; import { DeletestmtContext } from "./PostgreSqlParser.js"; -import { Using_clauseContext } from "./PostgreSqlParser.js"; import { LockstmtContext } from "./PostgreSqlParser.js"; -import { Opt_lockContext } from "./PostgreSqlParser.js"; -import { Lock_typeContext } from "./PostgreSqlParser.js"; -import { Opt_nowaitContext } from "./PostgreSqlParser.js"; -import { Opt_nowait_or_skipContext } from "./PostgreSqlParser.js"; import { UpdatestmtContext } from "./PostgreSqlParser.js"; import { Set_clause_listContext } from "./PostgreSqlParser.js"; import { Set_clauseContext } from "./PostgreSqlParser.js"; -import { Set_targetContext } from "./PostgreSqlParser.js"; -import { Set_target_listContext } from "./PostgreSqlParser.js"; import { DeclarecursorstmtContext } from "./PostgreSqlParser.js"; -import { Cursor_nameContext } from "./PostgreSqlParser.js"; -import { Cursor_optionsContext } from "./PostgreSqlParser.js"; -import { Opt_holdContext } from "./PostgreSqlParser.js"; import { SelectStatementContext } from "./PostgreSqlParser.js"; import { Select_with_parensContext } from "./PostgreSqlParser.js"; import { Select_no_parensContext } from "./PostgreSqlParser.js"; import { Select_clauseContext } from "./PostgreSqlParser.js"; import { Simple_selectContext } from "./PostgreSqlParser.js"; -import { UnionContext } from "./PostgreSqlParser.js"; -import { IntersectContext } from "./PostgreSqlParser.js"; -import { ExceptContext } from "./PostgreSqlParser.js"; import { Set_operator_with_all_or_distinctContext } from "./PostgreSqlParser.js"; import { With_clauseContext } from "./PostgreSqlParser.js"; -import { Cte_listContext } from "./PostgreSqlParser.js"; import { Common_table_exprContext } from "./PostgreSqlParser.js"; import { Search_cluaseContext } from "./PostgreSqlParser.js"; import { Cycle_cluaseContext } from "./PostgreSqlParser.js"; -import { Opt_materializedContext } from "./PostgreSqlParser.js"; -import { Opt_with_clauseContext } from "./PostgreSqlParser.js"; import { Into_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_strictContext } from "./PostgreSqlParser.js"; import { OpttempTableNameContext } from "./PostgreSqlParser.js"; -import { Opt_tableContext } from "./PostgreSqlParser.js"; -import { All_or_distinctContext } from "./PostgreSqlParser.js"; import { Distinct_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_all_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_sort_clauseContext } from "./PostgreSqlParser.js"; import { Sort_clauseContext } from "./PostgreSqlParser.js"; -import { Sortby_listContext } from "./PostgreSqlParser.js"; import { SortbyContext } from "./PostgreSqlParser.js"; import { Select_limitContext } from "./PostgreSqlParser.js"; -import { Opt_select_limitContext } from "./PostgreSqlParser.js"; import { Limit_clauseContext } from "./PostgreSqlParser.js"; import { Fetch_clauseContext } from "./PostgreSqlParser.js"; import { Offset_clauseContext } from "./PostgreSqlParser.js"; -import { Select_limit_valueContext } from "./PostgreSqlParser.js"; -import { Select_offset_valueContext } from "./PostgreSqlParser.js"; import { Select_fetch_first_valueContext } from "./PostgreSqlParser.js"; -import { I_or_f_constContext } from "./PostgreSqlParser.js"; -import { Row_or_rowsContext } from "./PostgreSqlParser.js"; -import { First_or_nextContext } from "./PostgreSqlParser.js"; import { Group_clauseContext } from "./PostgreSqlParser.js"; import { Group_by_listContext } from "./PostgreSqlParser.js"; import { Group_by_itemContext } from "./PostgreSqlParser.js"; -import { Empty_grouping_setContext } from "./PostgreSqlParser.js"; -import { Rollup_clauseContext } from "./PostgreSqlParser.js"; -import { Cube_clauseContext } from "./PostgreSqlParser.js"; -import { Grouping_sets_clauseContext } from "./PostgreSqlParser.js"; -import { Having_clauseContext } from "./PostgreSqlParser.js"; import { For_locking_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_for_locking_clauseContext } from "./PostgreSqlParser.js"; -import { For_locking_itemsContext } from "./PostgreSqlParser.js"; -import { For_locking_itemContext } from "./PostgreSqlParser.js"; -import { For_locking_strengthContext } from "./PostgreSqlParser.js"; -import { Locked_rels_listContext } from "./PostgreSqlParser.js"; import { Values_clauseContext } from "./PostgreSqlParser.js"; import { From_clauseContext } from "./PostgreSqlParser.js"; import { From_listContext } from "./PostgreSqlParser.js"; import { Table_refContext } from "./PostgreSqlParser.js"; import { Alias_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_alias_clauseContext } from "./PostgreSqlParser.js"; import { Func_alias_clauseContext } from "./PostgreSqlParser.js"; import { Join_typeContext } from "./PostgreSqlParser.js"; import { Join_qualContext } from "./PostgreSqlParser.js"; import { Relation_exprContext } from "./PostgreSqlParser.js"; -import { View_relation_exprContext } from "./PostgreSqlParser.js"; import { Publication_relation_exprContext } from "./PostgreSqlParser.js"; import { Relation_expr_listContext } from "./PostgreSqlParser.js"; -import { Publication_relation_expr_listContext } from "./PostgreSqlParser.js"; import { Relation_expr_opt_aliasContext } from "./PostgreSqlParser.js"; import { Tablesample_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_repeatable_clauseContext } from "./PostgreSqlParser.js"; import { Func_tableContext } from "./PostgreSqlParser.js"; import { Rowsfrom_itemContext } from "./PostgreSqlParser.js"; -import { Rowsfrom_listContext } from "./PostgreSqlParser.js"; -import { Opt_col_def_listContext } from "./PostgreSqlParser.js"; -import { Opt_ordinalityContext } from "./PostgreSqlParser.js"; import { Where_clauseContext } from "./PostgreSqlParser.js"; import { Where_or_current_clauseContext } from "./PostgreSqlParser.js"; -import { OpttablefuncelementlistContext } from "./PostgreSqlParser.js"; import { TablefuncelementlistContext } from "./PostgreSqlParser.js"; import { TablefuncelementContext } from "./PostgreSqlParser.js"; import { XmltableContext } from "./PostgreSqlParser.js"; -import { Xmltable_column_listContext } from "./PostgreSqlParser.js"; import { Xmltable_column_elContext } from "./PostgreSqlParser.js"; -import { Xmltable_column_option_listContext } from "./PostgreSqlParser.js"; -import { Xmltable_column_option_elContext } from "./PostgreSqlParser.js"; -import { Xml_namespace_listContext } from "./PostgreSqlParser.js"; import { Xml_namespace_elContext } from "./PostgreSqlParser.js"; import { TypenameContext } from "./PostgreSqlParser.js"; -import { Opt_array_boundsContext } from "./PostgreSqlParser.js"; import { SimpletypenameContext } from "./PostgreSqlParser.js"; import { ConsttypenameContext } from "./PostgreSqlParser.js"; -import { GenerictypeContext } from "./PostgreSqlParser.js"; -import { Opt_type_modifiersContext } from "./PostgreSqlParser.js"; import { NumericContext } from "./PostgreSqlParser.js"; import { Opt_floatContext } from "./PostgreSqlParser.js"; import { BitContext } from "./PostgreSqlParser.js"; -import { ConstbitContext } from "./PostgreSqlParser.js"; -import { BitwithlengthContext } from "./PostgreSqlParser.js"; -import { BitwithoutlengthContext } from "./PostgreSqlParser.js"; import { CharacterContext } from "./PostgreSqlParser.js"; -import { ConstcharacterContext } from "./PostgreSqlParser.js"; -import { Character_cContext } from "./PostgreSqlParser.js"; -import { Opt_varyingContext } from "./PostgreSqlParser.js"; import { ConstdatetimeContext } from "./PostgreSqlParser.js"; -import { ConstintervalContext } from "./PostgreSqlParser.js"; -import { Opt_timezoneContext } from "./PostgreSqlParser.js"; import { Opt_intervalContext } from "./PostgreSqlParser.js"; import { Interval_secondContext } from "./PostgreSqlParser.js"; -import { Opt_escapeContext } from "./PostgreSqlParser.js"; -import { A_exprContext } from "./PostgreSqlParser.js"; -import { A_expr_qualContext } from "./PostgreSqlParser.js"; -import { A_expr_lesslessContext } from "./PostgreSqlParser.js"; -import { A_expr_orContext } from "./PostgreSqlParser.js"; -import { A_expr_andContext } from "./PostgreSqlParser.js"; -import { A_expr_inContext } from "./PostgreSqlParser.js"; -import { A_expr_unary_notContext } from "./PostgreSqlParser.js"; -import { A_expr_isnullContext } from "./PostgreSqlParser.js"; -import { A_expr_is_notContext } from "./PostgreSqlParser.js"; -import { A_expr_compareContext } from "./PostgreSqlParser.js"; -import { A_expr_likeContext } from "./PostgreSqlParser.js"; -import { A_expr_qual_opContext } from "./PostgreSqlParser.js"; -import { A_expr_unary_qualopContext } from "./PostgreSqlParser.js"; -import { A_expr_addContext } from "./PostgreSqlParser.js"; -import { A_expr_mulContext } from "./PostgreSqlParser.js"; -import { A_expr_caretContext } from "./PostgreSqlParser.js"; -import { A_expr_unary_signContext } from "./PostgreSqlParser.js"; -import { A_expr_at_time_zoneContext } from "./PostgreSqlParser.js"; -import { A_expr_collateContext } from "./PostgreSqlParser.js"; -import { A_expr_typecastContext } from "./PostgreSqlParser.js"; -import { B_exprContext } from "./PostgreSqlParser.js"; -import { C_expr_existsContext } from "./PostgreSqlParser.js"; -import { C_expr_exprContext } from "./PostgreSqlParser.js"; -import { C_expr_caseContext } from "./PostgreSqlParser.js"; -import { PlsqlvariablenameContext } from "./PostgreSqlParser.js"; +import { ComparisonOperatorContext } from "./PostgreSqlParser.js"; +import { ExpressionContext } from "./PostgreSqlParser.js"; +import { LogicalNotContext } from "./PostgreSqlParser.js"; +import { PredicatedContext } from "./PostgreSqlParser.js"; +import { LogicalBinaryContext } from "./PostgreSqlParser.js"; +import { ComparisonContext } from "./PostgreSqlParser.js"; +import { QuantifiedComparisonContext } from "./PostgreSqlParser.js"; +import { BetweenContext } from "./PostgreSqlParser.js"; +import { InListContext } from "./PostgreSqlParser.js"; +import { InSubqueryContext } from "./PostgreSqlParser.js"; +import { LikeContext } from "./PostgreSqlParser.js"; +import { NullPredicateContext } from "./PostgreSqlParser.js"; +import { DistinctFromContext } from "./PostgreSqlParser.js"; +import { ValueExpressionDefaultContext } from "./PostgreSqlParser.js"; +import { ConcatenationContext } from "./PostgreSqlParser.js"; +import { ArithmeticBinaryContext } from "./PostgreSqlParser.js"; +import { ArithmeticUnaryContext } from "./PostgreSqlParser.js"; +import { AtTimeZoneContext } from "./PostgreSqlParser.js"; +import { PrimaryExpressionContext } from "./PostgreSqlParser.js"; import { Func_applicationContext } from "./PostgreSqlParser.js"; import { Func_exprContext } from "./PostgreSqlParser.js"; import { Func_expr_windowlessContext } from "./PostgreSqlParser.js"; import { Func_expr_common_subexprContext } from "./PostgreSqlParser.js"; -import { Xml_root_versionContext } from "./PostgreSqlParser.js"; -import { Opt_xml_root_standaloneContext } from "./PostgreSqlParser.js"; -import { Xml_attributesContext } from "./PostgreSqlParser.js"; import { Xml_attribute_listContext } from "./PostgreSqlParser.js"; import { Xml_attribute_elContext } from "./PostgreSqlParser.js"; import { Document_or_contentContext } from "./PostgreSqlParser.js"; -import { Xml_whitespace_optionContext } from "./PostgreSqlParser.js"; import { Xmlexists_argumentContext } from "./PostgreSqlParser.js"; import { Xml_passing_mechContext } from "./PostgreSqlParser.js"; -import { Within_group_clauseContext } from "./PostgreSqlParser.js"; -import { Filter_clauseContext } from "./PostgreSqlParser.js"; import { Window_clauseContext } from "./PostgreSqlParser.js"; -import { Window_definition_listContext } from "./PostgreSqlParser.js"; import { Window_definitionContext } from "./PostgreSqlParser.js"; import { Over_clauseContext } from "./PostgreSqlParser.js"; import { Window_specificationContext } from "./PostgreSqlParser.js"; -import { Opt_existing_window_nameContext } from "./PostgreSqlParser.js"; -import { Opt_partition_clauseContext } from "./PostgreSqlParser.js"; import { Opt_frame_clauseContext } from "./PostgreSqlParser.js"; -import { Frame_extentContext } from "./PostgreSqlParser.js"; import { Frame_boundContext } from "./PostgreSqlParser.js"; -import { Opt_window_exclusion_clauseContext } from "./PostgreSqlParser.js"; import { RowContext } from "./PostgreSqlParser.js"; import { Explicit_rowContext } from "./PostgreSqlParser.js"; -import { Implicit_rowContext } from "./PostgreSqlParser.js"; import { Sub_typeContext } from "./PostgreSqlParser.js"; import { All_opContext } from "./PostgreSqlParser.js"; import { MathopContext } from "./PostgreSqlParser.js"; @@ -678,35 +388,18 @@ import { Qual_opContext } from "./PostgreSqlParser.js"; import { Qual_all_opContext } from "./PostgreSqlParser.js"; import { Subquery_OpContext } from "./PostgreSqlParser.js"; import { Expr_listContext } from "./PostgreSqlParser.js"; -import { Column_expr_list_noparenContext } from "./PostgreSqlParser.js"; -import { Column_expr_listContext } from "./PostgreSqlParser.js"; import { Column_exprContext } from "./PostgreSqlParser.js"; import { Column_expr_noparenContext } from "./PostgreSqlParser.js"; import { Func_arg_listContext } from "./PostgreSqlParser.js"; import { Func_arg_exprContext } from "./PostgreSqlParser.js"; -import { Type_listContext } from "./PostgreSqlParser.js"; import { Array_exprContext } from "./PostgreSqlParser.js"; -import { Array_expr_listContext } from "./PostgreSqlParser.js"; -import { Extract_listContext } from "./PostgreSqlParser.js"; import { Extract_argContext } from "./PostgreSqlParser.js"; import { Unicode_normal_formContext } from "./PostgreSqlParser.js"; -import { Overlay_listContext } from "./PostgreSqlParser.js"; -import { Position_listContext } from "./PostgreSqlParser.js"; import { Substr_listContext } from "./PostgreSqlParser.js"; -import { Trim_listContext } from "./PostgreSqlParser.js"; -import { In_expr_selectContext } from "./PostgreSqlParser.js"; -import { In_expr_listContext } from "./PostgreSqlParser.js"; -import { Case_exprContext } from "./PostgreSqlParser.js"; -import { When_clause_listContext } from "./PostgreSqlParser.js"; import { When_clauseContext } from "./PostgreSqlParser.js"; -import { Case_defaultContext } from "./PostgreSqlParser.js"; -import { Case_argContext } from "./PostgreSqlParser.js"; -import { ColumnrefContext } from "./PostgreSqlParser.js"; import { Indirection_elContext } from "./PostgreSqlParser.js"; -import { Opt_slice_boundContext } from "./PostgreSqlParser.js"; import { IndirectionContext } from "./PostgreSqlParser.js"; import { Opt_indirectionContext } from "./PostgreSqlParser.js"; -import { Opt_target_listContext } from "./PostgreSqlParser.js"; import { Target_listContext } from "./PostgreSqlParser.js"; import { Target_labelContext } from "./PostgreSqlParser.js"; import { Target_starContext } from "./PostgreSqlParser.js"; @@ -714,7 +407,6 @@ import { Qualified_name_listContext } from "./PostgreSqlParser.js"; import { Table_name_listContext } from "./PostgreSqlParser.js"; import { Schema_name_listContext } from "./PostgreSqlParser.js"; import { Database_nameListContext } from "./PostgreSqlParser.js"; -import { Procedure_name_listContext } from "./PostgreSqlParser.js"; import { TablespaceNameCreateContext } from "./PostgreSqlParser.js"; import { TablespaceNameContext } from "./PostgreSqlParser.js"; import { TableNameCreateContext } from "./PostgreSqlParser.js"; @@ -734,163 +426,71 @@ import { ProcedureNameCreateContext } from "./PostgreSqlParser.js"; import { ColumnNameContext } from "./PostgreSqlParser.js"; import { ColumnNameMatchContext } from "./PostgreSqlParser.js"; import { ColumnNameCreateContext } from "./PostgreSqlParser.js"; -import { NameContext } from "./PostgreSqlParser.js"; -import { Attr_nameContext } from "./PostgreSqlParser.js"; -import { File_nameContext } from "./PostgreSqlParser.js"; import { FunctionNameCreateContext } from "./PostgreSqlParser.js"; import { FunctionNameContext } from "./PostgreSqlParser.js"; -import { Usual_nameContext } from "./PostgreSqlParser.js"; -import { AexprconstContext } from "./PostgreSqlParser.js"; -import { XconstContext } from "./PostgreSqlParser.js"; -import { BconstContext } from "./PostgreSqlParser.js"; -import { FconstContext } from "./PostgreSqlParser.js"; -import { IconstContext } from "./PostgreSqlParser.js"; import { SconstContext } from "./PostgreSqlParser.js"; import { AnysconstContext } from "./PostgreSqlParser.js"; -import { Opt_uescapeContext } from "./PostgreSqlParser.js"; import { SignediconstContext } from "./PostgreSqlParser.js"; -import { GroupnameContext } from "./PostgreSqlParser.js"; -import { RoleidContext } from "./PostgreSqlParser.js"; import { RolespecContext } from "./PostgreSqlParser.js"; import { Role_listContext } from "./PostgreSqlParser.js"; import { ColidContext } from "./PostgreSqlParser.js"; -import { Index_method_choicesContext } from "./PostgreSqlParser.js"; -import { Exclude_elementContext } from "./PostgreSqlParser.js"; -import { Index_paramentersContext } from "./PostgreSqlParser.js"; import { Type_function_nameContext } from "./PostgreSqlParser.js"; -import { Type_usual_nameContext } from "./PostgreSqlParser.js"; -import { Nonreservedword_columnContext } from "./PostgreSqlParser.js"; import { NonreservedwordContext } from "./PostgreSqlParser.js"; import { CollabelContext } from "./PostgreSqlParser.js"; import { IdentifierContext } from "./PostgreSqlParser.js"; -import { PlsqlidentifierContext } from "./PostgreSqlParser.js"; import { Unreserved_keywordContext } from "./PostgreSqlParser.js"; import { Col_name_keywordContext } from "./PostgreSqlParser.js"; import { Type_func_name_keywordContext } from "./PostgreSqlParser.js"; import { Reserved_keywordContext } from "./PostgreSqlParser.js"; -import { Pl_functionContext } from "./PostgreSqlParser.js"; -import { Comp_optionsContext } from "./PostgreSqlParser.js"; -import { Comp_optionContext } from "./PostgreSqlParser.js"; -import { SharpContext } from "./PostgreSqlParser.js"; -import { Option_valueContext } from "./PostgreSqlParser.js"; -import { Opt_semiContext } from "./PostgreSqlParser.js"; import { Pl_blockContext } from "./PostgreSqlParser.js"; -import { Decl_sectContext } from "./PostgreSqlParser.js"; -import { Decl_startContext } from "./PostgreSqlParser.js"; -import { Decl_stmtsContext } from "./PostgreSqlParser.js"; import { Label_declContext } from "./PostgreSqlParser.js"; -import { Decl_stmtContext } from "./PostgreSqlParser.js"; import { Decl_statementContext } from "./PostgreSqlParser.js"; -import { Opt_scrollableContext } from "./PostgreSqlParser.js"; -import { Decl_cursor_queryContext } from "./PostgreSqlParser.js"; -import { Decl_cursor_argsContext } from "./PostgreSqlParser.js"; -import { Decl_cursor_arglistContext } from "./PostgreSqlParser.js"; import { Decl_cursor_argContext } from "./PostgreSqlParser.js"; -import { Decl_is_forContext } from "./PostgreSqlParser.js"; -import { Decl_aliasitemContext } from "./PostgreSqlParser.js"; -import { Decl_varnameContext } from "./PostgreSqlParser.js"; -import { Decl_constContext } from "./PostgreSqlParser.js"; -import { Decl_datatypeContext } from "./PostgreSqlParser.js"; -import { Decl_collateContext } from "./PostgreSqlParser.js"; -import { Decl_notnullContext } from "./PostgreSqlParser.js"; -import { Decl_defvalContext } from "./PostgreSqlParser.js"; -import { Decl_defkeyContext } from "./PostgreSqlParser.js"; import { Assign_operatorContext } from "./PostgreSqlParser.js"; -import { Proc_sectContext } from "./PostgreSqlParser.js"; import { Proc_stmtContext } from "./PostgreSqlParser.js"; import { Stmt_performContext } from "./PostgreSqlParser.js"; import { Stmt_callContext } from "./PostgreSqlParser.js"; -import { Opt_expr_listContext } from "./PostgreSqlParser.js"; import { Stmt_assignContext } from "./PostgreSqlParser.js"; import { Stmt_getdiagContext } from "./PostgreSqlParser.js"; -import { Getdiag_area_optContext } from "./PostgreSqlParser.js"; -import { Getdiag_listContext } from "./PostgreSqlParser.js"; import { Getdiag_list_itemContext } from "./PostgreSqlParser.js"; -import { Getdiag_itemContext } from "./PostgreSqlParser.js"; -import { Getdiag_targetContext } from "./PostgreSqlParser.js"; import { Assign_varContext } from "./PostgreSqlParser.js"; import { Stmt_ifContext } from "./PostgreSqlParser.js"; -import { Stmt_elsifsContext } from "./PostgreSqlParser.js"; import { Stmt_elseContext } from "./PostgreSqlParser.js"; import { Stmt_caseContext } from "./PostgreSqlParser.js"; -import { Opt_expr_until_whenContext } from "./PostgreSqlParser.js"; -import { Case_when_listContext } from "./PostgreSqlParser.js"; -import { Case_whenContext } from "./PostgreSqlParser.js"; -import { Opt_case_elseContext } from "./PostgreSqlParser.js"; -import { Stmt_loopContext } from "./PostgreSqlParser.js"; -import { Stmt_whileContext } from "./PostgreSqlParser.js"; -import { Stmt_forContext } from "./PostgreSqlParser.js"; +import { Stmt_loop_while_forContext } from "./PostgreSqlParser.js"; import { For_controlContext } from "./PostgreSqlParser.js"; -import { Opt_for_using_expressionContext } from "./PostgreSqlParser.js"; -import { Opt_cursor_parametersContext } from "./PostgreSqlParser.js"; -import { Opt_reverseContext } from "./PostgreSqlParser.js"; -import { Opt_by_expressionContext } from "./PostgreSqlParser.js"; -import { For_variableContext } from "./PostgreSqlParser.js"; import { Stmt_foreach_aContext } from "./PostgreSqlParser.js"; -import { Foreach_sliceContext } from "./PostgreSqlParser.js"; import { Stmt_exitContext } from "./PostgreSqlParser.js"; -import { Exit_typeContext } from "./PostgreSqlParser.js"; import { Stmt_returnContext } from "./PostgreSqlParser.js"; -import { Opt_return_resultContext } from "./PostgreSqlParser.js"; import { Stmt_raiseContext } from "./PostgreSqlParser.js"; -import { Opt_stmt_raise_levelContext } from "./PostgreSqlParser.js"; -import { Opt_raise_listContext } from "./PostgreSqlParser.js"; -import { Opt_raise_usingContext } from "./PostgreSqlParser.js"; import { Opt_raise_using_elemContext } from "./PostgreSqlParser.js"; -import { Opt_raise_using_elem_listContext } from "./PostgreSqlParser.js"; import { Stmt_assertContext } from "./PostgreSqlParser.js"; -import { Opt_stmt_assert_messageContext } from "./PostgreSqlParser.js"; import { Loop_bodyContext } from "./PostgreSqlParser.js"; import { Stmt_execsqlContext } from "./PostgreSqlParser.js"; import { Stmt_dynexecuteContext } from "./PostgreSqlParser.js"; -import { Opt_execute_usingContext } from "./PostgreSqlParser.js"; -import { Opt_execute_using_listContext } from "./PostgreSqlParser.js"; import { Opt_execute_intoContext } from "./PostgreSqlParser.js"; import { Stmt_openContext } from "./PostgreSqlParser.js"; import { Opt_open_bound_list_itemContext } from "./PostgreSqlParser.js"; -import { Opt_open_bound_listContext } from "./PostgreSqlParser.js"; -import { Opt_open_usingContext } from "./PostgreSqlParser.js"; -import { Opt_scroll_optionContext } from "./PostgreSqlParser.js"; -import { Opt_scroll_option_noContext } from "./PostgreSqlParser.js"; import { Stmt_fetchContext } from "./PostgreSqlParser.js"; -import { Into_targetContext } from "./PostgreSqlParser.js"; -import { Opt_cursor_fromContext } from "./PostgreSqlParser.js"; import { Opt_fetch_directionContext } from "./PostgreSqlParser.js"; import { Stmt_moveContext } from "./PostgreSqlParser.js"; import { MergestmtContext } from "./PostgreSqlParser.js"; import { Data_sourceContext } from "./PostgreSqlParser.js"; -import { Join_conditionContext } from "./PostgreSqlParser.js"; import { Merge_when_clauseContext } from "./PostgreSqlParser.js"; import { Merge_insertContext } from "./PostgreSqlParser.js"; import { Merge_updateContext } from "./PostgreSqlParser.js"; import { Default_values_or_valuesContext } from "./PostgreSqlParser.js"; -import { ExprofdefaultlistContext } from "./PostgreSqlParser.js"; import { ExprofdefaultContext } from "./PostgreSqlParser.js"; import { Stmt_closeContext } from "./PostgreSqlParser.js"; import { Stmt_nullContext } from "./PostgreSqlParser.js"; -import { Stmt_commitContext } from "./PostgreSqlParser.js"; -import { Stmt_rollbackContext } from "./PostgreSqlParser.js"; -import { Plsql_opt_transaction_chainContext } from "./PostgreSqlParser.js"; +import { Stmt_commit_or_rollbackContext } from "./PostgreSqlParser.js"; import { Stmt_setContext } from "./PostgreSqlParser.js"; import { Cursor_variableContext } from "./PostgreSqlParser.js"; import { Exception_sectContext } from "./PostgreSqlParser.js"; -import { Proc_exceptionsContext } from "./PostgreSqlParser.js"; -import { Proc_exceptionContext } from "./PostgreSqlParser.js"; -import { Proc_conditionsContext } from "./PostgreSqlParser.js"; import { Proc_conditionContext } from "./PostgreSqlParser.js"; -import { Opt_block_labelContext } from "./PostgreSqlParser.js"; -import { Opt_loop_labelContext } from "./PostgreSqlParser.js"; -import { Opt_labelContext } from "./PostgreSqlParser.js"; -import { Opt_exitcondContext } from "./PostgreSqlParser.js"; import { Any_identifierContext } from "./PostgreSqlParser.js"; import { Plsql_unreserved_keywordContext } from "./PostgreSqlParser.js"; import { Sql_expressionContext } from "./PostgreSqlParser.js"; -import { Expr_until_thenContext } from "./PostgreSqlParser.js"; -import { Expr_until_semiContext } from "./PostgreSqlParser.js"; -import { Expr_until_rightbracketContext } from "./PostgreSqlParser.js"; -import { Expr_until_loopContext } from "./PostgreSqlParser.js"; -import { Make_execsql_stmtContext } from "./PostgreSqlParser.js"; -import { Opt_returning_clause_intoContext } from "./PostgreSqlParser.js"; /** @@ -908,16 +508,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitProgram?: (ctx: ProgramContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.plsqlroot`. - * @param ctx the parse tree - */ - enterPlsqlroot?: (ctx: PlsqlrootContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.plsqlroot`. - * @param ctx the parse tree - */ - exitPlsqlroot?: (ctx: PlsqlrootContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.singleStmt`. * @param ctx the parse tree @@ -938,16 +528,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitStmt?: (ctx: StmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.plsqlconsolecommand`. - * @param ctx the parse tree - */ - enterPlsqlconsolecommand?: (ctx: PlsqlconsolecommandContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.plsqlconsolecommand`. - * @param ctx the parse tree - */ - exitPlsqlconsolecommand?: (ctx: PlsqlconsolecommandContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.callstmt`. * @param ctx the parse tree @@ -968,36 +548,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitCreaterolestmt?: (ctx: CreaterolestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_with`. - * @param ctx the parse tree - */ - enterOpt_with?: (ctx: Opt_withContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_with`. - * @param ctx the parse tree - */ - exitOpt_with?: (ctx: Opt_withContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.optrolelist`. - * @param ctx the parse tree - */ - enterOptrolelist?: (ctx: OptrolelistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.optrolelist`. - * @param ctx the parse tree - */ - exitOptrolelist?: (ctx: OptrolelistContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alteroptrolelist`. - * @param ctx the parse tree - */ - enterAlteroptrolelist?: (ctx: AlteroptrolelistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alteroptrolelist`. - * @param ctx the parse tree - */ - exitAlteroptrolelist?: (ctx: AlteroptrolelistContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.alteroptroleelem`. * @param ctx the parse tree @@ -1038,16 +588,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitAlterrolestmt?: (ctx: AlterrolestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_in_database`. - * @param ctx the parse tree - */ - enterOpt_in_database?: (ctx: Opt_in_databaseContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_in_database`. - * @param ctx the parse tree - */ - exitOpt_in_database?: (ctx: Opt_in_databaseContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.alterrolesetstmt`. * @param ctx the parse tree @@ -1078,16 +618,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitAlter_routine_cluase?: (ctx: Alter_routine_cluaseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.routine_action_list`. - * @param ctx the parse tree - */ - enterRoutine_action_list?: (ctx: Routine_action_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.routine_action_list`. - * @param ctx the parse tree - */ - exitRoutine_action_list?: (ctx: Routine_action_listContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.routine_action`. * @param ctx the parse tree @@ -1118,16 +648,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitAltergroupstmt?: (ctx: AltergroupstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.add_drop`. - * @param ctx the parse tree - */ - enterAdd_drop?: (ctx: Add_dropContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.add_drop`. - * @param ctx the parse tree - */ - exitAdd_drop?: (ctx: Add_dropContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.createschemastmt`. * @param ctx the parse tree @@ -1150,16 +670,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitSchemaNameCreate?: (ctx: SchemaNameCreateContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.optschemaeltlist`. - * @param ctx the parse tree - */ - enterOptschemaeltlist?: (ctx: OptschemaeltlistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.optschemaeltlist`. - * @param ctx the parse tree - */ - exitOptschemaeltlist?: (ctx: OptschemaeltlistContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.schema_stmt`. * @param ctx the parse tree @@ -1280,26 +790,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitZone_value?: (ctx: Zone_valueContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_encoding`. - * @param ctx the parse tree - */ - enterOpt_encoding?: (ctx: Opt_encodingContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_encoding`. - * @param ctx the parse tree - */ - exitOpt_encoding?: (ctx: Opt_encodingContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.nonreservedword_or_sconst_column`. - * @param ctx the parse tree - */ - enterNonreservedword_or_sconst_column?: (ctx: Nonreservedword_or_sconst_columnContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.nonreservedword_or_sconst_column`. - * @param ctx the parse tree - */ - exitNonreservedword_or_sconst_column?: (ctx: Nonreservedword_or_sconst_columnContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.nonreservedword_or_sconst`. * @param ctx the parse tree @@ -1330,16 +820,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitReset_rest?: (ctx: Reset_restContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.generic_reset`. - * @param ctx the parse tree - */ - enterGeneric_reset?: (ctx: Generic_resetContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.generic_reset`. - * @param ctx the parse tree - */ - exitGeneric_reset?: (ctx: Generic_resetContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.setresetclause`. * @param ctx the parse tree @@ -1380,26 +860,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitConstraintssetstmt?: (ctx: ConstraintssetstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.constraints_set_list`. - * @param ctx the parse tree - */ - enterConstraints_set_list?: (ctx: Constraints_set_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.constraints_set_list`. - * @param ctx the parse tree - */ - exitConstraints_set_list?: (ctx: Constraints_set_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.constraints_set_mode`. - * @param ctx the parse tree - */ - enterConstraints_set_mode?: (ctx: Constraints_set_modeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.constraints_set_mode`. - * @param ctx the parse tree - */ - exitConstraints_set_mode?: (ctx: Constraints_set_modeContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.checkpointstmt`. * @param ctx the parse tree @@ -1540,26 +1000,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitOpt_collate_clause?: (ctx: Opt_collate_clauseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alter_using`. - * @param ctx the parse tree - */ - enterAlter_using?: (ctx: Alter_usingContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alter_using`. - * @param ctx the parse tree - */ - exitAlter_using?: (ctx: Alter_usingContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.replica_identity`. - * @param ctx the parse tree - */ - enterReplica_identity?: (ctx: Replica_identityContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.replica_identity`. - * @param ctx the parse tree - */ - exitReplica_identity?: (ctx: Replica_identityContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.reloptions`. * @param ctx the parse tree @@ -1580,16 +1020,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitOpt_reloptions?: (ctx: Opt_reloptionsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.reloption_list`. - * @param ctx the parse tree - */ - enterReloption_list?: (ctx: Reloption_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.reloption_list`. - * @param ctx the parse tree - */ - exitReloption_list?: (ctx: Reloption_listContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.reloption_elem`. * @param ctx the parse tree @@ -1600,26 +1030,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitReloption_elem?: (ctx: Reloption_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alter_identity_column_option_list`. - * @param ctx the parse tree - */ - enterAlter_identity_column_option_list?: (ctx: Alter_identity_column_option_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alter_identity_column_option_list`. - * @param ctx the parse tree - */ - exitAlter_identity_column_option_list?: (ctx: Alter_identity_column_option_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alter_identity_column_option`. - * @param ctx the parse tree - */ - enterAlter_identity_column_option?: (ctx: Alter_identity_column_optionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alter_identity_column_option`. - * @param ctx the parse tree - */ - exitAlter_identity_column_option?: (ctx: Alter_identity_column_optionContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.partitionboundspec`. * @param ctx the parse tree @@ -1630,26 +1040,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitPartitionboundspec?: (ctx: PartitionboundspecContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.hash_partbound_elem`. - * @param ctx the parse tree - */ - enterHash_partbound_elem?: (ctx: Hash_partbound_elemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.hash_partbound_elem`. - * @param ctx the parse tree - */ - exitHash_partbound_elem?: (ctx: Hash_partbound_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.hash_partbound`. - * @param ctx the parse tree - */ - enterHash_partbound?: (ctx: Hash_partboundContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.hash_partbound`. - * @param ctx the parse tree - */ - exitHash_partbound?: (ctx: Hash_partboundContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.altercompositetypestmt`. * @param ctx the parse tree @@ -1660,16 +1050,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitAltercompositetypestmt?: (ctx: AltercompositetypestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alter_type_cmds`. - * @param ctx the parse tree - */ - enterAlter_type_cmds?: (ctx: Alter_type_cmdsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alter_type_cmds`. - * @param ctx the parse tree - */ - exitAlter_type_cmds?: (ctx: Alter_type_cmdsContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.alter_type_cmd`. * @param ctx the parse tree @@ -1701,522 +1081,232 @@ export class PostgreSqlParserListener implements ParseTreeListener { */ exitCopystmt?: (ctx: CopystmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.copy_from`. + * Enter a parse tree produced by `PostgreSqlParser.copy_options`. * @param ctx the parse tree */ - enterCopy_from?: (ctx: Copy_fromContext) => void; + enterCopy_options?: (ctx: Copy_optionsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.copy_from`. + * Exit a parse tree produced by `PostgreSqlParser.copy_options`. * @param ctx the parse tree */ - exitCopy_from?: (ctx: Copy_fromContext) => void; + exitCopy_options?: (ctx: Copy_optionsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_program`. + * Enter a parse tree produced by `PostgreSqlParser.copy_generic_opt_elem`. * @param ctx the parse tree */ - enterOpt_program?: (ctx: Opt_programContext) => void; + enterCopy_generic_opt_elem?: (ctx: Copy_generic_opt_elemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_program`. + * Exit a parse tree produced by `PostgreSqlParser.copy_generic_opt_elem`. * @param ctx the parse tree */ - exitOpt_program?: (ctx: Opt_programContext) => void; + exitCopy_generic_opt_elem?: (ctx: Copy_generic_opt_elemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.copy_file_name`. + * Enter a parse tree produced by the `columnCreateTable` + * labeled alternative in `PostgreSqlParser.createstmt`. * @param ctx the parse tree */ - enterCopy_file_name?: (ctx: Copy_file_nameContext) => void; + enterColumnCreateTable?: (ctx: ColumnCreateTableContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.copy_file_name`. + * Exit a parse tree produced by the `columnCreateTable` + * labeled alternative in `PostgreSqlParser.createstmt`. * @param ctx the parse tree */ - exitCopy_file_name?: (ctx: Copy_file_nameContext) => void; + exitColumnCreateTable?: (ctx: ColumnCreateTableContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.copy_options`. + * Enter a parse tree produced by `PostgreSqlParser.opttemp`. * @param ctx the parse tree */ - enterCopy_options?: (ctx: Copy_optionsContext) => void; + enterOpttemp?: (ctx: OpttempContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.copy_options`. + * Exit a parse tree produced by `PostgreSqlParser.opttemp`. * @param ctx the parse tree */ - exitCopy_options?: (ctx: Copy_optionsContext) => void; + exitOpttemp?: (ctx: OpttempContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.copy_opt_list`. + * Enter a parse tree produced by `PostgreSqlParser.opttypedtableelementlist`. * @param ctx the parse tree */ - enterCopy_opt_list?: (ctx: Copy_opt_listContext) => void; + enterOpttypedtableelementlist?: (ctx: OpttypedtableelementlistContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.copy_opt_list`. + * Exit a parse tree produced by `PostgreSqlParser.opttypedtableelementlist`. * @param ctx the parse tree */ - exitCopy_opt_list?: (ctx: Copy_opt_listContext) => void; + exitOpttypedtableelementlist?: (ctx: OpttypedtableelementlistContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.copy_opt_item`. + * Enter a parse tree produced by `PostgreSqlParser.tableelementlist`. * @param ctx the parse tree */ - enterCopy_opt_item?: (ctx: Copy_opt_itemContext) => void; + enterTableelementlist?: (ctx: TableelementlistContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.copy_opt_item`. + * Exit a parse tree produced by `PostgreSqlParser.tableelementlist`. * @param ctx the parse tree */ - exitCopy_opt_item?: (ctx: Copy_opt_itemContext) => void; + exitTableelementlist?: (ctx: TableelementlistContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_binary`. + * Enter a parse tree produced by `PostgreSqlParser.tableelement`. * @param ctx the parse tree */ - enterOpt_binary?: (ctx: Opt_binaryContext) => void; + enterTableelement?: (ctx: TableelementContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_binary`. + * Exit a parse tree produced by `PostgreSqlParser.tableelement`. * @param ctx the parse tree */ - exitOpt_binary?: (ctx: Opt_binaryContext) => void; + exitTableelement?: (ctx: TableelementContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.copy_delimiter`. + * Enter a parse tree produced by `PostgreSqlParser.typedtableelement`. * @param ctx the parse tree */ - enterCopy_delimiter?: (ctx: Copy_delimiterContext) => void; + enterTypedtableelement?: (ctx: TypedtableelementContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.copy_delimiter`. + * Exit a parse tree produced by `PostgreSqlParser.typedtableelement`. * @param ctx the parse tree */ - exitCopy_delimiter?: (ctx: Copy_delimiterContext) => void; + exitTypedtableelement?: (ctx: TypedtableelementContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_using`. + * Enter a parse tree produced by `PostgreSqlParser.column_def`. * @param ctx the parse tree */ - enterOpt_using?: (ctx: Opt_usingContext) => void; + enterColumn_def?: (ctx: Column_defContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_using`. + * Exit a parse tree produced by `PostgreSqlParser.column_def`. * @param ctx the parse tree */ - exitOpt_using?: (ctx: Opt_usingContext) => void; + exitColumn_def?: (ctx: Column_defContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.copy_generic_opt_list`. + * Enter a parse tree produced by `PostgreSqlParser.colconstraint`. * @param ctx the parse tree */ - enterCopy_generic_opt_list?: (ctx: Copy_generic_opt_listContext) => void; + enterColconstraint?: (ctx: ColconstraintContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.copy_generic_opt_list`. + * Exit a parse tree produced by `PostgreSqlParser.colconstraint`. * @param ctx the parse tree */ - exitCopy_generic_opt_list?: (ctx: Copy_generic_opt_listContext) => void; + exitColconstraint?: (ctx: ColconstraintContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.copy_generic_opt_elem`. + * Enter a parse tree produced by `PostgreSqlParser.colconstraintelem`. * @param ctx the parse tree */ - enterCopy_generic_opt_elem?: (ctx: Copy_generic_opt_elemContext) => void; + enterColconstraintelem?: (ctx: ColconstraintelemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.copy_generic_opt_elem`. + * Exit a parse tree produced by `PostgreSqlParser.colconstraintelem`. * @param ctx the parse tree */ - exitCopy_generic_opt_elem?: (ctx: Copy_generic_opt_elemContext) => void; + exitColconstraintelem?: (ctx: ColconstraintelemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.copy_generic_opt_arg`. + * Enter a parse tree produced by `PostgreSqlParser.generated_when`. * @param ctx the parse tree */ - enterCopy_generic_opt_arg?: (ctx: Copy_generic_opt_argContext) => void; + enterGenerated_when?: (ctx: Generated_whenContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.copy_generic_opt_arg`. + * Exit a parse tree produced by `PostgreSqlParser.generated_when`. * @param ctx the parse tree */ - exitCopy_generic_opt_arg?: (ctx: Copy_generic_opt_argContext) => void; + exitGenerated_when?: (ctx: Generated_whenContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.copy_generic_opt_arg_list`. + * Enter a parse tree produced by `PostgreSqlParser.tablelikeoption`. * @param ctx the parse tree */ - enterCopy_generic_opt_arg_list?: (ctx: Copy_generic_opt_arg_listContext) => void; + enterTablelikeoption?: (ctx: TablelikeoptionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.copy_generic_opt_arg_list`. + * Exit a parse tree produced by `PostgreSqlParser.tablelikeoption`. * @param ctx the parse tree */ - exitCopy_generic_opt_arg_list?: (ctx: Copy_generic_opt_arg_listContext) => void; + exitTablelikeoption?: (ctx: TablelikeoptionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.copy_generic_opt_arg_list_item`. + * Enter a parse tree produced by `PostgreSqlParser.constraintelem`. * @param ctx the parse tree */ - enterCopy_generic_opt_arg_list_item?: (ctx: Copy_generic_opt_arg_list_itemContext) => void; + enterConstraintelem?: (ctx: ConstraintelemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.copy_generic_opt_arg_list_item`. + * Exit a parse tree produced by `PostgreSqlParser.constraintelem`. * @param ctx the parse tree */ - exitCopy_generic_opt_arg_list_item?: (ctx: Copy_generic_opt_arg_list_itemContext) => void; + exitConstraintelem?: (ctx: ConstraintelemContext) => void; /** - * Enter a parse tree produced by the `columnCreateTable` - * labeled alternative in `PostgreSqlParser.createstmt`. + * Enter a parse tree produced by `PostgreSqlParser.opt_column_list`. * @param ctx the parse tree */ - enterColumnCreateTable?: (ctx: ColumnCreateTableContext) => void; + enterOpt_column_list?: (ctx: Opt_column_listContext) => void; /** - * Exit a parse tree produced by the `columnCreateTable` - * labeled alternative in `PostgreSqlParser.createstmt`. + * Exit a parse tree produced by `PostgreSqlParser.opt_column_list`. * @param ctx the parse tree */ - exitColumnCreateTable?: (ctx: ColumnCreateTableContext) => void; + exitOpt_column_list?: (ctx: Opt_column_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opttemp`. + * Enter a parse tree produced by `PostgreSqlParser.opt_column_list_create`. * @param ctx the parse tree */ - enterOpttemp?: (ctx: OpttempContext) => void; + enterOpt_column_list_create?: (ctx: Opt_column_list_createContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opttemp`. + * Exit a parse tree produced by `PostgreSqlParser.opt_column_list_create`. * @param ctx the parse tree */ - exitOpttemp?: (ctx: OpttempContext) => void; + exitOpt_column_list_create?: (ctx: Opt_column_list_createContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.table_column_list`. + * Enter a parse tree produced by `PostgreSqlParser.column_list`. * @param ctx the parse tree */ - enterTable_column_list?: (ctx: Table_column_listContext) => void; + enterColumn_list?: (ctx: Column_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.table_column_list`. + * Exit a parse tree produced by `PostgreSqlParser.column_list`. * @param ctx the parse tree */ - exitTable_column_list?: (ctx: Table_column_listContext) => void; + exitColumn_list?: (ctx: Column_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opttableelementlist`. + * Enter a parse tree produced by `PostgreSqlParser.opt_c_include`. * @param ctx the parse tree */ - enterOpttableelementlist?: (ctx: OpttableelementlistContext) => void; + enterOpt_c_include?: (ctx: Opt_c_includeContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opttableelementlist`. + * Exit a parse tree produced by `PostgreSqlParser.opt_c_include`. * @param ctx the parse tree */ - exitOpttableelementlist?: (ctx: OpttableelementlistContext) => void; + exitOpt_c_include?: (ctx: Opt_c_includeContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opttypedtableelementlist`. + * Enter a parse tree produced by `PostgreSqlParser.key_match`. * @param ctx the parse tree */ - enterOpttypedtableelementlist?: (ctx: OpttypedtableelementlistContext) => void; + enterKey_match?: (ctx: Key_matchContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opttypedtableelementlist`. + * Exit a parse tree produced by `PostgreSqlParser.key_match`. * @param ctx the parse tree */ - exitOpttypedtableelementlist?: (ctx: OpttypedtableelementlistContext) => void; + exitKey_match?: (ctx: Key_matchContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.tableelementlist`. + * Enter a parse tree produced by `PostgreSqlParser.exclusionconstraintelem`. * @param ctx the parse tree */ - enterTableelementlist?: (ctx: TableelementlistContext) => void; + enterExclusionconstraintelem?: (ctx: ExclusionconstraintelemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.tableelementlist`. + * Exit a parse tree produced by `PostgreSqlParser.exclusionconstraintelem`. * @param ctx the parse tree */ - exitTableelementlist?: (ctx: TableelementlistContext) => void; + exitExclusionconstraintelem?: (ctx: ExclusionconstraintelemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.typedtableelementlist`. + * Enter a parse tree produced by `PostgreSqlParser.key_actions`. * @param ctx the parse tree */ - enterTypedtableelementlist?: (ctx: TypedtableelementlistContext) => void; + enterKey_actions?: (ctx: Key_actionsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.typedtableelementlist`. + * Exit a parse tree produced by `PostgreSqlParser.key_actions`. * @param ctx the parse tree */ - exitTypedtableelementlist?: (ctx: TypedtableelementlistContext) => void; + exitKey_actions?: (ctx: Key_actionsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.tableelement`. + * Enter a parse tree produced by `PostgreSqlParser.key_update`. * @param ctx the parse tree */ - enterTableelement?: (ctx: TableelementContext) => void; + enterKey_update?: (ctx: Key_updateContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.tableelement`. + * Exit a parse tree produced by `PostgreSqlParser.key_update`. * @param ctx the parse tree */ - exitTableelement?: (ctx: TableelementContext) => void; + exitKey_update?: (ctx: Key_updateContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.typedtableelement`. + * Enter a parse tree produced by `PostgreSqlParser.key_delete`. * @param ctx the parse tree */ - enterTypedtableelement?: (ctx: TypedtableelementContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.typedtableelement`. - * @param ctx the parse tree - */ - exitTypedtableelement?: (ctx: TypedtableelementContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.column_def`. - * @param ctx the parse tree - */ - enterColumn_def?: (ctx: Column_defContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.column_def`. - * @param ctx the parse tree - */ - exitColumn_def?: (ctx: Column_defContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.compressionCluase`. - * @param ctx the parse tree - */ - enterCompressionCluase?: (ctx: CompressionCluaseContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.compressionCluase`. - * @param ctx the parse tree - */ - exitCompressionCluase?: (ctx: CompressionCluaseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.storageCluase`. - * @param ctx the parse tree - */ - enterStorageCluase?: (ctx: StorageCluaseContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.storageCluase`. - * @param ctx the parse tree - */ - exitStorageCluase?: (ctx: StorageCluaseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.columnOptions`. - * @param ctx the parse tree - */ - enterColumnOptions?: (ctx: ColumnOptionsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.columnOptions`. - * @param ctx the parse tree - */ - exitColumnOptions?: (ctx: ColumnOptionsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.colquallist`. - * @param ctx the parse tree - */ - enterColquallist?: (ctx: ColquallistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.colquallist`. - * @param ctx the parse tree - */ - exitColquallist?: (ctx: ColquallistContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.colconstraint`. - * @param ctx the parse tree - */ - enterColconstraint?: (ctx: ColconstraintContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.colconstraint`. - * @param ctx the parse tree - */ - exitColconstraint?: (ctx: ColconstraintContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.colconstraintelem`. - * @param ctx the parse tree - */ - enterColconstraintelem?: (ctx: ColconstraintelemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.colconstraintelem`. - * @param ctx the parse tree - */ - exitColconstraintelem?: (ctx: ColconstraintelemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.nulls_distinct`. - * @param ctx the parse tree - */ - enterNulls_distinct?: (ctx: Nulls_distinctContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.nulls_distinct`. - * @param ctx the parse tree - */ - exitNulls_distinct?: (ctx: Nulls_distinctContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.generated_when`. - * @param ctx the parse tree - */ - enterGenerated_when?: (ctx: Generated_whenContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.generated_when`. - * @param ctx the parse tree - */ - exitGenerated_when?: (ctx: Generated_whenContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.deferrable_trigger`. - * @param ctx the parse tree - */ - enterDeferrable_trigger?: (ctx: Deferrable_triggerContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.deferrable_trigger`. - * @param ctx the parse tree - */ - exitDeferrable_trigger?: (ctx: Deferrable_triggerContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.initially_trigger`. - * @param ctx the parse tree - */ - enterInitially_trigger?: (ctx: Initially_triggerContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.initially_trigger`. - * @param ctx the parse tree - */ - exitInitially_trigger?: (ctx: Initially_triggerContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.tablelikeclause`. - * @param ctx the parse tree - */ - enterTablelikeclause?: (ctx: TablelikeclauseContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.tablelikeclause`. - * @param ctx the parse tree - */ - exitTablelikeclause?: (ctx: TablelikeclauseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.tablelikeoptionlist`. - * @param ctx the parse tree - */ - enterTablelikeoptionlist?: (ctx: TablelikeoptionlistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.tablelikeoptionlist`. - * @param ctx the parse tree - */ - exitTablelikeoptionlist?: (ctx: TablelikeoptionlistContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.tablelikeoption`. - * @param ctx the parse tree - */ - enterTablelikeoption?: (ctx: TablelikeoptionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.tablelikeoption`. - * @param ctx the parse tree - */ - exitTablelikeoption?: (ctx: TablelikeoptionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.tableconstraint`. - * @param ctx the parse tree - */ - enterTableconstraint?: (ctx: TableconstraintContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.tableconstraint`. - * @param ctx the parse tree - */ - exitTableconstraint?: (ctx: TableconstraintContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.constraintelem`. - * @param ctx the parse tree - */ - enterConstraintelem?: (ctx: ConstraintelemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.constraintelem`. - * @param ctx the parse tree - */ - exitConstraintelem?: (ctx: ConstraintelemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_no_inherit`. - * @param ctx the parse tree - */ - enterOpt_no_inherit?: (ctx: Opt_no_inheritContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_no_inherit`. - * @param ctx the parse tree - */ - exitOpt_no_inherit?: (ctx: Opt_no_inheritContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_column_list`. - * @param ctx the parse tree - */ - enterOpt_column_list?: (ctx: Opt_column_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_column_list`. - * @param ctx the parse tree - */ - exitOpt_column_list?: (ctx: Opt_column_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_column_list_create`. - * @param ctx the parse tree - */ - enterOpt_column_list_create?: (ctx: Opt_column_list_createContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_column_list_create`. - * @param ctx the parse tree - */ - exitOpt_column_list_create?: (ctx: Opt_column_list_createContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.column_list`. - * @param ctx the parse tree - */ - enterColumn_list?: (ctx: Column_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.column_list`. - * @param ctx the parse tree - */ - exitColumn_list?: (ctx: Column_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.column_list_create`. - * @param ctx the parse tree - */ - enterColumn_list_create?: (ctx: Column_list_createContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.column_list_create`. - * @param ctx the parse tree - */ - exitColumn_list_create?: (ctx: Column_list_createContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_c_include`. - * @param ctx the parse tree - */ - enterOpt_c_include?: (ctx: Opt_c_includeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_c_include`. - * @param ctx the parse tree - */ - exitOpt_c_include?: (ctx: Opt_c_includeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.key_match`. - * @param ctx the parse tree - */ - enterKey_match?: (ctx: Key_matchContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.key_match`. - * @param ctx the parse tree - */ - exitKey_match?: (ctx: Key_matchContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.exclusionconstraintlist`. - * @param ctx the parse tree - */ - enterExclusionconstraintlist?: (ctx: ExclusionconstraintlistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.exclusionconstraintlist`. - * @param ctx the parse tree - */ - exitExclusionconstraintlist?: (ctx: ExclusionconstraintlistContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.exclusionconstraintelem`. - * @param ctx the parse tree - */ - enterExclusionconstraintelem?: (ctx: ExclusionconstraintelemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.exclusionconstraintelem`. - * @param ctx the parse tree - */ - exitExclusionconstraintelem?: (ctx: ExclusionconstraintelemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.exclusionwhereclause`. - * @param ctx the parse tree - */ - enterExclusionwhereclause?: (ctx: ExclusionwhereclauseContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.exclusionwhereclause`. - * @param ctx the parse tree - */ - exitExclusionwhereclause?: (ctx: ExclusionwhereclauseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.key_actions`. - * @param ctx the parse tree - */ - enterKey_actions?: (ctx: Key_actionsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.key_actions`. - * @param ctx the parse tree - */ - exitKey_actions?: (ctx: Key_actionsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.key_update`. - * @param ctx the parse tree - */ - enterKey_update?: (ctx: Key_updateContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.key_update`. - * @param ctx the parse tree - */ - exitKey_update?: (ctx: Key_updateContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.key_delete`. - * @param ctx the parse tree - */ - enterKey_delete?: (ctx: Key_deleteContext) => void; + enterKey_delete?: (ctx: Key_deleteContext) => void; /** * Exit a parse tree produced by `PostgreSqlParser.key_delete`. * @param ctx the parse tree @@ -2242,16 +1332,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitOptinherit?: (ctx: OptinheritContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.optpartitionspec`. - * @param ctx the parse tree - */ - enterOptpartitionspec?: (ctx: OptpartitionspecContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.optpartitionspec`. - * @param ctx the parse tree - */ - exitOptpartitionspec?: (ctx: OptpartitionspecContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.partitionspec`. * @param ctx the parse tree @@ -2262,16 +1342,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitPartitionspec?: (ctx: PartitionspecContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.part_params`. - * @param ctx the parse tree - */ - enterPart_params?: (ctx: Part_paramsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.part_params`. - * @param ctx the parse tree - */ - exitPart_params?: (ctx: Part_paramsContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.part_elem`. * @param ctx the parse tree @@ -2322,16 +1392,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitOpttablespace?: (ctx: OpttablespaceContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.index_paramenters_create`. - * @param ctx the parse tree - */ - enterIndex_paramenters_create?: (ctx: Index_paramenters_createContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.index_paramenters_create`. - * @param ctx the parse tree - */ - exitIndex_paramenters_create?: (ctx: Index_paramenters_createContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.optconstablespace`. * @param ctx the parse tree @@ -2416,6744 +1476,3630 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitCreateMaterializedView?: (ctx: CreateMaterializedViewContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.create_mv_target`. - * @param ctx the parse tree - */ - enterCreate_mv_target?: (ctx: Create_mv_targetContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.create_mv_target`. - * @param ctx the parse tree - */ - exitCreate_mv_target?: (ctx: Create_mv_targetContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.optnolog`. - * @param ctx the parse tree - */ - enterOptnolog?: (ctx: OptnologContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.optnolog`. - * @param ctx the parse tree - */ - exitOptnolog?: (ctx: OptnologContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.refreshmatviewstmt`. * @param ctx the parse tree */ - enterRefreshmatviewstmt?: (ctx: RefreshmatviewstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.refreshmatviewstmt`. - * @param ctx the parse tree - */ - exitRefreshmatviewstmt?: (ctx: RefreshmatviewstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createseqstmt`. - * @param ctx the parse tree - */ - enterCreateseqstmt?: (ctx: CreateseqstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createseqstmt`. - * @param ctx the parse tree - */ - exitCreateseqstmt?: (ctx: CreateseqstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterseqstmt`. - * @param ctx the parse tree - */ - enterAlterseqstmt?: (ctx: AlterseqstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterseqstmt`. - * @param ctx the parse tree - */ - exitAlterseqstmt?: (ctx: AlterseqstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.optseqoptlist`. - * @param ctx the parse tree - */ - enterOptseqoptlist?: (ctx: OptseqoptlistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.optseqoptlist`. - * @param ctx the parse tree - */ - exitOptseqoptlist?: (ctx: OptseqoptlistContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.optparenthesizedseqoptlist`. - * @param ctx the parse tree - */ - enterOptparenthesizedseqoptlist?: (ctx: OptparenthesizedseqoptlistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.optparenthesizedseqoptlist`. - * @param ctx the parse tree - */ - exitOptparenthesizedseqoptlist?: (ctx: OptparenthesizedseqoptlistContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.seqoptlist`. - * @param ctx the parse tree - */ - enterSeqoptlist?: (ctx: SeqoptlistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.seqoptlist`. - * @param ctx the parse tree - */ - exitSeqoptlist?: (ctx: SeqoptlistContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.seqoptelem`. - * @param ctx the parse tree - */ - enterSeqoptelem?: (ctx: SeqoptelemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.seqoptelem`. - * @param ctx the parse tree - */ - exitSeqoptelem?: (ctx: SeqoptelemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_by`. - * @param ctx the parse tree - */ - enterOpt_by?: (ctx: Opt_byContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_by`. - * @param ctx the parse tree - */ - exitOpt_by?: (ctx: Opt_byContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.numericonly`. - * @param ctx the parse tree - */ - enterNumericonly?: (ctx: NumericonlyContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.numericonly`. - * @param ctx the parse tree - */ - exitNumericonly?: (ctx: NumericonlyContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.numericonly_list`. - * @param ctx the parse tree - */ - enterNumericonly_list?: (ctx: Numericonly_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.numericonly_list`. - * @param ctx the parse tree - */ - exitNumericonly_list?: (ctx: Numericonly_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createplangstmt`. - * @param ctx the parse tree - */ - enterCreateplangstmt?: (ctx: CreateplangstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createplangstmt`. - * @param ctx the parse tree - */ - exitCreateplangstmt?: (ctx: CreateplangstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_trusted`. - * @param ctx the parse tree - */ - enterOpt_trusted?: (ctx: Opt_trustedContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_trusted`. - * @param ctx the parse tree - */ - exitOpt_trusted?: (ctx: Opt_trustedContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.handler_name`. - * @param ctx the parse tree - */ - enterHandler_name?: (ctx: Handler_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.handler_name`. - * @param ctx the parse tree - */ - exitHandler_name?: (ctx: Handler_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_inline_handler`. - * @param ctx the parse tree - */ - enterOpt_inline_handler?: (ctx: Opt_inline_handlerContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_inline_handler`. - * @param ctx the parse tree - */ - exitOpt_inline_handler?: (ctx: Opt_inline_handlerContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.validator_clause`. - * @param ctx the parse tree - */ - enterValidator_clause?: (ctx: Validator_clauseContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.validator_clause`. - * @param ctx the parse tree - */ - exitValidator_clause?: (ctx: Validator_clauseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_validator`. - * @param ctx the parse tree - */ - enterOpt_validator?: (ctx: Opt_validatorContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_validator`. - * @param ctx the parse tree - */ - exitOpt_validator?: (ctx: Opt_validatorContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_procedural`. - * @param ctx the parse tree - */ - enterOpt_procedural?: (ctx: Opt_proceduralContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_procedural`. - * @param ctx the parse tree - */ - exitOpt_procedural?: (ctx: Opt_proceduralContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createtablespacestmt`. - * @param ctx the parse tree - */ - enterCreatetablespacestmt?: (ctx: CreatetablespacestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createtablespacestmt`. - * @param ctx the parse tree - */ - exitCreatetablespacestmt?: (ctx: CreatetablespacestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opttablespaceowner`. - * @param ctx the parse tree - */ - enterOpttablespaceowner?: (ctx: OpttablespaceownerContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opttablespaceowner`. - * @param ctx the parse tree - */ - exitOpttablespaceowner?: (ctx: OpttablespaceownerContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createextensionstmt`. - * @param ctx the parse tree - */ - enterCreateextensionstmt?: (ctx: CreateextensionstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createextensionstmt`. - * @param ctx the parse tree - */ - exitCreateextensionstmt?: (ctx: CreateextensionstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.create_extension_opt_list`. - * @param ctx the parse tree - */ - enterCreate_extension_opt_list?: (ctx: Create_extension_opt_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.create_extension_opt_list`. - * @param ctx the parse tree - */ - exitCreate_extension_opt_list?: (ctx: Create_extension_opt_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.create_extension_opt_item`. - * @param ctx the parse tree - */ - enterCreate_extension_opt_item?: (ctx: Create_extension_opt_itemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.create_extension_opt_item`. - * @param ctx the parse tree - */ - exitCreate_extension_opt_item?: (ctx: Create_extension_opt_itemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterextensionstmt`. - * @param ctx the parse tree - */ - enterAlterextensionstmt?: (ctx: AlterextensionstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterextensionstmt`. - * @param ctx the parse tree - */ - exitAlterextensionstmt?: (ctx: AlterextensionstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alter_extension_opt_list`. - * @param ctx the parse tree - */ - enterAlter_extension_opt_list?: (ctx: Alter_extension_opt_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alter_extension_opt_list`. - * @param ctx the parse tree - */ - exitAlter_extension_opt_list?: (ctx: Alter_extension_opt_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alter_extension_opt_item`. - * @param ctx the parse tree - */ - enterAlter_extension_opt_item?: (ctx: Alter_extension_opt_itemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alter_extension_opt_item`. - * @param ctx the parse tree - */ - exitAlter_extension_opt_item?: (ctx: Alter_extension_opt_itemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterextensioncontentsstmt`. - * @param ctx the parse tree - */ - enterAlterextensioncontentsstmt?: (ctx: AlterextensioncontentsstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterextensioncontentsstmt`. - * @param ctx the parse tree - */ - exitAlterextensioncontentsstmt?: (ctx: AlterextensioncontentsstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createfdwstmt`. - * @param ctx the parse tree - */ - enterCreatefdwstmt?: (ctx: CreatefdwstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createfdwstmt`. - * @param ctx the parse tree - */ - exitCreatefdwstmt?: (ctx: CreatefdwstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.fdw_option`. - * @param ctx the parse tree - */ - enterFdw_option?: (ctx: Fdw_optionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.fdw_option`. - * @param ctx the parse tree - */ - exitFdw_option?: (ctx: Fdw_optionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.fdw_options`. - * @param ctx the parse tree - */ - enterFdw_options?: (ctx: Fdw_optionsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.fdw_options`. - * @param ctx the parse tree - */ - exitFdw_options?: (ctx: Fdw_optionsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_fdw_options`. - * @param ctx the parse tree - */ - enterOpt_fdw_options?: (ctx: Opt_fdw_optionsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_fdw_options`. - * @param ctx the parse tree - */ - exitOpt_fdw_options?: (ctx: Opt_fdw_optionsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterfdwstmt`. - * @param ctx the parse tree - */ - enterAlterfdwstmt?: (ctx: AlterfdwstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterfdwstmt`. - * @param ctx the parse tree - */ - exitAlterfdwstmt?: (ctx: AlterfdwstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.create_generic_options`. - * @param ctx the parse tree - */ - enterCreate_generic_options?: (ctx: Create_generic_optionsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.create_generic_options`. - * @param ctx the parse tree - */ - exitCreate_generic_options?: (ctx: Create_generic_optionsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.generic_option_list`. - * @param ctx the parse tree - */ - enterGeneric_option_list?: (ctx: Generic_option_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.generic_option_list`. - * @param ctx the parse tree - */ - exitGeneric_option_list?: (ctx: Generic_option_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alter_generic_options`. - * @param ctx the parse tree - */ - enterAlter_generic_options?: (ctx: Alter_generic_optionsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alter_generic_options`. - * @param ctx the parse tree - */ - exitAlter_generic_options?: (ctx: Alter_generic_optionsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alter_generic_option_list`. - * @param ctx the parse tree - */ - enterAlter_generic_option_list?: (ctx: Alter_generic_option_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alter_generic_option_list`. - * @param ctx the parse tree - */ - exitAlter_generic_option_list?: (ctx: Alter_generic_option_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alter_generic_option_elem`. - * @param ctx the parse tree - */ - enterAlter_generic_option_elem?: (ctx: Alter_generic_option_elemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alter_generic_option_elem`. - * @param ctx the parse tree - */ - exitAlter_generic_option_elem?: (ctx: Alter_generic_option_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.generic_option_elem`. - * @param ctx the parse tree - */ - enterGeneric_option_elem?: (ctx: Generic_option_elemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.generic_option_elem`. - * @param ctx the parse tree - */ - exitGeneric_option_elem?: (ctx: Generic_option_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.generic_option_name`. - * @param ctx the parse tree - */ - enterGeneric_option_name?: (ctx: Generic_option_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.generic_option_name`. - * @param ctx the parse tree - */ - exitGeneric_option_name?: (ctx: Generic_option_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.generic_option_arg`. - * @param ctx the parse tree - */ - enterGeneric_option_arg?: (ctx: Generic_option_argContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.generic_option_arg`. - * @param ctx the parse tree - */ - exitGeneric_option_arg?: (ctx: Generic_option_argContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createforeignserverstmt`. - * @param ctx the parse tree - */ - enterCreateforeignserverstmt?: (ctx: CreateforeignserverstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createforeignserverstmt`. - * @param ctx the parse tree - */ - exitCreateforeignserverstmt?: (ctx: CreateforeignserverstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_type`. - * @param ctx the parse tree - */ - enterOpt_type?: (ctx: Opt_typeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_type`. - * @param ctx the parse tree - */ - exitOpt_type?: (ctx: Opt_typeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.foreign_server_version`. - * @param ctx the parse tree - */ - enterForeign_server_version?: (ctx: Foreign_server_versionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.foreign_server_version`. - * @param ctx the parse tree - */ - exitForeign_server_version?: (ctx: Foreign_server_versionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_foreign_server_version`. - * @param ctx the parse tree - */ - enterOpt_foreign_server_version?: (ctx: Opt_foreign_server_versionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_foreign_server_version`. - * @param ctx the parse tree - */ - exitOpt_foreign_server_version?: (ctx: Opt_foreign_server_versionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterforeignserverstmt`. - * @param ctx the parse tree - */ - enterAlterforeignserverstmt?: (ctx: AlterforeignserverstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterforeignserverstmt`. - * @param ctx the parse tree - */ - exitAlterforeignserverstmt?: (ctx: AlterforeignserverstmtContext) => void; - /** - * Enter a parse tree produced by the `createForeignTable` - * labeled alternative in `PostgreSqlParser.createforeigntablestmt`. - * @param ctx the parse tree - */ - enterCreateForeignTable?: (ctx: CreateForeignTableContext) => void; - /** - * Exit a parse tree produced by the `createForeignTable` - * labeled alternative in `PostgreSqlParser.createforeigntablestmt`. - * @param ctx the parse tree - */ - exitCreateForeignTable?: (ctx: CreateForeignTableContext) => void; - /** - * Enter a parse tree produced by the `createPartitionForeignTable` - * labeled alternative in `PostgreSqlParser.createforeigntablestmt`. - * @param ctx the parse tree - */ - enterCreatePartitionForeignTable?: (ctx: CreatePartitionForeignTableContext) => void; - /** - * Exit a parse tree produced by the `createPartitionForeignTable` - * labeled alternative in `PostgreSqlParser.createforeigntablestmt`. - * @param ctx the parse tree - */ - exitCreatePartitionForeignTable?: (ctx: CreatePartitionForeignTableContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.importforeignschemastmt`. - * @param ctx the parse tree - */ - enterImportforeignschemastmt?: (ctx: ImportforeignschemastmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.importforeignschemastmt`. - * @param ctx the parse tree - */ - exitImportforeignschemastmt?: (ctx: ImportforeignschemastmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.import_qualification_type`. - * @param ctx the parse tree - */ - enterImport_qualification_type?: (ctx: Import_qualification_typeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.import_qualification_type`. - * @param ctx the parse tree - */ - exitImport_qualification_type?: (ctx: Import_qualification_typeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.import_qualification`. - * @param ctx the parse tree - */ - enterImport_qualification?: (ctx: Import_qualificationContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.import_qualification`. - * @param ctx the parse tree - */ - exitImport_qualification?: (ctx: Import_qualificationContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createusermappingstmt`. - * @param ctx the parse tree - */ - enterCreateusermappingstmt?: (ctx: CreateusermappingstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createusermappingstmt`. - * @param ctx the parse tree - */ - exitCreateusermappingstmt?: (ctx: CreateusermappingstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.auth_ident`. - * @param ctx the parse tree - */ - enterAuth_ident?: (ctx: Auth_identContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.auth_ident`. - * @param ctx the parse tree - */ - exitAuth_ident?: (ctx: Auth_identContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterusermappingstmt`. - * @param ctx the parse tree - */ - enterAlterusermappingstmt?: (ctx: AlterusermappingstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterusermappingstmt`. - * @param ctx the parse tree - */ - exitAlterusermappingstmt?: (ctx: AlterusermappingstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createpolicystmt`. - * @param ctx the parse tree - */ - enterCreatepolicystmt?: (ctx: CreatepolicystmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createpolicystmt`. - * @param ctx the parse tree - */ - exitCreatepolicystmt?: (ctx: CreatepolicystmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterpolicystmt`. - * @param ctx the parse tree - */ - enterAlterpolicystmt?: (ctx: AlterpolicystmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterpolicystmt`. - * @param ctx the parse tree - */ - exitAlterpolicystmt?: (ctx: AlterpolicystmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterprocedurestmt`. - * @param ctx the parse tree - */ - enterAlterprocedurestmt?: (ctx: AlterprocedurestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterprocedurestmt`. - * @param ctx the parse tree - */ - exitAlterprocedurestmt?: (ctx: AlterprocedurestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.procedure_cluase`. - * @param ctx the parse tree - */ - enterProcedure_cluase?: (ctx: Procedure_cluaseContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.procedure_cluase`. - * @param ctx the parse tree - */ - exitProcedure_cluase?: (ctx: Procedure_cluaseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.procedure_action`. - * @param ctx the parse tree - */ - enterProcedure_action?: (ctx: Procedure_actionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.procedure_action`. - * @param ctx the parse tree - */ - exitProcedure_action?: (ctx: Procedure_actionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.rowsecurityoptionalexpr`. - * @param ctx the parse tree - */ - enterRowsecurityoptionalexpr?: (ctx: RowsecurityoptionalexprContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.rowsecurityoptionalexpr`. - * @param ctx the parse tree - */ - exitRowsecurityoptionalexpr?: (ctx: RowsecurityoptionalexprContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.rowsecurityoptionalwithcheck`. - * @param ctx the parse tree - */ - enterRowsecurityoptionalwithcheck?: (ctx: RowsecurityoptionalwithcheckContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.rowsecurityoptionalwithcheck`. - * @param ctx the parse tree - */ - exitRowsecurityoptionalwithcheck?: (ctx: RowsecurityoptionalwithcheckContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.rowsecuritydefaulttorole`. - * @param ctx the parse tree - */ - enterRowsecuritydefaulttorole?: (ctx: RowsecuritydefaulttoroleContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.rowsecuritydefaulttorole`. - * @param ctx the parse tree - */ - exitRowsecuritydefaulttorole?: (ctx: RowsecuritydefaulttoroleContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.rowsecurityoptionaltorole`. - * @param ctx the parse tree - */ - enterRowsecurityoptionaltorole?: (ctx: RowsecurityoptionaltoroleContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.rowsecurityoptionaltorole`. - * @param ctx the parse tree - */ - exitRowsecurityoptionaltorole?: (ctx: RowsecurityoptionaltoroleContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.rowsecuritydefaultpermissive`. - * @param ctx the parse tree - */ - enterRowsecuritydefaultpermissive?: (ctx: RowsecuritydefaultpermissiveContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.rowsecuritydefaultpermissive`. - * @param ctx the parse tree - */ - exitRowsecuritydefaultpermissive?: (ctx: RowsecuritydefaultpermissiveContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.rowsecuritydefaultforcmd`. - * @param ctx the parse tree - */ - enterRowsecuritydefaultforcmd?: (ctx: RowsecuritydefaultforcmdContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.rowsecuritydefaultforcmd`. - * @param ctx the parse tree - */ - exitRowsecuritydefaultforcmd?: (ctx: RowsecuritydefaultforcmdContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.row_security_cmd`. - * @param ctx the parse tree - */ - enterRow_security_cmd?: (ctx: Row_security_cmdContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.row_security_cmd`. - * @param ctx the parse tree - */ - exitRow_security_cmd?: (ctx: Row_security_cmdContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createamstmt`. - * @param ctx the parse tree - */ - enterCreateamstmt?: (ctx: CreateamstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createamstmt`. - * @param ctx the parse tree - */ - exitCreateamstmt?: (ctx: CreateamstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.am_type`. - * @param ctx the parse tree - */ - enterAm_type?: (ctx: Am_typeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.am_type`. - * @param ctx the parse tree - */ - exitAm_type?: (ctx: Am_typeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createtrigstmt`. - * @param ctx the parse tree - */ - enterCreatetrigstmt?: (ctx: CreatetrigstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createtrigstmt`. - * @param ctx the parse tree - */ - exitCreatetrigstmt?: (ctx: CreatetrigstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggeractiontime`. - * @param ctx the parse tree - */ - enterTriggeractiontime?: (ctx: TriggeractiontimeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggeractiontime`. - * @param ctx the parse tree - */ - exitTriggeractiontime?: (ctx: TriggeractiontimeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.foreachrow`. - * @param ctx the parse tree - */ - enterForeachrow?: (ctx: ForeachrowContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.foreachrow`. - * @param ctx the parse tree - */ - exitForeachrow?: (ctx: ForeachrowContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.roworstatment`. - * @param ctx the parse tree - */ - enterRoworstatment?: (ctx: RoworstatmentContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.roworstatment`. - * @param ctx the parse tree - */ - exitRoworstatment?: (ctx: RoworstatmentContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggerevents`. - * @param ctx the parse tree - */ - enterTriggerevents?: (ctx: TriggereventsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggerevents`. - * @param ctx the parse tree - */ - exitTriggerevents?: (ctx: TriggereventsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggeroneevent`. - * @param ctx the parse tree - */ - enterTriggeroneevent?: (ctx: TriggeroneeventContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggeroneevent`. - * @param ctx the parse tree - */ - exitTriggeroneevent?: (ctx: TriggeroneeventContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggerreferencing`. - * @param ctx the parse tree - */ - enterTriggerreferencing?: (ctx: TriggerreferencingContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggerreferencing`. - * @param ctx the parse tree - */ - exitTriggerreferencing?: (ctx: TriggerreferencingContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggertransitions`. - * @param ctx the parse tree - */ - enterTriggertransitions?: (ctx: TriggertransitionsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggertransitions`. - * @param ctx the parse tree - */ - exitTriggertransitions?: (ctx: TriggertransitionsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggertransition`. - * @param ctx the parse tree - */ - enterTriggertransition?: (ctx: TriggertransitionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggertransition`. - * @param ctx the parse tree - */ - exitTriggertransition?: (ctx: TriggertransitionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.transitionoldornew`. - * @param ctx the parse tree - */ - enterTransitionoldornew?: (ctx: TransitionoldornewContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.transitionoldornew`. - * @param ctx the parse tree - */ - exitTransitionoldornew?: (ctx: TransitionoldornewContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.transitionrowortable`. - * @param ctx the parse tree - */ - enterTransitionrowortable?: (ctx: TransitionrowortableContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.transitionrowortable`. - * @param ctx the parse tree - */ - exitTransitionrowortable?: (ctx: TransitionrowortableContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.transitionrelname`. - * @param ctx the parse tree - */ - enterTransitionrelname?: (ctx: TransitionrelnameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.transitionrelname`. - * @param ctx the parse tree - */ - exitTransitionrelname?: (ctx: TransitionrelnameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggerforspec`. - * @param ctx the parse tree - */ - enterTriggerforspec?: (ctx: TriggerforspecContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggerforspec`. - * @param ctx the parse tree - */ - exitTriggerforspec?: (ctx: TriggerforspecContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggerforopteach`. - * @param ctx the parse tree - */ - enterTriggerforopteach?: (ctx: TriggerforopteachContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggerforopteach`. - * @param ctx the parse tree - */ - exitTriggerforopteach?: (ctx: TriggerforopteachContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggerfortype`. - * @param ctx the parse tree - */ - enterTriggerfortype?: (ctx: TriggerfortypeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggerfortype`. - * @param ctx the parse tree - */ - exitTriggerfortype?: (ctx: TriggerfortypeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggerwhen`. - * @param ctx the parse tree - */ - enterTriggerwhen?: (ctx: TriggerwhenContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggerwhen`. - * @param ctx the parse tree - */ - exitTriggerwhen?: (ctx: TriggerwhenContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.function_or_procedure`. - * @param ctx the parse tree - */ - enterFunction_or_procedure?: (ctx: Function_or_procedureContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.function_or_procedure`. - * @param ctx the parse tree - */ - exitFunction_or_procedure?: (ctx: Function_or_procedureContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggerfuncargs`. - * @param ctx the parse tree - */ - enterTriggerfuncargs?: (ctx: TriggerfuncargsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggerfuncargs`. - * @param ctx the parse tree - */ - exitTriggerfuncargs?: (ctx: TriggerfuncargsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.triggerfuncarg`. - * @param ctx the parse tree - */ - enterTriggerfuncarg?: (ctx: TriggerfuncargContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.triggerfuncarg`. - * @param ctx the parse tree - */ - exitTriggerfuncarg?: (ctx: TriggerfuncargContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.optconstrfromtable`. - * @param ctx the parse tree - */ - enterOptconstrfromtable?: (ctx: OptconstrfromtableContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.optconstrfromtable`. - * @param ctx the parse tree - */ - exitOptconstrfromtable?: (ctx: OptconstrfromtableContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.constraintattributespec`. - * @param ctx the parse tree - */ - enterConstraintattributespec?: (ctx: ConstraintattributespecContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.constraintattributespec`. - * @param ctx the parse tree - */ - exitConstraintattributespec?: (ctx: ConstraintattributespecContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.constraintattributeElem`. - * @param ctx the parse tree - */ - enterConstraintattributeElem?: (ctx: ConstraintattributeElemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.constraintattributeElem`. - * @param ctx the parse tree - */ - exitConstraintattributeElem?: (ctx: ConstraintattributeElemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createeventtrigstmt`. - * @param ctx the parse tree - */ - enterCreateeventtrigstmt?: (ctx: CreateeventtrigstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createeventtrigstmt`. - * @param ctx the parse tree - */ - exitCreateeventtrigstmt?: (ctx: CreateeventtrigstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.event_trigger_when_list`. - * @param ctx the parse tree - */ - enterEvent_trigger_when_list?: (ctx: Event_trigger_when_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.event_trigger_when_list`. - * @param ctx the parse tree - */ - exitEvent_trigger_when_list?: (ctx: Event_trigger_when_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.event_trigger_when_item`. - * @param ctx the parse tree - */ - enterEvent_trigger_when_item?: (ctx: Event_trigger_when_itemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.event_trigger_when_item`. - * @param ctx the parse tree - */ - exitEvent_trigger_when_item?: (ctx: Event_trigger_when_itemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.event_trigger_value_list`. - * @param ctx the parse tree - */ - enterEvent_trigger_value_list?: (ctx: Event_trigger_value_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.event_trigger_value_list`. - * @param ctx the parse tree - */ - exitEvent_trigger_value_list?: (ctx: Event_trigger_value_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.altereventtrigstmt`. - * @param ctx the parse tree - */ - enterAltereventtrigstmt?: (ctx: AltereventtrigstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.altereventtrigstmt`. - * @param ctx the parse tree - */ - exitAltereventtrigstmt?: (ctx: AltereventtrigstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.enable_trigger`. - * @param ctx the parse tree - */ - enterEnable_trigger?: (ctx: Enable_triggerContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.enable_trigger`. - * @param ctx the parse tree - */ - exitEnable_trigger?: (ctx: Enable_triggerContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createassertionstmt`. - * @param ctx the parse tree - */ - enterCreateassertionstmt?: (ctx: CreateassertionstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createassertionstmt`. - * @param ctx the parse tree - */ - exitCreateassertionstmt?: (ctx: CreateassertionstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.definestmt`. - * @param ctx the parse tree - */ - enterDefinestmt?: (ctx: DefinestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.definestmt`. - * @param ctx the parse tree - */ - exitDefinestmt?: (ctx: DefinestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.definition`. - * @param ctx the parse tree - */ - enterDefinition?: (ctx: DefinitionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.definition`. - * @param ctx the parse tree - */ - exitDefinition?: (ctx: DefinitionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.def_list`. - * @param ctx the parse tree - */ - enterDef_list?: (ctx: Def_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.def_list`. - * @param ctx the parse tree - */ - exitDef_list?: (ctx: Def_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.def_elem`. - * @param ctx the parse tree - */ - enterDef_elem?: (ctx: Def_elemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.def_elem`. - * @param ctx the parse tree - */ - exitDef_elem?: (ctx: Def_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.def_arg`. - * @param ctx the parse tree - */ - enterDef_arg?: (ctx: Def_argContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.def_arg`. - * @param ctx the parse tree - */ - exitDef_arg?: (ctx: Def_argContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.old_aggr_definition`. - * @param ctx the parse tree - */ - enterOld_aggr_definition?: (ctx: Old_aggr_definitionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.old_aggr_definition`. - * @param ctx the parse tree - */ - exitOld_aggr_definition?: (ctx: Old_aggr_definitionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.old_aggr_list`. - * @param ctx the parse tree - */ - enterOld_aggr_list?: (ctx: Old_aggr_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.old_aggr_list`. - * @param ctx the parse tree - */ - exitOld_aggr_list?: (ctx: Old_aggr_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.old_aggr_elem`. - * @param ctx the parse tree - */ - enterOld_aggr_elem?: (ctx: Old_aggr_elemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.old_aggr_elem`. - * @param ctx the parse tree - */ - exitOld_aggr_elem?: (ctx: Old_aggr_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_enum_val_list`. - * @param ctx the parse tree - */ - enterOpt_enum_val_list?: (ctx: Opt_enum_val_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_enum_val_list`. - * @param ctx the parse tree - */ - exitOpt_enum_val_list?: (ctx: Opt_enum_val_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.enum_val_list`. - * @param ctx the parse tree - */ - enterEnum_val_list?: (ctx: Enum_val_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.enum_val_list`. - * @param ctx the parse tree - */ - exitEnum_val_list?: (ctx: Enum_val_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterenumstmt`. - * @param ctx the parse tree - */ - enterAlterenumstmt?: (ctx: AlterenumstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterenumstmt`. - * @param ctx the parse tree - */ - exitAlterenumstmt?: (ctx: AlterenumstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_if_not_exists`. - * @param ctx the parse tree - */ - enterOpt_if_not_exists?: (ctx: Opt_if_not_existsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_if_not_exists`. - * @param ctx the parse tree - */ - exitOpt_if_not_exists?: (ctx: Opt_if_not_existsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createopclassstmt`. - * @param ctx the parse tree - */ - enterCreateopclassstmt?: (ctx: CreateopclassstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createopclassstmt`. - * @param ctx the parse tree - */ - exitCreateopclassstmt?: (ctx: CreateopclassstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opclass_item_list`. - * @param ctx the parse tree - */ - enterOpclass_item_list?: (ctx: Opclass_item_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opclass_item_list`. - * @param ctx the parse tree - */ - exitOpclass_item_list?: (ctx: Opclass_item_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opclass_item`. - * @param ctx the parse tree - */ - enterOpclass_item?: (ctx: Opclass_itemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opclass_item`. - * @param ctx the parse tree - */ - exitOpclass_item?: (ctx: Opclass_itemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_default`. - * @param ctx the parse tree - */ - enterOpt_default?: (ctx: Opt_defaultContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_default`. - * @param ctx the parse tree - */ - exitOpt_default?: (ctx: Opt_defaultContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_opfamily`. - * @param ctx the parse tree - */ - enterOpt_opfamily?: (ctx: Opt_opfamilyContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_opfamily`. - * @param ctx the parse tree - */ - exitOpt_opfamily?: (ctx: Opt_opfamilyContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opclass_purpose`. - * @param ctx the parse tree - */ - enterOpclass_purpose?: (ctx: Opclass_purposeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opclass_purpose`. - * @param ctx the parse tree - */ - exitOpclass_purpose?: (ctx: Opclass_purposeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_recheck`. - * @param ctx the parse tree - */ - enterOpt_recheck?: (ctx: Opt_recheckContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_recheck`. - * @param ctx the parse tree - */ - exitOpt_recheck?: (ctx: Opt_recheckContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createopfamilystmt`. - * @param ctx the parse tree - */ - enterCreateopfamilystmt?: (ctx: CreateopfamilystmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createopfamilystmt`. - * @param ctx the parse tree - */ - exitCreateopfamilystmt?: (ctx: CreateopfamilystmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alteropfamilystmt`. - * @param ctx the parse tree - */ - enterAlteropfamilystmt?: (ctx: AlteropfamilystmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alteropfamilystmt`. - * @param ctx the parse tree - */ - exitAlteropfamilystmt?: (ctx: AlteropfamilystmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opclass_drop_list`. - * @param ctx the parse tree - */ - enterOpclass_drop_list?: (ctx: Opclass_drop_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opclass_drop_list`. - * @param ctx the parse tree - */ - exitOpclass_drop_list?: (ctx: Opclass_drop_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opclass_drop`. - * @param ctx the parse tree - */ - enterOpclass_drop?: (ctx: Opclass_dropContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opclass_drop`. - * @param ctx the parse tree - */ - exitOpclass_drop?: (ctx: Opclass_dropContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.reassignownedstmt`. - * @param ctx the parse tree - */ - enterReassignownedstmt?: (ctx: ReassignownedstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.reassignownedstmt`. - * @param ctx the parse tree - */ - exitReassignownedstmt?: (ctx: ReassignownedstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.dropstmt`. - * @param ctx the parse tree - */ - enterDropstmt?: (ctx: DropstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.dropstmt`. - * @param ctx the parse tree - */ - exitDropstmt?: (ctx: DropstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.view_nameList`. - * @param ctx the parse tree - */ - enterView_nameList?: (ctx: View_nameListContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.view_nameList`. - * @param ctx the parse tree - */ - exitView_nameList?: (ctx: View_nameListContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.object_type_any_name`. - * @param ctx the parse tree - */ - enterObject_type_any_name?: (ctx: Object_type_any_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.object_type_any_name`. - * @param ctx the parse tree - */ - exitObject_type_any_name?: (ctx: Object_type_any_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.object_type_name`. - * @param ctx the parse tree - */ - enterObject_type_name?: (ctx: Object_type_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.object_type_name`. - * @param ctx the parse tree - */ - exitObject_type_name?: (ctx: Object_type_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.object_type_name_on_any_name`. - * @param ctx the parse tree - */ - enterObject_type_name_on_any_name?: (ctx: Object_type_name_on_any_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.object_type_name_on_any_name`. - * @param ctx the parse tree - */ - exitObject_type_name_on_any_name?: (ctx: Object_type_name_on_any_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.any_name_list`. - * @param ctx the parse tree - */ - enterAny_name_list?: (ctx: Any_name_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.any_name_list`. - * @param ctx the parse tree - */ - exitAny_name_list?: (ctx: Any_name_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.relation_column_name`. - * @param ctx the parse tree - */ - enterRelation_column_name?: (ctx: Relation_column_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.relation_column_name`. - * @param ctx the parse tree - */ - exitRelation_column_name?: (ctx: Relation_column_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.relation_name`. - * @param ctx the parse tree - */ - enterRelation_name?: (ctx: Relation_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.relation_name`. - * @param ctx the parse tree - */ - exitRelation_name?: (ctx: Relation_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.any_name`. - * @param ctx the parse tree - */ - enterAny_name?: (ctx: Any_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.any_name`. - * @param ctx the parse tree - */ - exitAny_name?: (ctx: Any_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.attrs`. - * @param ctx the parse tree - */ - enterAttrs?: (ctx: AttrsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.attrs`. - * @param ctx the parse tree - */ - exitAttrs?: (ctx: AttrsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.type_name_list`. - * @param ctx the parse tree - */ - enterType_name_list?: (ctx: Type_name_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.type_name_list`. - * @param ctx the parse tree - */ - exitType_name_list?: (ctx: Type_name_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.truncatestmt`. - * @param ctx the parse tree - */ - enterTruncatestmt?: (ctx: TruncatestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.truncatestmt`. - * @param ctx the parse tree - */ - exitTruncatestmt?: (ctx: TruncatestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.truncate_table`. - * @param ctx the parse tree - */ - enterTruncate_table?: (ctx: Truncate_tableContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.truncate_table`. - * @param ctx the parse tree - */ - exitTruncate_table?: (ctx: Truncate_tableContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.commentstmt`. - * @param ctx the parse tree - */ - enterCommentstmt?: (ctx: CommentstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.commentstmt`. - * @param ctx the parse tree - */ - exitCommentstmt?: (ctx: CommentstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.comment_text`. - * @param ctx the parse tree - */ - enterComment_text?: (ctx: Comment_textContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.comment_text`. - * @param ctx the parse tree - */ - exitComment_text?: (ctx: Comment_textContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.seclabelstmt`. - * @param ctx the parse tree - */ - enterSeclabelstmt?: (ctx: SeclabelstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.seclabelstmt`. - * @param ctx the parse tree - */ - exitSeclabelstmt?: (ctx: SeclabelstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_provider`. - * @param ctx the parse tree - */ - enterOpt_provider?: (ctx: Opt_providerContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_provider`. - * @param ctx the parse tree - */ - exitOpt_provider?: (ctx: Opt_providerContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.security_label`. - * @param ctx the parse tree - */ - enterSecurity_label?: (ctx: Security_labelContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.security_label`. - * @param ctx the parse tree - */ - exitSecurity_label?: (ctx: Security_labelContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.fetchstmt`. - * @param ctx the parse tree - */ - enterFetchstmt?: (ctx: FetchstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.fetchstmt`. - * @param ctx the parse tree - */ - exitFetchstmt?: (ctx: FetchstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.fetch_args`. - * @param ctx the parse tree - */ - enterFetch_args?: (ctx: Fetch_argsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.fetch_args`. - * @param ctx the parse tree - */ - exitFetch_args?: (ctx: Fetch_argsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.from_in`. - * @param ctx the parse tree - */ - enterFrom_in?: (ctx: From_inContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.from_in`. - * @param ctx the parse tree - */ - exitFrom_in?: (ctx: From_inContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_from_in`. - * @param ctx the parse tree - */ - enterOpt_from_in?: (ctx: Opt_from_inContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_from_in`. - * @param ctx the parse tree - */ - exitOpt_from_in?: (ctx: Opt_from_inContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.grantstmt`. - * @param ctx the parse tree - */ - enterGrantstmt?: (ctx: GrantstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.grantstmt`. - * @param ctx the parse tree - */ - exitGrantstmt?: (ctx: GrantstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.revokestmt`. - * @param ctx the parse tree - */ - enterRevokestmt?: (ctx: RevokestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.revokestmt`. - * @param ctx the parse tree - */ - exitRevokestmt?: (ctx: RevokestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.privileges`. - * @param ctx the parse tree - */ - enterPrivileges?: (ctx: PrivilegesContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.privileges`. - * @param ctx the parse tree - */ - exitPrivileges?: (ctx: PrivilegesContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.beforeprivilegeselectlist`. - * @param ctx the parse tree - */ - enterBeforeprivilegeselectlist?: (ctx: BeforeprivilegeselectlistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.beforeprivilegeselectlist`. - * @param ctx the parse tree - */ - exitBeforeprivilegeselectlist?: (ctx: BeforeprivilegeselectlistContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.beforeprivilegeselect`. - * @param ctx the parse tree - */ - enterBeforeprivilegeselect?: (ctx: BeforeprivilegeselectContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.beforeprivilegeselect`. - * @param ctx the parse tree - */ - exitBeforeprivilegeselect?: (ctx: BeforeprivilegeselectContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.privilege_list`. - * @param ctx the parse tree - */ - enterPrivilege_list?: (ctx: Privilege_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.privilege_list`. - * @param ctx the parse tree - */ - exitPrivilege_list?: (ctx: Privilege_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.privilege`. - * @param ctx the parse tree - */ - enterPrivilege?: (ctx: PrivilegeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.privilege`. - * @param ctx the parse tree - */ - exitPrivilege?: (ctx: PrivilegeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.privilege_target`. - * @param ctx the parse tree - */ - enterPrivilege_target?: (ctx: Privilege_targetContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.privilege_target`. - * @param ctx the parse tree - */ - exitPrivilege_target?: (ctx: Privilege_targetContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.grantee_list`. - * @param ctx the parse tree - */ - enterGrantee_list?: (ctx: Grantee_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.grantee_list`. - * @param ctx the parse tree - */ - exitGrantee_list?: (ctx: Grantee_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.grantee`. - * @param ctx the parse tree - */ - enterGrantee?: (ctx: GranteeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.grantee`. - * @param ctx the parse tree - */ - exitGrantee?: (ctx: GranteeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_grant_grant_option`. - * @param ctx the parse tree - */ - enterOpt_grant_grant_option?: (ctx: Opt_grant_grant_optionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_grant_grant_option`. - * @param ctx the parse tree - */ - exitOpt_grant_grant_option?: (ctx: Opt_grant_grant_optionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.grantrolestmt`. - * @param ctx the parse tree - */ - enterGrantrolestmt?: (ctx: GrantrolestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.grantrolestmt`. - * @param ctx the parse tree - */ - exitGrantrolestmt?: (ctx: GrantrolestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.revokerolestmt`. - * @param ctx the parse tree - */ - enterRevokerolestmt?: (ctx: RevokerolestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.revokerolestmt`. - * @param ctx the parse tree - */ - exitRevokerolestmt?: (ctx: RevokerolestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_grant_admin_option`. - * @param ctx the parse tree - */ - enterOpt_grant_admin_option?: (ctx: Opt_grant_admin_optionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_grant_admin_option`. - * @param ctx the parse tree - */ - exitOpt_grant_admin_option?: (ctx: Opt_grant_admin_optionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_granted_by`. - * @param ctx the parse tree - */ - enterOpt_granted_by?: (ctx: Opt_granted_byContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_granted_by`. - * @param ctx the parse tree - */ - exitOpt_granted_by?: (ctx: Opt_granted_byContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterdefaultprivilegesstmt`. - * @param ctx the parse tree - */ - enterAlterdefaultprivilegesstmt?: (ctx: AlterdefaultprivilegesstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterdefaultprivilegesstmt`. - * @param ctx the parse tree - */ - exitAlterdefaultprivilegesstmt?: (ctx: AlterdefaultprivilegesstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.defacloptionlist`. - * @param ctx the parse tree - */ - enterDefacloptionlist?: (ctx: DefacloptionlistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.defacloptionlist`. - * @param ctx the parse tree - */ - exitDefacloptionlist?: (ctx: DefacloptionlistContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.defacloption`. - * @param ctx the parse tree - */ - enterDefacloption?: (ctx: DefacloptionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.defacloption`. - * @param ctx the parse tree - */ - exitDefacloption?: (ctx: DefacloptionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.defaclaction`. - * @param ctx the parse tree - */ - enterDefaclaction?: (ctx: DefaclactionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.defaclaction`. - * @param ctx the parse tree - */ - exitDefaclaction?: (ctx: DefaclactionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.defacl_privilege_target`. - * @param ctx the parse tree - */ - enterDefacl_privilege_target?: (ctx: Defacl_privilege_targetContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.defacl_privilege_target`. - * @param ctx the parse tree - */ - exitDefacl_privilege_target?: (ctx: Defacl_privilege_targetContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.indexstmt`. - * @param ctx the parse tree - */ - enterIndexstmt?: (ctx: IndexstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.indexstmt`. - * @param ctx the parse tree - */ - exitIndexstmt?: (ctx: IndexstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_unique`. - * @param ctx the parse tree - */ - enterOpt_unique?: (ctx: Opt_uniqueContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_unique`. - * @param ctx the parse tree - */ - exitOpt_unique?: (ctx: Opt_uniqueContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_concurrently`. - * @param ctx the parse tree - */ - enterOpt_concurrently?: (ctx: Opt_concurrentlyContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_concurrently`. - * @param ctx the parse tree - */ - exitOpt_concurrently?: (ctx: Opt_concurrentlyContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_index_name`. - * @param ctx the parse tree - */ - enterOpt_index_name?: (ctx: Opt_index_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_index_name`. - * @param ctx the parse tree - */ - exitOpt_index_name?: (ctx: Opt_index_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.access_method_clause`. - * @param ctx the parse tree - */ - enterAccess_method_clause?: (ctx: Access_method_clauseContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.access_method_clause`. - * @param ctx the parse tree - */ - exitAccess_method_clause?: (ctx: Access_method_clauseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.index_params`. - * @param ctx the parse tree - */ - enterIndex_params?: (ctx: Index_paramsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.index_params`. - * @param ctx the parse tree - */ - exitIndex_params?: (ctx: Index_paramsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.index_elem_options`. - * @param ctx the parse tree - */ - enterIndex_elem_options?: (ctx: Index_elem_optionsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.index_elem_options`. - * @param ctx the parse tree - */ - exitIndex_elem_options?: (ctx: Index_elem_optionsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.index_elem`. - * @param ctx the parse tree - */ - enterIndex_elem?: (ctx: Index_elemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.index_elem`. - * @param ctx the parse tree - */ - exitIndex_elem?: (ctx: Index_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_include`. - * @param ctx the parse tree - */ - enterOpt_include?: (ctx: Opt_includeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_include`. - * @param ctx the parse tree - */ - exitOpt_include?: (ctx: Opt_includeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.index_including_params`. - * @param ctx the parse tree - */ - enterIndex_including_params?: (ctx: Index_including_paramsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.index_including_params`. - * @param ctx the parse tree - */ - exitIndex_including_params?: (ctx: Index_including_paramsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_collate`. - * @param ctx the parse tree - */ - enterOpt_collate?: (ctx: Opt_collateContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_collate`. - * @param ctx the parse tree - */ - exitOpt_collate?: (ctx: Opt_collateContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_class`. - * @param ctx the parse tree - */ - enterOpt_class?: (ctx: Opt_classContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_class`. - * @param ctx the parse tree - */ - exitOpt_class?: (ctx: Opt_classContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_asc_desc`. - * @param ctx the parse tree - */ - enterOpt_asc_desc?: (ctx: Opt_asc_descContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_asc_desc`. - * @param ctx the parse tree - */ - exitOpt_asc_desc?: (ctx: Opt_asc_descContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_nulls_order`. - * @param ctx the parse tree - */ - enterOpt_nulls_order?: (ctx: Opt_nulls_orderContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_nulls_order`. - * @param ctx the parse tree - */ - exitOpt_nulls_order?: (ctx: Opt_nulls_orderContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createfunctionstmt`. - * @param ctx the parse tree - */ - enterCreatefunctionstmt?: (ctx: CreatefunctionstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createfunctionstmt`. - * @param ctx the parse tree - */ - exitCreatefunctionstmt?: (ctx: CreatefunctionstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.attrilist`. - * @param ctx the parse tree - */ - enterAttrilist?: (ctx: AttrilistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.attrilist`. - * @param ctx the parse tree - */ - exitAttrilist?: (ctx: AttrilistContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_or_replace`. - * @param ctx the parse tree - */ - enterOpt_or_replace?: (ctx: Opt_or_replaceContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_or_replace`. - * @param ctx the parse tree - */ - exitOpt_or_replace?: (ctx: Opt_or_replaceContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.func_args`. - * @param ctx the parse tree - */ - enterFunc_args?: (ctx: Func_argsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.func_args`. - * @param ctx the parse tree - */ - exitFunc_args?: (ctx: Func_argsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.func_args_list`. - * @param ctx the parse tree - */ - enterFunc_args_list?: (ctx: Func_args_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.func_args_list`. - * @param ctx the parse tree - */ - exitFunc_args_list?: (ctx: Func_args_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.routine_with_argtypes_list`. - * @param ctx the parse tree - */ - enterRoutine_with_argtypes_list?: (ctx: Routine_with_argtypes_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.routine_with_argtypes_list`. - * @param ctx the parse tree - */ - exitRoutine_with_argtypes_list?: (ctx: Routine_with_argtypes_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.routine_with_argtypes`. - * @param ctx the parse tree - */ - enterRoutine_with_argtypes?: (ctx: Routine_with_argtypesContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.routine_with_argtypes`. - * @param ctx the parse tree - */ - exitRoutine_with_argtypes?: (ctx: Routine_with_argtypesContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.procedure_with_argtypes_list`. - * @param ctx the parse tree - */ - enterProcedure_with_argtypes_list?: (ctx: Procedure_with_argtypes_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.procedure_with_argtypes_list`. - * @param ctx the parse tree - */ - exitProcedure_with_argtypes_list?: (ctx: Procedure_with_argtypes_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.procedure_with_argtypes`. - * @param ctx the parse tree - */ - enterProcedure_with_argtypes?: (ctx: Procedure_with_argtypesContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.procedure_with_argtypes`. - * @param ctx the parse tree - */ - exitProcedure_with_argtypes?: (ctx: Procedure_with_argtypesContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.function_with_argtypes_list`. - * @param ctx the parse tree - */ - enterFunction_with_argtypes_list?: (ctx: Function_with_argtypes_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.function_with_argtypes_list`. - * @param ctx the parse tree - */ - exitFunction_with_argtypes_list?: (ctx: Function_with_argtypes_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.function_with_argtypes`. - * @param ctx the parse tree - */ - enterFunction_with_argtypes?: (ctx: Function_with_argtypesContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.function_with_argtypes`. - * @param ctx the parse tree - */ - exitFunction_with_argtypes?: (ctx: Function_with_argtypesContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.func_args_with_defaults`. - * @param ctx the parse tree - */ - enterFunc_args_with_defaults?: (ctx: Func_args_with_defaultsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.func_args_with_defaults`. - * @param ctx the parse tree - */ - exitFunc_args_with_defaults?: (ctx: Func_args_with_defaultsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.func_args_with_defaults_list`. - * @param ctx the parse tree - */ - enterFunc_args_with_defaults_list?: (ctx: Func_args_with_defaults_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.func_args_with_defaults_list`. - * @param ctx the parse tree - */ - exitFunc_args_with_defaults_list?: (ctx: Func_args_with_defaults_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.func_arg`. - * @param ctx the parse tree - */ - enterFunc_arg?: (ctx: Func_argContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.func_arg`. - * @param ctx the parse tree - */ - exitFunc_arg?: (ctx: Func_argContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.arg_class`. - * @param ctx the parse tree - */ - enterArg_class?: (ctx: Arg_classContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.arg_class`. - * @param ctx the parse tree - */ - exitArg_class?: (ctx: Arg_classContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.param_name`. - * @param ctx the parse tree - */ - enterParam_name?: (ctx: Param_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.param_name`. - * @param ctx the parse tree - */ - exitParam_name?: (ctx: Param_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.func_return`. - * @param ctx the parse tree - */ - enterFunc_return?: (ctx: Func_returnContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.func_return`. - * @param ctx the parse tree - */ - exitFunc_return?: (ctx: Func_returnContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.func_type`. - * @param ctx the parse tree - */ - enterFunc_type?: (ctx: Func_typeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.func_type`. - * @param ctx the parse tree - */ - exitFunc_type?: (ctx: Func_typeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.func_arg_with_default`. - * @param ctx the parse tree - */ - enterFunc_arg_with_default?: (ctx: Func_arg_with_defaultContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.func_arg_with_default`. - * @param ctx the parse tree - */ - exitFunc_arg_with_default?: (ctx: Func_arg_with_defaultContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.aggr_arg`. - * @param ctx the parse tree - */ - enterAggr_arg?: (ctx: Aggr_argContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.aggr_arg`. - * @param ctx the parse tree - */ - exitAggr_arg?: (ctx: Aggr_argContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.aggr_args`. - * @param ctx the parse tree - */ - enterAggr_args?: (ctx: Aggr_argsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.aggr_args`. - * @param ctx the parse tree - */ - exitAggr_args?: (ctx: Aggr_argsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.aggr_args_list`. - * @param ctx the parse tree - */ - enterAggr_args_list?: (ctx: Aggr_args_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.aggr_args_list`. - * @param ctx the parse tree - */ - exitAggr_args_list?: (ctx: Aggr_args_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.aggregate_with_argtypes`. - * @param ctx the parse tree - */ - enterAggregate_with_argtypes?: (ctx: Aggregate_with_argtypesContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.aggregate_with_argtypes`. - * @param ctx the parse tree - */ - exitAggregate_with_argtypes?: (ctx: Aggregate_with_argtypesContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.aggregate_with_argtypes_list`. - * @param ctx the parse tree - */ - enterAggregate_with_argtypes_list?: (ctx: Aggregate_with_argtypes_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.aggregate_with_argtypes_list`. - * @param ctx the parse tree - */ - exitAggregate_with_argtypes_list?: (ctx: Aggregate_with_argtypes_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createfunc_opt_list`. - * @param ctx the parse tree - */ - enterCreatefunc_opt_list?: (ctx: Createfunc_opt_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createfunc_opt_list`. - * @param ctx the parse tree - */ - exitCreatefunc_opt_list?: (ctx: Createfunc_opt_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.common_func_opt_item`. - * @param ctx the parse tree - */ - enterCommon_func_opt_item?: (ctx: Common_func_opt_itemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.common_func_opt_item`. - * @param ctx the parse tree - */ - exitCommon_func_opt_item?: (ctx: Common_func_opt_itemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createfunc_opt_item`. - * @param ctx the parse tree - */ - enterCreatefunc_opt_item?: (ctx: Createfunc_opt_itemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createfunc_opt_item`. - * @param ctx the parse tree - */ - exitCreatefunc_opt_item?: (ctx: Createfunc_opt_itemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.transform_type_list`. - * @param ctx the parse tree - */ - enterTransform_type_list?: (ctx: Transform_type_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.transform_type_list`. - * @param ctx the parse tree - */ - exitTransform_type_list?: (ctx: Transform_type_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_definition`. - * @param ctx the parse tree - */ - enterOpt_definition?: (ctx: Opt_definitionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_definition`. - * @param ctx the parse tree - */ - exitOpt_definition?: (ctx: Opt_definitionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.table_func_column`. - * @param ctx the parse tree - */ - enterTable_func_column?: (ctx: Table_func_columnContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.table_func_column`. - * @param ctx the parse tree - */ - exitTable_func_column?: (ctx: Table_func_columnContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.table_func_column_list`. - * @param ctx the parse tree - */ - enterTable_func_column_list?: (ctx: Table_func_column_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.table_func_column_list`. - * @param ctx the parse tree - */ - exitTable_func_column_list?: (ctx: Table_func_column_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterfunctionstmt`. - * @param ctx the parse tree - */ - enterAlterfunctionstmt?: (ctx: AlterfunctionstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterfunctionstmt`. - * @param ctx the parse tree - */ - exitAlterfunctionstmt?: (ctx: AlterfunctionstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterFunctionTypeClause`. - * @param ctx the parse tree - */ - enterAlterFunctionTypeClause?: (ctx: AlterFunctionTypeClauseContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterFunctionTypeClause`. - * @param ctx the parse tree - */ - exitAlterFunctionTypeClause?: (ctx: AlterFunctionTypeClauseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterfunc_opt_list`. - * @param ctx the parse tree - */ - enterAlterfunc_opt_list?: (ctx: Alterfunc_opt_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterfunc_opt_list`. - * @param ctx the parse tree - */ - exitAlterfunc_opt_list?: (ctx: Alterfunc_opt_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_restrict`. - * @param ctx the parse tree - */ - enterOpt_restrict?: (ctx: Opt_restrictContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_restrict`. - * @param ctx the parse tree - */ - exitOpt_restrict?: (ctx: Opt_restrictContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.removefuncstmt`. - * @param ctx the parse tree - */ - enterRemovefuncstmt?: (ctx: RemovefuncstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.removefuncstmt`. - * @param ctx the parse tree - */ - exitRemovefuncstmt?: (ctx: RemovefuncstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.removeaggrstmt`. - * @param ctx the parse tree - */ - enterRemoveaggrstmt?: (ctx: RemoveaggrstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.removeaggrstmt`. - * @param ctx the parse tree - */ - exitRemoveaggrstmt?: (ctx: RemoveaggrstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.removeoperstmt`. - * @param ctx the parse tree - */ - enterRemoveoperstmt?: (ctx: RemoveoperstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.removeoperstmt`. - * @param ctx the parse tree - */ - exitRemoveoperstmt?: (ctx: RemoveoperstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.oper_argtypes`. - * @param ctx the parse tree - */ - enterOper_argtypes?: (ctx: Oper_argtypesContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.oper_argtypes`. - * @param ctx the parse tree - */ - exitOper_argtypes?: (ctx: Oper_argtypesContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.any_operator`. - * @param ctx the parse tree - */ - enterAny_operator?: (ctx: Any_operatorContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.any_operator`. - * @param ctx the parse tree - */ - exitAny_operator?: (ctx: Any_operatorContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.operator_with_argtypes_list`. - * @param ctx the parse tree - */ - enterOperator_with_argtypes_list?: (ctx: Operator_with_argtypes_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.operator_with_argtypes_list`. - * @param ctx the parse tree - */ - exitOperator_with_argtypes_list?: (ctx: Operator_with_argtypes_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.operator_with_argtypes`. - * @param ctx the parse tree - */ - enterOperator_with_argtypes?: (ctx: Operator_with_argtypesContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.operator_with_argtypes`. - * @param ctx the parse tree - */ - exitOperator_with_argtypes?: (ctx: Operator_with_argtypesContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.dostmt`. - * @param ctx the parse tree - */ - enterDostmt?: (ctx: DostmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.dostmt`. - * @param ctx the parse tree - */ - exitDostmt?: (ctx: DostmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.dostmt_opt_list`. - * @param ctx the parse tree - */ - enterDostmt_opt_list?: (ctx: Dostmt_opt_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.dostmt_opt_list`. - * @param ctx the parse tree - */ - exitDostmt_opt_list?: (ctx: Dostmt_opt_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.dostmt_opt_item`. - * @param ctx the parse tree - */ - enterDostmt_opt_item?: (ctx: Dostmt_opt_itemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.dostmt_opt_item`. - * @param ctx the parse tree - */ - exitDostmt_opt_item?: (ctx: Dostmt_opt_itemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createcaststmt`. - * @param ctx the parse tree - */ - enterCreatecaststmt?: (ctx: CreatecaststmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createcaststmt`. - * @param ctx the parse tree - */ - exitCreatecaststmt?: (ctx: CreatecaststmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.cast_context`. - * @param ctx the parse tree - */ - enterCast_context?: (ctx: Cast_contextContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.cast_context`. - * @param ctx the parse tree - */ - exitCast_context?: (ctx: Cast_contextContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_if_exists`. - * @param ctx the parse tree - */ - enterOpt_if_exists?: (ctx: Opt_if_existsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_if_exists`. - * @param ctx the parse tree - */ - exitOpt_if_exists?: (ctx: Opt_if_existsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createtransformstmt`. - * @param ctx the parse tree - */ - enterCreatetransformstmt?: (ctx: CreatetransformstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createtransformstmt`. - * @param ctx the parse tree - */ - exitCreatetransformstmt?: (ctx: CreatetransformstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.transform_element_list`. - * @param ctx the parse tree - */ - enterTransform_element_list?: (ctx: Transform_element_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.transform_element_list`. - * @param ctx the parse tree - */ - exitTransform_element_list?: (ctx: Transform_element_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.reindexstmt`. - * @param ctx the parse tree - */ - enterReindexstmt?: (ctx: ReindexstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.reindexstmt`. - * @param ctx the parse tree - */ - exitReindexstmt?: (ctx: ReindexstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.reindex_target_type`. - * @param ctx the parse tree - */ - enterReindex_target_type?: (ctx: Reindex_target_typeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.reindex_target_type`. - * @param ctx the parse tree - */ - exitReindex_target_type?: (ctx: Reindex_target_typeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.reindex_target_multitable`. - * @param ctx the parse tree - */ - enterReindex_target_multitable?: (ctx: Reindex_target_multitableContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.reindex_target_multitable`. - * @param ctx the parse tree - */ - exitReindex_target_multitable?: (ctx: Reindex_target_multitableContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.reindex_option_list`. - * @param ctx the parse tree - */ - enterReindex_option_list?: (ctx: Reindex_option_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.reindex_option_list`. - * @param ctx the parse tree - */ - exitReindex_option_list?: (ctx: Reindex_option_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.reindex_option_elem`. - * @param ctx the parse tree - */ - enterReindex_option_elem?: (ctx: Reindex_option_elemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.reindex_option_elem`. - * @param ctx the parse tree - */ - exitReindex_option_elem?: (ctx: Reindex_option_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.altertblspcstmt`. - * @param ctx the parse tree - */ - enterAltertblspcstmt?: (ctx: AltertblspcstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.altertblspcstmt`. - * @param ctx the parse tree - */ - exitAltertblspcstmt?: (ctx: AltertblspcstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.renamestmt`. - * @param ctx the parse tree - */ - enterRenamestmt?: (ctx: RenamestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.renamestmt`. - * @param ctx the parse tree - */ - exitRenamestmt?: (ctx: RenamestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_set_data`. - * @param ctx the parse tree - */ - enterOpt_set_data?: (ctx: Opt_set_dataContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_set_data`. - * @param ctx the parse tree - */ - exitOpt_set_data?: (ctx: Opt_set_dataContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterobjectdependsstmt`. - * @param ctx the parse tree - */ - enterAlterobjectdependsstmt?: (ctx: AlterobjectdependsstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterobjectdependsstmt`. - * @param ctx the parse tree - */ - exitAlterobjectdependsstmt?: (ctx: AlterobjectdependsstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_no`. - * @param ctx the parse tree - */ - enterOpt_no?: (ctx: Opt_noContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_no`. - * @param ctx the parse tree - */ - exitOpt_no?: (ctx: Opt_noContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterobjectschemastmt`. - * @param ctx the parse tree - */ - enterAlterobjectschemastmt?: (ctx: AlterobjectschemastmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterobjectschemastmt`. - * @param ctx the parse tree - */ - exitAlterobjectschemastmt?: (ctx: AlterobjectschemastmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alteroperatorstmt`. - * @param ctx the parse tree - */ - enterAlteroperatorstmt?: (ctx: AlteroperatorstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alteroperatorstmt`. - * @param ctx the parse tree - */ - exitAlteroperatorstmt?: (ctx: AlteroperatorstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.operator_def_list`. - * @param ctx the parse tree - */ - enterOperator_def_list?: (ctx: Operator_def_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.operator_def_list`. - * @param ctx the parse tree - */ - exitOperator_def_list?: (ctx: Operator_def_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.operator_def_elem`. - * @param ctx the parse tree - */ - enterOperator_def_elem?: (ctx: Operator_def_elemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.operator_def_elem`. - * @param ctx the parse tree - */ - exitOperator_def_elem?: (ctx: Operator_def_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.operator_def_arg`. - * @param ctx the parse tree - */ - enterOperator_def_arg?: (ctx: Operator_def_argContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.operator_def_arg`. - * @param ctx the parse tree - */ - exitOperator_def_arg?: (ctx: Operator_def_argContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.altertypestmt`. - * @param ctx the parse tree - */ - enterAltertypestmt?: (ctx: AltertypestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.altertypestmt`. - * @param ctx the parse tree - */ - exitAltertypestmt?: (ctx: AltertypestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterownerstmt`. - * @param ctx the parse tree - */ - enterAlterownerstmt?: (ctx: AlterownerstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterownerstmt`. - * @param ctx the parse tree - */ - exitAlterownerstmt?: (ctx: AlterownerstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createpublicationstmt`. - * @param ctx the parse tree - */ - enterCreatepublicationstmt?: (ctx: CreatepublicationstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createpublicationstmt`. - * @param ctx the parse tree - */ - exitCreatepublicationstmt?: (ctx: CreatepublicationstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_publication_for_tables`. - * @param ctx the parse tree - */ - enterOpt_publication_for_tables?: (ctx: Opt_publication_for_tablesContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_publication_for_tables`. - * @param ctx the parse tree - */ - exitOpt_publication_for_tables?: (ctx: Opt_publication_for_tablesContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.publication_for_tables`. - * @param ctx the parse tree - */ - enterPublication_for_tables?: (ctx: Publication_for_tablesContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.publication_for_tables`. - * @param ctx the parse tree - */ - exitPublication_for_tables?: (ctx: Publication_for_tablesContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterpublicationstmt`. - * @param ctx the parse tree - */ - enterAlterpublicationstmt?: (ctx: AlterpublicationstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterpublicationstmt`. - * @param ctx the parse tree - */ - exitAlterpublicationstmt?: (ctx: AlterpublicationstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createsubscriptionstmt`. - * @param ctx the parse tree - */ - enterCreatesubscriptionstmt?: (ctx: CreatesubscriptionstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createsubscriptionstmt`. - * @param ctx the parse tree - */ - exitCreatesubscriptionstmt?: (ctx: CreatesubscriptionstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.publication_name_list`. - * @param ctx the parse tree - */ - enterPublication_name_list?: (ctx: Publication_name_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.publication_name_list`. - * @param ctx the parse tree - */ - exitPublication_name_list?: (ctx: Publication_name_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.publication_name_item`. - * @param ctx the parse tree - */ - enterPublication_name_item?: (ctx: Publication_name_itemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.publication_name_item`. - * @param ctx the parse tree - */ - exitPublication_name_item?: (ctx: Publication_name_itemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.altersubscriptionstmt`. - * @param ctx the parse tree - */ - enterAltersubscriptionstmt?: (ctx: AltersubscriptionstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.altersubscriptionstmt`. - * @param ctx the parse tree - */ - exitAltersubscriptionstmt?: (ctx: AltersubscriptionstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.rulestmt`. - * @param ctx the parse tree - */ - enterRulestmt?: (ctx: RulestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.rulestmt`. - * @param ctx the parse tree - */ - exitRulestmt?: (ctx: RulestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.ruleactionlist`. - * @param ctx the parse tree - */ - enterRuleactionlist?: (ctx: RuleactionlistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.ruleactionlist`. - * @param ctx the parse tree - */ - exitRuleactionlist?: (ctx: RuleactionlistContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.ruleactionmulti`. - * @param ctx the parse tree - */ - enterRuleactionmulti?: (ctx: RuleactionmultiContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.ruleactionmulti`. - * @param ctx the parse tree - */ - exitRuleactionmulti?: (ctx: RuleactionmultiContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.ruleactionstmt`. - * @param ctx the parse tree - */ - enterRuleactionstmt?: (ctx: RuleactionstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.ruleactionstmt`. - * @param ctx the parse tree - */ - exitRuleactionstmt?: (ctx: RuleactionstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.ruleactionstmtOrEmpty`. - * @param ctx the parse tree - */ - enterRuleactionstmtOrEmpty?: (ctx: RuleactionstmtOrEmptyContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.ruleactionstmtOrEmpty`. - * @param ctx the parse tree - */ - exitRuleactionstmtOrEmpty?: (ctx: RuleactionstmtOrEmptyContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.event`. - * @param ctx the parse tree - */ - enterEvent?: (ctx: EventContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.event`. - * @param ctx the parse tree - */ - exitEvent?: (ctx: EventContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_instead`. - * @param ctx the parse tree - */ - enterOpt_instead?: (ctx: Opt_insteadContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_instead`. - * @param ctx the parse tree - */ - exitOpt_instead?: (ctx: Opt_insteadContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.notifystmt`. - * @param ctx the parse tree - */ - enterNotifystmt?: (ctx: NotifystmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.notifystmt`. - * @param ctx the parse tree - */ - exitNotifystmt?: (ctx: NotifystmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.notify_payload`. - * @param ctx the parse tree - */ - enterNotify_payload?: (ctx: Notify_payloadContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.notify_payload`. - * @param ctx the parse tree - */ - exitNotify_payload?: (ctx: Notify_payloadContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.listenstmt`. - * @param ctx the parse tree - */ - enterListenstmt?: (ctx: ListenstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.listenstmt`. - * @param ctx the parse tree - */ - exitListenstmt?: (ctx: ListenstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.unlistenstmt`. - * @param ctx the parse tree - */ - enterUnlistenstmt?: (ctx: UnlistenstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.unlistenstmt`. - * @param ctx the parse tree - */ - exitUnlistenstmt?: (ctx: UnlistenstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.transactionstmt`. - * @param ctx the parse tree - */ - enterTransactionstmt?: (ctx: TransactionstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.transactionstmt`. - * @param ctx the parse tree - */ - exitTransactionstmt?: (ctx: TransactionstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_transaction`. - * @param ctx the parse tree - */ - enterOpt_transaction?: (ctx: Opt_transactionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_transaction`. - * @param ctx the parse tree - */ - exitOpt_transaction?: (ctx: Opt_transactionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.transaction_mode_item`. - * @param ctx the parse tree - */ - enterTransaction_mode_item?: (ctx: Transaction_mode_itemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.transaction_mode_item`. - * @param ctx the parse tree - */ - exitTransaction_mode_item?: (ctx: Transaction_mode_itemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.transaction_mode_list`. - * @param ctx the parse tree - */ - enterTransaction_mode_list?: (ctx: Transaction_mode_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.transaction_mode_list`. - * @param ctx the parse tree - */ - exitTransaction_mode_list?: (ctx: Transaction_mode_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.transaction_mode_list_or_empty`. - * @param ctx the parse tree - */ - enterTransaction_mode_list_or_empty?: (ctx: Transaction_mode_list_or_emptyContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.transaction_mode_list_or_empty`. - * @param ctx the parse tree - */ - exitTransaction_mode_list_or_empty?: (ctx: Transaction_mode_list_or_emptyContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_transaction_chain`. - * @param ctx the parse tree - */ - enterOpt_transaction_chain?: (ctx: Opt_transaction_chainContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_transaction_chain`. - * @param ctx the parse tree - */ - exitOpt_transaction_chain?: (ctx: Opt_transaction_chainContext) => void; - /** - * Enter a parse tree produced by the `createView` - * labeled alternative in `PostgreSqlParser.viewstmt`. - * @param ctx the parse tree - */ - enterCreateView?: (ctx: CreateViewContext) => void; - /** - * Exit a parse tree produced by the `createView` - * labeled alternative in `PostgreSqlParser.viewstmt`. - * @param ctx the parse tree - */ - exitCreateView?: (ctx: CreateViewContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_check_option`. - * @param ctx the parse tree - */ - enterOpt_check_option?: (ctx: Opt_check_optionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_check_option`. - * @param ctx the parse tree - */ - exitOpt_check_option?: (ctx: Opt_check_optionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.loadstmt`. - * @param ctx the parse tree - */ - enterLoadstmt?: (ctx: LoadstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.loadstmt`. - * @param ctx the parse tree - */ - exitLoadstmt?: (ctx: LoadstmtContext) => void; - /** - * Enter a parse tree produced by the `createDatabase` - * labeled alternative in `PostgreSqlParser.createdbstmt`. - * @param ctx the parse tree - */ - enterCreateDatabase?: (ctx: CreateDatabaseContext) => void; - /** - * Exit a parse tree produced by the `createDatabase` - * labeled alternative in `PostgreSqlParser.createdbstmt`. - * @param ctx the parse tree - */ - exitCreateDatabase?: (ctx: CreateDatabaseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createdb_opt_list`. - * @param ctx the parse tree - */ - enterCreatedb_opt_list?: (ctx: Createdb_opt_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createdb_opt_list`. - * @param ctx the parse tree - */ - exitCreatedb_opt_list?: (ctx: Createdb_opt_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createdb_opt_items`. - * @param ctx the parse tree - */ - enterCreatedb_opt_items?: (ctx: Createdb_opt_itemsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createdb_opt_items`. - * @param ctx the parse tree - */ - exitCreatedb_opt_items?: (ctx: Createdb_opt_itemsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createdb_opt_item`. - * @param ctx the parse tree - */ - enterCreatedb_opt_item?: (ctx: Createdb_opt_itemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createdb_opt_item`. - * @param ctx the parse tree - */ - exitCreatedb_opt_item?: (ctx: Createdb_opt_itemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createdb_opt_name`. - * @param ctx the parse tree - */ - enterCreatedb_opt_name?: (ctx: Createdb_opt_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createdb_opt_name`. - * @param ctx the parse tree - */ - exitCreatedb_opt_name?: (ctx: Createdb_opt_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_equal`. - * @param ctx the parse tree - */ - enterOpt_equal?: (ctx: Opt_equalContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_equal`. - * @param ctx the parse tree - */ - exitOpt_equal?: (ctx: Opt_equalContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterdatabasestmt`. - * @param ctx the parse tree - */ - enterAlterdatabasestmt?: (ctx: AlterdatabasestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterdatabasestmt`. - * @param ctx the parse tree - */ - exitAlterdatabasestmt?: (ctx: AlterdatabasestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterdatabasesetstmt`. - * @param ctx the parse tree - */ - enterAlterdatabasesetstmt?: (ctx: AlterdatabasesetstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterdatabasesetstmt`. - * @param ctx the parse tree - */ - exitAlterdatabasesetstmt?: (ctx: AlterdatabasesetstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.drop_option_list`. - * @param ctx the parse tree - */ - enterDrop_option_list?: (ctx: Drop_option_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.drop_option_list`. - * @param ctx the parse tree - */ - exitDrop_option_list?: (ctx: Drop_option_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.drop_option`. - * @param ctx the parse tree - */ - enterDrop_option?: (ctx: Drop_optionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.drop_option`. - * @param ctx the parse tree - */ - exitDrop_option?: (ctx: Drop_optionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.altercollationstmt`. - * @param ctx the parse tree - */ - enterAltercollationstmt?: (ctx: AltercollationstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.altercollationstmt`. - * @param ctx the parse tree - */ - exitAltercollationstmt?: (ctx: AltercollationstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.altersystemstmt`. - * @param ctx the parse tree - */ - enterAltersystemstmt?: (ctx: AltersystemstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.altersystemstmt`. - * @param ctx the parse tree - */ - exitAltersystemstmt?: (ctx: AltersystemstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createdomainstmt`. - * @param ctx the parse tree - */ - enterCreatedomainstmt?: (ctx: CreatedomainstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createdomainstmt`. - * @param ctx the parse tree - */ - exitCreatedomainstmt?: (ctx: CreatedomainstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.alterdomainstmt`. - * @param ctx the parse tree - */ - enterAlterdomainstmt?: (ctx: AlterdomainstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.alterdomainstmt`. - * @param ctx the parse tree - */ - exitAlterdomainstmt?: (ctx: AlterdomainstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_as`. - * @param ctx the parse tree - */ - enterOpt_as?: (ctx: Opt_asContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_as`. - * @param ctx the parse tree - */ - exitOpt_as?: (ctx: Opt_asContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.altertsdictionarystmt`. - * @param ctx the parse tree - */ - enterAltertsdictionarystmt?: (ctx: AltertsdictionarystmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.altertsdictionarystmt`. - * @param ctx the parse tree - */ - exitAltertsdictionarystmt?: (ctx: AltertsdictionarystmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.altertsconfigurationstmt`. - * @param ctx the parse tree - */ - enterAltertsconfigurationstmt?: (ctx: AltertsconfigurationstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.altertsconfigurationstmt`. - * @param ctx the parse tree - */ - exitAltertsconfigurationstmt?: (ctx: AltertsconfigurationstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.any_with`. - * @param ctx the parse tree - */ - enterAny_with?: (ctx: Any_withContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.any_with`. - * @param ctx the parse tree - */ - exitAny_with?: (ctx: Any_withContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.createconversionstmt`. - * @param ctx the parse tree - */ - enterCreateconversionstmt?: (ctx: CreateconversionstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.createconversionstmt`. - * @param ctx the parse tree - */ - exitCreateconversionstmt?: (ctx: CreateconversionstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.clusterstmt`. - * @param ctx the parse tree - */ - enterClusterstmt?: (ctx: ClusterstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.clusterstmt`. - * @param ctx the parse tree - */ - exitClusterstmt?: (ctx: ClusterstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_verbose_list`. - * @param ctx the parse tree - */ - enterOpt_verbose_list?: (ctx: Opt_verbose_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_verbose_list`. - * @param ctx the parse tree - */ - exitOpt_verbose_list?: (ctx: Opt_verbose_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.cluster_index_specification`. - * @param ctx the parse tree - */ - enterCluster_index_specification?: (ctx: Cluster_index_specificationContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.cluster_index_specification`. - * @param ctx the parse tree - */ - exitCluster_index_specification?: (ctx: Cluster_index_specificationContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.vacuumstmt`. - * @param ctx the parse tree - */ - enterVacuumstmt?: (ctx: VacuumstmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.vacuumstmt`. - * @param ctx the parse tree - */ - exitVacuumstmt?: (ctx: VacuumstmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.analyzestmt`. - * @param ctx the parse tree - */ - enterAnalyzestmt?: (ctx: AnalyzestmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.analyzestmt`. - * @param ctx the parse tree - */ - exitAnalyzestmt?: (ctx: AnalyzestmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.vac_analyze_option_list`. - * @param ctx the parse tree - */ - enterVac_analyze_option_list?: (ctx: Vac_analyze_option_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.vac_analyze_option_list`. - * @param ctx the parse tree - */ - exitVac_analyze_option_list?: (ctx: Vac_analyze_option_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.analyze_keyword`. - * @param ctx the parse tree - */ - enterAnalyze_keyword?: (ctx: Analyze_keywordContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.analyze_keyword`. - * @param ctx the parse tree - */ - exitAnalyze_keyword?: (ctx: Analyze_keywordContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.vac_analyze_option_elem`. - * @param ctx the parse tree - */ - enterVac_analyze_option_elem?: (ctx: Vac_analyze_option_elemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.vac_analyze_option_elem`. - * @param ctx the parse tree - */ - exitVac_analyze_option_elem?: (ctx: Vac_analyze_option_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.vac_analyze_option_name`. - * @param ctx the parse tree - */ - enterVac_analyze_option_name?: (ctx: Vac_analyze_option_nameContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.vac_analyze_option_name`. - * @param ctx the parse tree - */ - exitVac_analyze_option_name?: (ctx: Vac_analyze_option_nameContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.vac_analyze_option_arg`. - * @param ctx the parse tree - */ - enterVac_analyze_option_arg?: (ctx: Vac_analyze_option_argContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.vac_analyze_option_arg`. - * @param ctx the parse tree - */ - exitVac_analyze_option_arg?: (ctx: Vac_analyze_option_argContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_analyze`. - * @param ctx the parse tree - */ - enterOpt_analyze?: (ctx: Opt_analyzeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_analyze`. - * @param ctx the parse tree - */ - exitOpt_analyze?: (ctx: Opt_analyzeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.analyze_options_list`. - * @param ctx the parse tree - */ - enterAnalyze_options_list?: (ctx: Analyze_options_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.analyze_options_list`. - * @param ctx the parse tree - */ - exitAnalyze_options_list?: (ctx: Analyze_options_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.analyze_option_elem`. - * @param ctx the parse tree - */ - enterAnalyze_option_elem?: (ctx: Analyze_option_elemContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.analyze_option_elem`. - * @param ctx the parse tree - */ - exitAnalyze_option_elem?: (ctx: Analyze_option_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_verbose`. - * @param ctx the parse tree - */ - enterOpt_verbose?: (ctx: Opt_verboseContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_verbose`. - * @param ctx the parse tree - */ - exitOpt_verbose?: (ctx: Opt_verboseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_skiplock`. - * @param ctx the parse tree - */ - enterOpt_skiplock?: (ctx: Opt_skiplockContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_skiplock`. - * @param ctx the parse tree - */ - exitOpt_skiplock?: (ctx: Opt_skiplockContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_buffer_usage_limit`. - * @param ctx the parse tree - */ - enterOpt_buffer_usage_limit?: (ctx: Opt_buffer_usage_limitContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_buffer_usage_limit`. - * @param ctx the parse tree - */ - exitOpt_buffer_usage_limit?: (ctx: Opt_buffer_usage_limitContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_full`. - * @param ctx the parse tree - */ - enterOpt_full?: (ctx: Opt_fullContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_full`. - * @param ctx the parse tree - */ - exitOpt_full?: (ctx: Opt_fullContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_freeze`. - * @param ctx the parse tree - */ - enterOpt_freeze?: (ctx: Opt_freezeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_freeze`. - * @param ctx the parse tree - */ - exitOpt_freeze?: (ctx: Opt_freezeContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_name_list`. - * @param ctx the parse tree - */ - enterOpt_name_list?: (ctx: Opt_name_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_name_list`. - * @param ctx the parse tree - */ - exitOpt_name_list?: (ctx: Opt_name_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.vacuum_relation`. - * @param ctx the parse tree - */ - enterVacuum_relation?: (ctx: Vacuum_relationContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.vacuum_relation`. - * @param ctx the parse tree - */ - exitVacuum_relation?: (ctx: Vacuum_relationContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.vacuum_relation_list`. - * @param ctx the parse tree - */ - enterVacuum_relation_list?: (ctx: Vacuum_relation_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.vacuum_relation_list`. - * @param ctx the parse tree - */ - exitVacuum_relation_list?: (ctx: Vacuum_relation_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_vacuum_relation_list`. - * @param ctx the parse tree - */ - enterOpt_vacuum_relation_list?: (ctx: Opt_vacuum_relation_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_vacuum_relation_list`. - * @param ctx the parse tree - */ - exitOpt_vacuum_relation_list?: (ctx: Opt_vacuum_relation_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.explainstmt`. - * @param ctx the parse tree - */ - enterExplainstmt?: (ctx: ExplainstmtContext) => void; + enterRefreshmatviewstmt?: (ctx: RefreshmatviewstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.explainstmt`. + * Exit a parse tree produced by `PostgreSqlParser.refreshmatviewstmt`. * @param ctx the parse tree */ - exitExplainstmt?: (ctx: ExplainstmtContext) => void; + exitRefreshmatviewstmt?: (ctx: RefreshmatviewstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.explainablestmt`. + * Enter a parse tree produced by `PostgreSqlParser.createseqstmt`. * @param ctx the parse tree */ - enterExplainablestmt?: (ctx: ExplainablestmtContext) => void; + enterCreateseqstmt?: (ctx: CreateseqstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.explainablestmt`. + * Exit a parse tree produced by `PostgreSqlParser.createseqstmt`. * @param ctx the parse tree */ - exitExplainablestmt?: (ctx: ExplainablestmtContext) => void; + exitCreateseqstmt?: (ctx: CreateseqstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.explain_option_list`. + * Enter a parse tree produced by `PostgreSqlParser.alterseqstmt`. * @param ctx the parse tree */ - enterExplain_option_list?: (ctx: Explain_option_listContext) => void; + enterAlterseqstmt?: (ctx: AlterseqstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.explain_option_list`. + * Exit a parse tree produced by `PostgreSqlParser.alterseqstmt`. * @param ctx the parse tree */ - exitExplain_option_list?: (ctx: Explain_option_listContext) => void; + exitAlterseqstmt?: (ctx: AlterseqstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.explain_option_elem`. + * Enter a parse tree produced by `PostgreSqlParser.seqoptelem`. * @param ctx the parse tree */ - enterExplain_option_elem?: (ctx: Explain_option_elemContext) => void; + enterSeqoptelem?: (ctx: SeqoptelemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.explain_option_elem`. + * Exit a parse tree produced by `PostgreSqlParser.seqoptelem`. * @param ctx the parse tree */ - exitExplain_option_elem?: (ctx: Explain_option_elemContext) => void; + exitSeqoptelem?: (ctx: SeqoptelemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.explain_option_name`. + * Enter a parse tree produced by `PostgreSqlParser.numericonly`. * @param ctx the parse tree */ - enterExplain_option_name?: (ctx: Explain_option_nameContext) => void; + enterNumericonly?: (ctx: NumericonlyContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.explain_option_name`. + * Exit a parse tree produced by `PostgreSqlParser.numericonly`. * @param ctx the parse tree */ - exitExplain_option_name?: (ctx: Explain_option_nameContext) => void; + exitNumericonly?: (ctx: NumericonlyContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.explain_option_arg`. + * Enter a parse tree produced by `PostgreSqlParser.createplangstmt`. * @param ctx the parse tree */ - enterExplain_option_arg?: (ctx: Explain_option_argContext) => void; + enterCreateplangstmt?: (ctx: CreateplangstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.explain_option_arg`. + * Exit a parse tree produced by `PostgreSqlParser.createplangstmt`. * @param ctx the parse tree */ - exitExplain_option_arg?: (ctx: Explain_option_argContext) => void; + exitCreateplangstmt?: (ctx: CreateplangstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.preparestmt`. + * Enter a parse tree produced by `PostgreSqlParser.createtablespacestmt`. * @param ctx the parse tree */ - enterPreparestmt?: (ctx: PreparestmtContext) => void; + enterCreatetablespacestmt?: (ctx: CreatetablespacestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.preparestmt`. + * Exit a parse tree produced by `PostgreSqlParser.createtablespacestmt`. * @param ctx the parse tree */ - exitPreparestmt?: (ctx: PreparestmtContext) => void; + exitCreatetablespacestmt?: (ctx: CreatetablespacestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.prep_type_clause`. + * Enter a parse tree produced by `PostgreSqlParser.createextensionstmt`. * @param ctx the parse tree */ - enterPrep_type_clause?: (ctx: Prep_type_clauseContext) => void; + enterCreateextensionstmt?: (ctx: CreateextensionstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.prep_type_clause`. + * Exit a parse tree produced by `PostgreSqlParser.createextensionstmt`. * @param ctx the parse tree */ - exitPrep_type_clause?: (ctx: Prep_type_clauseContext) => void; + exitCreateextensionstmt?: (ctx: CreateextensionstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.preparablestmt`. + * Enter a parse tree produced by `PostgreSqlParser.alterextensionstmt`. * @param ctx the parse tree */ - enterPreparablestmt?: (ctx: PreparablestmtContext) => void; + enterAlterextensionstmt?: (ctx: AlterextensionstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.preparablestmt`. + * Exit a parse tree produced by `PostgreSqlParser.alterextensionstmt`. * @param ctx the parse tree */ - exitPreparablestmt?: (ctx: PreparablestmtContext) => void; + exitAlterextensionstmt?: (ctx: AlterextensionstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.executestmt`. + * Enter a parse tree produced by `PostgreSqlParser.alterextensioncontentsstmt`. * @param ctx the parse tree */ - enterExecutestmt?: (ctx: ExecutestmtContext) => void; + enterAlterextensioncontentsstmt?: (ctx: AlterextensioncontentsstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.executestmt`. + * Exit a parse tree produced by `PostgreSqlParser.alterextensioncontentsstmt`. * @param ctx the parse tree */ - exitExecutestmt?: (ctx: ExecutestmtContext) => void; + exitAlterextensioncontentsstmt?: (ctx: AlterextensioncontentsstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.execute_param_clause`. + * Enter a parse tree produced by `PostgreSqlParser.createfdwstmt`. * @param ctx the parse tree */ - enterExecute_param_clause?: (ctx: Execute_param_clauseContext) => void; + enterCreatefdwstmt?: (ctx: CreatefdwstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.execute_param_clause`. + * Exit a parse tree produced by `PostgreSqlParser.createfdwstmt`. * @param ctx the parse tree */ - exitExecute_param_clause?: (ctx: Execute_param_clauseContext) => void; + exitCreatefdwstmt?: (ctx: CreatefdwstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.deallocatestmt`. + * Enter a parse tree produced by `PostgreSqlParser.fdw_option`. * @param ctx the parse tree */ - enterDeallocatestmt?: (ctx: DeallocatestmtContext) => void; + enterFdw_option?: (ctx: Fdw_optionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.deallocatestmt`. + * Exit a parse tree produced by `PostgreSqlParser.fdw_option`. * @param ctx the parse tree */ - exitDeallocatestmt?: (ctx: DeallocatestmtContext) => void; + exitFdw_option?: (ctx: Fdw_optionContext) => void; /** - * Enter a parse tree produced by the `insertStatement` - * labeled alternative in `PostgreSqlParser.insertstmt`. + * Enter a parse tree produced by `PostgreSqlParser.alterfdwstmt`. * @param ctx the parse tree */ - enterInsertStatement?: (ctx: InsertStatementContext) => void; + enterAlterfdwstmt?: (ctx: AlterfdwstmtContext) => void; /** - * Exit a parse tree produced by the `insertStatement` - * labeled alternative in `PostgreSqlParser.insertstmt`. + * Exit a parse tree produced by `PostgreSqlParser.alterfdwstmt`. * @param ctx the parse tree */ - exitInsertStatement?: (ctx: InsertStatementContext) => void; + exitAlterfdwstmt?: (ctx: AlterfdwstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.insert_target`. + * Enter a parse tree produced by `PostgreSqlParser.create_generic_options`. * @param ctx the parse tree */ - enterInsert_target?: (ctx: Insert_targetContext) => void; + enterCreate_generic_options?: (ctx: Create_generic_optionsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.insert_target`. + * Exit a parse tree produced by `PostgreSqlParser.create_generic_options`. * @param ctx the parse tree */ - exitInsert_target?: (ctx: Insert_targetContext) => void; + exitCreate_generic_options?: (ctx: Create_generic_optionsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.insert_rest`. + * Enter a parse tree produced by `PostgreSqlParser.alter_generic_options`. * @param ctx the parse tree */ - enterInsert_rest?: (ctx: Insert_restContext) => void; + enterAlter_generic_options?: (ctx: Alter_generic_optionsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.insert_rest`. + * Exit a parse tree produced by `PostgreSqlParser.alter_generic_options`. * @param ctx the parse tree */ - exitInsert_rest?: (ctx: Insert_restContext) => void; + exitAlter_generic_options?: (ctx: Alter_generic_optionsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.override_kind`. + * Enter a parse tree produced by `PostgreSqlParser.alter_generic_option_elem`. * @param ctx the parse tree */ - enterOverride_kind?: (ctx: Override_kindContext) => void; + enterAlter_generic_option_elem?: (ctx: Alter_generic_option_elemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.override_kind`. + * Exit a parse tree produced by `PostgreSqlParser.alter_generic_option_elem`. * @param ctx the parse tree */ - exitOverride_kind?: (ctx: Override_kindContext) => void; + exitAlter_generic_option_elem?: (ctx: Alter_generic_option_elemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.insert_column_list`. + * Enter a parse tree produced by `PostgreSqlParser.generic_option_elem`. * @param ctx the parse tree */ - enterInsert_column_list?: (ctx: Insert_column_listContext) => void; + enterGeneric_option_elem?: (ctx: Generic_option_elemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.insert_column_list`. + * Exit a parse tree produced by `PostgreSqlParser.generic_option_elem`. * @param ctx the parse tree */ - exitInsert_column_list?: (ctx: Insert_column_listContext) => void; + exitGeneric_option_elem?: (ctx: Generic_option_elemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.insert_column_item`. + * Enter a parse tree produced by `PostgreSqlParser.createforeignserverstmt`. * @param ctx the parse tree */ - enterInsert_column_item?: (ctx: Insert_column_itemContext) => void; + enterCreateforeignserverstmt?: (ctx: CreateforeignserverstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.insert_column_item`. + * Exit a parse tree produced by `PostgreSqlParser.createforeignserverstmt`. * @param ctx the parse tree */ - exitInsert_column_item?: (ctx: Insert_column_itemContext) => void; + exitCreateforeignserverstmt?: (ctx: CreateforeignserverstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_on_conflict`. + * Enter a parse tree produced by `PostgreSqlParser.foreign_server_version`. * @param ctx the parse tree */ - enterOpt_on_conflict?: (ctx: Opt_on_conflictContext) => void; + enterForeign_server_version?: (ctx: Foreign_server_versionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_on_conflict`. + * Exit a parse tree produced by `PostgreSqlParser.foreign_server_version`. * @param ctx the parse tree */ - exitOpt_on_conflict?: (ctx: Opt_on_conflictContext) => void; + exitForeign_server_version?: (ctx: Foreign_server_versionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_conf_expr`. + * Enter a parse tree produced by `PostgreSqlParser.alterforeignserverstmt`. * @param ctx the parse tree */ - enterOpt_conf_expr?: (ctx: Opt_conf_exprContext) => void; + enterAlterforeignserverstmt?: (ctx: AlterforeignserverstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_conf_expr`. + * Exit a parse tree produced by `PostgreSqlParser.alterforeignserverstmt`. * @param ctx the parse tree */ - exitOpt_conf_expr?: (ctx: Opt_conf_exprContext) => void; + exitAlterforeignserverstmt?: (ctx: AlterforeignserverstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.returning_clause`. + * Enter a parse tree produced by the `createForeignTable` + * labeled alternative in `PostgreSqlParser.createforeigntablestmt`. * @param ctx the parse tree */ - enterReturning_clause?: (ctx: Returning_clauseContext) => void; + enterCreateForeignTable?: (ctx: CreateForeignTableContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.returning_clause`. + * Exit a parse tree produced by the `createForeignTable` + * labeled alternative in `PostgreSqlParser.createforeigntablestmt`. * @param ctx the parse tree */ - exitReturning_clause?: (ctx: Returning_clauseContext) => void; + exitCreateForeignTable?: (ctx: CreateForeignTableContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.deletestmt`. + * Enter a parse tree produced by the `createPartitionForeignTable` + * labeled alternative in `PostgreSqlParser.createforeigntablestmt`. * @param ctx the parse tree */ - enterDeletestmt?: (ctx: DeletestmtContext) => void; + enterCreatePartitionForeignTable?: (ctx: CreatePartitionForeignTableContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.deletestmt`. + * Exit a parse tree produced by the `createPartitionForeignTable` + * labeled alternative in `PostgreSqlParser.createforeigntablestmt`. * @param ctx the parse tree */ - exitDeletestmt?: (ctx: DeletestmtContext) => void; + exitCreatePartitionForeignTable?: (ctx: CreatePartitionForeignTableContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.using_clause`. + * Enter a parse tree produced by `PostgreSqlParser.importforeignschemastmt`. * @param ctx the parse tree */ - enterUsing_clause?: (ctx: Using_clauseContext) => void; + enterImportforeignschemastmt?: (ctx: ImportforeignschemastmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.using_clause`. + * Exit a parse tree produced by `PostgreSqlParser.importforeignschemastmt`. * @param ctx the parse tree */ - exitUsing_clause?: (ctx: Using_clauseContext) => void; + exitImportforeignschemastmt?: (ctx: ImportforeignschemastmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.lockstmt`. + * Enter a parse tree produced by `PostgreSqlParser.createusermappingstmt`. * @param ctx the parse tree */ - enterLockstmt?: (ctx: LockstmtContext) => void; + enterCreateusermappingstmt?: (ctx: CreateusermappingstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.lockstmt`. + * Exit a parse tree produced by `PostgreSqlParser.createusermappingstmt`. * @param ctx the parse tree */ - exitLockstmt?: (ctx: LockstmtContext) => void; + exitCreateusermappingstmt?: (ctx: CreateusermappingstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_lock`. + * Enter a parse tree produced by `PostgreSqlParser.alterusermappingstmt`. * @param ctx the parse tree */ - enterOpt_lock?: (ctx: Opt_lockContext) => void; + enterAlterusermappingstmt?: (ctx: AlterusermappingstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_lock`. + * Exit a parse tree produced by `PostgreSqlParser.alterusermappingstmt`. * @param ctx the parse tree */ - exitOpt_lock?: (ctx: Opt_lockContext) => void; + exitAlterusermappingstmt?: (ctx: AlterusermappingstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.lock_type`. + * Enter a parse tree produced by `PostgreSqlParser.createpolicystmt`. * @param ctx the parse tree */ - enterLock_type?: (ctx: Lock_typeContext) => void; + enterCreatepolicystmt?: (ctx: CreatepolicystmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.lock_type`. + * Exit a parse tree produced by `PostgreSqlParser.createpolicystmt`. * @param ctx the parse tree */ - exitLock_type?: (ctx: Lock_typeContext) => void; + exitCreatepolicystmt?: (ctx: CreatepolicystmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_nowait`. + * Enter a parse tree produced by `PostgreSqlParser.alterpolicystmt`. * @param ctx the parse tree */ - enterOpt_nowait?: (ctx: Opt_nowaitContext) => void; + enterAlterpolicystmt?: (ctx: AlterpolicystmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_nowait`. + * Exit a parse tree produced by `PostgreSqlParser.alterpolicystmt`. * @param ctx the parse tree */ - exitOpt_nowait?: (ctx: Opt_nowaitContext) => void; + exitAlterpolicystmt?: (ctx: AlterpolicystmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_nowait_or_skip`. + * Enter a parse tree produced by `PostgreSqlParser.alterprocedurestmt`. * @param ctx the parse tree */ - enterOpt_nowait_or_skip?: (ctx: Opt_nowait_or_skipContext) => void; + enterAlterprocedurestmt?: (ctx: AlterprocedurestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_nowait_or_skip`. + * Exit a parse tree produced by `PostgreSqlParser.alterprocedurestmt`. * @param ctx the parse tree */ - exitOpt_nowait_or_skip?: (ctx: Opt_nowait_or_skipContext) => void; + exitAlterprocedurestmt?: (ctx: AlterprocedurestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.updatestmt`. + * Enter a parse tree produced by `PostgreSqlParser.procedure_action`. * @param ctx the parse tree */ - enterUpdatestmt?: (ctx: UpdatestmtContext) => void; + enterProcedure_action?: (ctx: Procedure_actionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.updatestmt`. + * Exit a parse tree produced by `PostgreSqlParser.procedure_action`. * @param ctx the parse tree */ - exitUpdatestmt?: (ctx: UpdatestmtContext) => void; + exitProcedure_action?: (ctx: Procedure_actionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.set_clause_list`. + * Enter a parse tree produced by `PostgreSqlParser.rowsecurityoptionalexpr`. * @param ctx the parse tree */ - enterSet_clause_list?: (ctx: Set_clause_listContext) => void; + enterRowsecurityoptionalexpr?: (ctx: RowsecurityoptionalexprContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.set_clause_list`. + * Exit a parse tree produced by `PostgreSqlParser.rowsecurityoptionalexpr`. * @param ctx the parse tree */ - exitSet_clause_list?: (ctx: Set_clause_listContext) => void; + exitRowsecurityoptionalexpr?: (ctx: RowsecurityoptionalexprContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.set_clause`. + * Enter a parse tree produced by `PostgreSqlParser.rowsecurityoptionalwithcheck`. * @param ctx the parse tree */ - enterSet_clause?: (ctx: Set_clauseContext) => void; + enterRowsecurityoptionalwithcheck?: (ctx: RowsecurityoptionalwithcheckContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.set_clause`. + * Exit a parse tree produced by `PostgreSqlParser.rowsecurityoptionalwithcheck`. * @param ctx the parse tree */ - exitSet_clause?: (ctx: Set_clauseContext) => void; + exitRowsecurityoptionalwithcheck?: (ctx: RowsecurityoptionalwithcheckContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.set_target`. + * Enter a parse tree produced by `PostgreSqlParser.createamstmt`. * @param ctx the parse tree */ - enterSet_target?: (ctx: Set_targetContext) => void; + enterCreateamstmt?: (ctx: CreateamstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.set_target`. + * Exit a parse tree produced by `PostgreSqlParser.createamstmt`. * @param ctx the parse tree */ - exitSet_target?: (ctx: Set_targetContext) => void; + exitCreateamstmt?: (ctx: CreateamstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.set_target_list`. + * Enter a parse tree produced by `PostgreSqlParser.createtrigstmt`. * @param ctx the parse tree */ - enterSet_target_list?: (ctx: Set_target_listContext) => void; + enterCreatetrigstmt?: (ctx: CreatetrigstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.set_target_list`. + * Exit a parse tree produced by `PostgreSqlParser.createtrigstmt`. * @param ctx the parse tree */ - exitSet_target_list?: (ctx: Set_target_listContext) => void; + exitCreatetrigstmt?: (ctx: CreatetrigstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.declarecursorstmt`. + * Enter a parse tree produced by `PostgreSqlParser.triggeractiontime`. * @param ctx the parse tree */ - enterDeclarecursorstmt?: (ctx: DeclarecursorstmtContext) => void; + enterTriggeractiontime?: (ctx: TriggeractiontimeContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.declarecursorstmt`. + * Exit a parse tree produced by `PostgreSqlParser.triggeractiontime`. * @param ctx the parse tree */ - exitDeclarecursorstmt?: (ctx: DeclarecursorstmtContext) => void; + exitTriggeractiontime?: (ctx: TriggeractiontimeContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.cursor_name`. + * Enter a parse tree produced by `PostgreSqlParser.triggerevents`. * @param ctx the parse tree */ - enterCursor_name?: (ctx: Cursor_nameContext) => void; + enterTriggerevents?: (ctx: TriggereventsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.cursor_name`. + * Exit a parse tree produced by `PostgreSqlParser.triggerevents`. * @param ctx the parse tree */ - exitCursor_name?: (ctx: Cursor_nameContext) => void; + exitTriggerevents?: (ctx: TriggereventsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.cursor_options`. + * Enter a parse tree produced by `PostgreSqlParser.triggeroneevent`. * @param ctx the parse tree */ - enterCursor_options?: (ctx: Cursor_optionsContext) => void; + enterTriggeroneevent?: (ctx: TriggeroneeventContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.cursor_options`. + * Exit a parse tree produced by `PostgreSqlParser.triggeroneevent`. * @param ctx the parse tree */ - exitCursor_options?: (ctx: Cursor_optionsContext) => void; + exitTriggeroneevent?: (ctx: TriggeroneeventContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_hold`. + * Enter a parse tree produced by `PostgreSqlParser.triggerwhen`. * @param ctx the parse tree */ - enterOpt_hold?: (ctx: Opt_holdContext) => void; + enterTriggerwhen?: (ctx: TriggerwhenContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_hold`. + * Exit a parse tree produced by `PostgreSqlParser.triggerwhen`. * @param ctx the parse tree */ - exitOpt_hold?: (ctx: Opt_holdContext) => void; + exitTriggerwhen?: (ctx: TriggerwhenContext) => void; /** - * Enter a parse tree produced by the `selectStatement` - * labeled alternative in `PostgreSqlParser.selectstmt`. + * Enter a parse tree produced by `PostgreSqlParser.function_or_procedure`. * @param ctx the parse tree */ - enterSelectStatement?: (ctx: SelectStatementContext) => void; + enterFunction_or_procedure?: (ctx: Function_or_procedureContext) => void; /** - * Exit a parse tree produced by the `selectStatement` - * labeled alternative in `PostgreSqlParser.selectstmt`. + * Exit a parse tree produced by `PostgreSqlParser.function_or_procedure`. * @param ctx the parse tree */ - exitSelectStatement?: (ctx: SelectStatementContext) => void; + exitFunction_or_procedure?: (ctx: Function_or_procedureContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.select_with_parens`. + * Enter a parse tree produced by `PostgreSqlParser.triggerfuncargs`. * @param ctx the parse tree */ - enterSelect_with_parens?: (ctx: Select_with_parensContext) => void; + enterTriggerfuncargs?: (ctx: TriggerfuncargsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.select_with_parens`. + * Exit a parse tree produced by `PostgreSqlParser.triggerfuncargs`. * @param ctx the parse tree */ - exitSelect_with_parens?: (ctx: Select_with_parensContext) => void; + exitTriggerfuncargs?: (ctx: TriggerfuncargsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.select_no_parens`. + * Enter a parse tree produced by `PostgreSqlParser.triggerfuncarg`. * @param ctx the parse tree */ - enterSelect_no_parens?: (ctx: Select_no_parensContext) => void; + enterTriggerfuncarg?: (ctx: TriggerfuncargContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.select_no_parens`. + * Exit a parse tree produced by `PostgreSqlParser.triggerfuncarg`. * @param ctx the parse tree */ - exitSelect_no_parens?: (ctx: Select_no_parensContext) => void; + exitTriggerfuncarg?: (ctx: TriggerfuncargContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.select_clause`. + * Enter a parse tree produced by `PostgreSqlParser.constraintattributeElem`. * @param ctx the parse tree */ - enterSelect_clause?: (ctx: Select_clauseContext) => void; + enterConstraintattributeElem?: (ctx: ConstraintattributeElemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.select_clause`. + * Exit a parse tree produced by `PostgreSqlParser.constraintattributeElem`. * @param ctx the parse tree */ - exitSelect_clause?: (ctx: Select_clauseContext) => void; + exitConstraintattributeElem?: (ctx: ConstraintattributeElemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.simple_select`. + * Enter a parse tree produced by `PostgreSqlParser.createeventtrigstmt`. * @param ctx the parse tree */ - enterSimple_select?: (ctx: Simple_selectContext) => void; + enterCreateeventtrigstmt?: (ctx: CreateeventtrigstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.simple_select`. + * Exit a parse tree produced by `PostgreSqlParser.createeventtrigstmt`. * @param ctx the parse tree */ - exitSimple_select?: (ctx: Simple_selectContext) => void; + exitCreateeventtrigstmt?: (ctx: CreateeventtrigstmtContext) => void; /** - * Enter a parse tree produced by the `union` - * labeled alternative in `PostgreSqlParser.set_operator`. + * Enter a parse tree produced by `PostgreSqlParser.event_trigger_when_item`. * @param ctx the parse tree */ - enterUnion?: (ctx: UnionContext) => void; + enterEvent_trigger_when_item?: (ctx: Event_trigger_when_itemContext) => void; /** - * Exit a parse tree produced by the `union` - * labeled alternative in `PostgreSqlParser.set_operator`. + * Exit a parse tree produced by `PostgreSqlParser.event_trigger_when_item`. * @param ctx the parse tree */ - exitUnion?: (ctx: UnionContext) => void; + exitEvent_trigger_when_item?: (ctx: Event_trigger_when_itemContext) => void; /** - * Enter a parse tree produced by the `intersect` - * labeled alternative in `PostgreSqlParser.set_operator`. + * Enter a parse tree produced by `PostgreSqlParser.altereventtrigstmt`. * @param ctx the parse tree */ - enterIntersect?: (ctx: IntersectContext) => void; + enterAltereventtrigstmt?: (ctx: AltereventtrigstmtContext) => void; /** - * Exit a parse tree produced by the `intersect` - * labeled alternative in `PostgreSqlParser.set_operator`. + * Exit a parse tree produced by `PostgreSqlParser.altereventtrigstmt`. * @param ctx the parse tree */ - exitIntersect?: (ctx: IntersectContext) => void; + exitAltereventtrigstmt?: (ctx: AltereventtrigstmtContext) => void; /** - * Enter a parse tree produced by the `except` - * labeled alternative in `PostgreSqlParser.set_operator`. + * Enter a parse tree produced by `PostgreSqlParser.createassertionstmt`. * @param ctx the parse tree */ - enterExcept?: (ctx: ExceptContext) => void; + enterCreateassertionstmt?: (ctx: CreateassertionstmtContext) => void; /** - * Exit a parse tree produced by the `except` - * labeled alternative in `PostgreSqlParser.set_operator`. + * Exit a parse tree produced by `PostgreSqlParser.createassertionstmt`. * @param ctx the parse tree */ - exitExcept?: (ctx: ExceptContext) => void; + exitCreateassertionstmt?: (ctx: CreateassertionstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.set_operator_with_all_or_distinct`. + * Enter a parse tree produced by `PostgreSqlParser.definestmt`. * @param ctx the parse tree */ - enterSet_operator_with_all_or_distinct?: (ctx: Set_operator_with_all_or_distinctContext) => void; + enterDefinestmt?: (ctx: DefinestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.set_operator_with_all_or_distinct`. + * Exit a parse tree produced by `PostgreSqlParser.definestmt`. * @param ctx the parse tree */ - exitSet_operator_with_all_or_distinct?: (ctx: Set_operator_with_all_or_distinctContext) => void; + exitDefinestmt?: (ctx: DefinestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.with_clause`. + * Enter a parse tree produced by `PostgreSqlParser.definition`. * @param ctx the parse tree */ - enterWith_clause?: (ctx: With_clauseContext) => void; + enterDefinition?: (ctx: DefinitionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.with_clause`. + * Exit a parse tree produced by `PostgreSqlParser.definition`. * @param ctx the parse tree */ - exitWith_clause?: (ctx: With_clauseContext) => void; + exitDefinition?: (ctx: DefinitionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.cte_list`. + * Enter a parse tree produced by `PostgreSqlParser.def_elem`. * @param ctx the parse tree */ - enterCte_list?: (ctx: Cte_listContext) => void; + enterDef_elem?: (ctx: Def_elemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.cte_list`. + * Exit a parse tree produced by `PostgreSqlParser.def_elem`. * @param ctx the parse tree */ - exitCte_list?: (ctx: Cte_listContext) => void; + exitDef_elem?: (ctx: Def_elemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.common_table_expr`. + * Enter a parse tree produced by `PostgreSqlParser.def_arg`. * @param ctx the parse tree */ - enterCommon_table_expr?: (ctx: Common_table_exprContext) => void; + enterDef_arg?: (ctx: Def_argContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.common_table_expr`. + * Exit a parse tree produced by `PostgreSqlParser.def_arg`. * @param ctx the parse tree */ - exitCommon_table_expr?: (ctx: Common_table_exprContext) => void; + exitDef_arg?: (ctx: Def_argContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.search_cluase`. + * Enter a parse tree produced by `PostgreSqlParser.old_aggr_elem`. * @param ctx the parse tree */ - enterSearch_cluase?: (ctx: Search_cluaseContext) => void; + enterOld_aggr_elem?: (ctx: Old_aggr_elemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.search_cluase`. + * Exit a parse tree produced by `PostgreSqlParser.old_aggr_elem`. * @param ctx the parse tree */ - exitSearch_cluase?: (ctx: Search_cluaseContext) => void; + exitOld_aggr_elem?: (ctx: Old_aggr_elemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.cycle_cluase`. + * Enter a parse tree produced by `PostgreSqlParser.alterenumstmt`. * @param ctx the parse tree */ - enterCycle_cluase?: (ctx: Cycle_cluaseContext) => void; + enterAlterenumstmt?: (ctx: AlterenumstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.cycle_cluase`. + * Exit a parse tree produced by `PostgreSqlParser.alterenumstmt`. * @param ctx the parse tree */ - exitCycle_cluase?: (ctx: Cycle_cluaseContext) => void; + exitAlterenumstmt?: (ctx: AlterenumstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_materialized`. + * Enter a parse tree produced by `PostgreSqlParser.opt_if_not_exists`. * @param ctx the parse tree */ - enterOpt_materialized?: (ctx: Opt_materializedContext) => void; + enterOpt_if_not_exists?: (ctx: Opt_if_not_existsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_materialized`. + * Exit a parse tree produced by `PostgreSqlParser.opt_if_not_exists`. * @param ctx the parse tree */ - exitOpt_materialized?: (ctx: Opt_materializedContext) => void; + exitOpt_if_not_exists?: (ctx: Opt_if_not_existsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_with_clause`. + * Enter a parse tree produced by `PostgreSqlParser.createopclassstmt`. * @param ctx the parse tree */ - enterOpt_with_clause?: (ctx: Opt_with_clauseContext) => void; + enterCreateopclassstmt?: (ctx: CreateopclassstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_with_clause`. + * Exit a parse tree produced by `PostgreSqlParser.createopclassstmt`. * @param ctx the parse tree */ - exitOpt_with_clause?: (ctx: Opt_with_clauseContext) => void; + exitCreateopclassstmt?: (ctx: CreateopclassstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.into_clause`. + * Enter a parse tree produced by `PostgreSqlParser.opclass_item`. * @param ctx the parse tree */ - enterInto_clause?: (ctx: Into_clauseContext) => void; + enterOpclass_item?: (ctx: Opclass_itemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.into_clause`. + * Exit a parse tree produced by `PostgreSqlParser.opclass_item`. * @param ctx the parse tree */ - exitInto_clause?: (ctx: Into_clauseContext) => void; + exitOpclass_item?: (ctx: Opclass_itemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_strict`. + * Enter a parse tree produced by `PostgreSqlParser.createopfamilystmt`. * @param ctx the parse tree */ - enterOpt_strict?: (ctx: Opt_strictContext) => void; + enterCreateopfamilystmt?: (ctx: CreateopfamilystmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_strict`. + * Exit a parse tree produced by `PostgreSqlParser.createopfamilystmt`. * @param ctx the parse tree */ - exitOpt_strict?: (ctx: Opt_strictContext) => void; + exitCreateopfamilystmt?: (ctx: CreateopfamilystmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opttempTableName`. + * Enter a parse tree produced by `PostgreSqlParser.alteropfamilystmt`. * @param ctx the parse tree */ - enterOpttempTableName?: (ctx: OpttempTableNameContext) => void; + enterAlteropfamilystmt?: (ctx: AlteropfamilystmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opttempTableName`. + * Exit a parse tree produced by `PostgreSqlParser.alteropfamilystmt`. * @param ctx the parse tree */ - exitOpttempTableName?: (ctx: OpttempTableNameContext) => void; + exitAlteropfamilystmt?: (ctx: AlteropfamilystmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_table`. + * Enter a parse tree produced by `PostgreSqlParser.opclass_drop`. * @param ctx the parse tree */ - enterOpt_table?: (ctx: Opt_tableContext) => void; + enterOpclass_drop?: (ctx: Opclass_dropContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_table`. + * Exit a parse tree produced by `PostgreSqlParser.opclass_drop`. * @param ctx the parse tree */ - exitOpt_table?: (ctx: Opt_tableContext) => void; + exitOpclass_drop?: (ctx: Opclass_dropContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.all_or_distinct`. + * Enter a parse tree produced by `PostgreSqlParser.reassignownedstmt`. * @param ctx the parse tree */ - enterAll_or_distinct?: (ctx: All_or_distinctContext) => void; + enterReassignownedstmt?: (ctx: ReassignownedstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.all_or_distinct`. + * Exit a parse tree produced by `PostgreSqlParser.reassignownedstmt`. * @param ctx the parse tree */ - exitAll_or_distinct?: (ctx: All_or_distinctContext) => void; + exitReassignownedstmt?: (ctx: ReassignownedstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.distinct_clause`. + * Enter a parse tree produced by `PostgreSqlParser.dropstmt`. * @param ctx the parse tree */ - enterDistinct_clause?: (ctx: Distinct_clauseContext) => void; + enterDropstmt?: (ctx: DropstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.distinct_clause`. + * Exit a parse tree produced by `PostgreSqlParser.dropstmt`. * @param ctx the parse tree */ - exitDistinct_clause?: (ctx: Distinct_clauseContext) => void; + exitDropstmt?: (ctx: DropstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_all_clause`. + * Enter a parse tree produced by `PostgreSqlParser.object_type_any_name`. * @param ctx the parse tree */ - enterOpt_all_clause?: (ctx: Opt_all_clauseContext) => void; + enterObject_type_any_name?: (ctx: Object_type_any_nameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_all_clause`. + * Exit a parse tree produced by `PostgreSqlParser.object_type_any_name`. * @param ctx the parse tree */ - exitOpt_all_clause?: (ctx: Opt_all_clauseContext) => void; + exitObject_type_any_name?: (ctx: Object_type_any_nameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_sort_clause`. + * Enter a parse tree produced by `PostgreSqlParser.object_type_name`. * @param ctx the parse tree */ - enterOpt_sort_clause?: (ctx: Opt_sort_clauseContext) => void; + enterObject_type_name?: (ctx: Object_type_nameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_sort_clause`. + * Exit a parse tree produced by `PostgreSqlParser.object_type_name`. * @param ctx the parse tree */ - exitOpt_sort_clause?: (ctx: Opt_sort_clauseContext) => void; + exitObject_type_name?: (ctx: Object_type_nameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.sort_clause`. + * Enter a parse tree produced by `PostgreSqlParser.any_name_list`. * @param ctx the parse tree */ - enterSort_clause?: (ctx: Sort_clauseContext) => void; + enterAny_name_list?: (ctx: Any_name_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.sort_clause`. + * Exit a parse tree produced by `PostgreSqlParser.any_name_list`. * @param ctx the parse tree */ - exitSort_clause?: (ctx: Sort_clauseContext) => void; + exitAny_name_list?: (ctx: Any_name_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.sortby_list`. + * Enter a parse tree produced by `PostgreSqlParser.any_name`. * @param ctx the parse tree */ - enterSortby_list?: (ctx: Sortby_listContext) => void; + enterAny_name?: (ctx: Any_nameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.sortby_list`. + * Exit a parse tree produced by `PostgreSqlParser.any_name`. * @param ctx the parse tree */ - exitSortby_list?: (ctx: Sortby_listContext) => void; + exitAny_name?: (ctx: Any_nameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.sortby`. + * Enter a parse tree produced by `PostgreSqlParser.attrs`. * @param ctx the parse tree */ - enterSortby?: (ctx: SortbyContext) => void; + enterAttrs?: (ctx: AttrsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.sortby`. + * Exit a parse tree produced by `PostgreSqlParser.attrs`. * @param ctx the parse tree */ - exitSortby?: (ctx: SortbyContext) => void; + exitAttrs?: (ctx: AttrsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.select_limit`. + * Enter a parse tree produced by `PostgreSqlParser.truncatestmt`. * @param ctx the parse tree */ - enterSelect_limit?: (ctx: Select_limitContext) => void; + enterTruncatestmt?: (ctx: TruncatestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.select_limit`. + * Exit a parse tree produced by `PostgreSqlParser.truncatestmt`. * @param ctx the parse tree */ - exitSelect_limit?: (ctx: Select_limitContext) => void; + exitTruncatestmt?: (ctx: TruncatestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_select_limit`. + * Enter a parse tree produced by `PostgreSqlParser.truncate_table`. * @param ctx the parse tree */ - enterOpt_select_limit?: (ctx: Opt_select_limitContext) => void; + enterTruncate_table?: (ctx: Truncate_tableContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_select_limit`. + * Exit a parse tree produced by `PostgreSqlParser.truncate_table`. * @param ctx the parse tree */ - exitOpt_select_limit?: (ctx: Opt_select_limitContext) => void; + exitTruncate_table?: (ctx: Truncate_tableContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.limit_clause`. + * Enter a parse tree produced by `PostgreSqlParser.commentstmt`. * @param ctx the parse tree */ - enterLimit_clause?: (ctx: Limit_clauseContext) => void; + enterCommentstmt?: (ctx: CommentstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.limit_clause`. + * Exit a parse tree produced by `PostgreSqlParser.commentstmt`. * @param ctx the parse tree */ - exitLimit_clause?: (ctx: Limit_clauseContext) => void; + exitCommentstmt?: (ctx: CommentstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.fetch_clause`. + * Enter a parse tree produced by `PostgreSqlParser.seclabelstmt`. * @param ctx the parse tree */ - enterFetch_clause?: (ctx: Fetch_clauseContext) => void; + enterSeclabelstmt?: (ctx: SeclabelstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.fetch_clause`. + * Exit a parse tree produced by `PostgreSqlParser.seclabelstmt`. * @param ctx the parse tree */ - exitFetch_clause?: (ctx: Fetch_clauseContext) => void; + exitSeclabelstmt?: (ctx: SeclabelstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.offset_clause`. + * Enter a parse tree produced by `PostgreSqlParser.fetchstmt`. * @param ctx the parse tree */ - enterOffset_clause?: (ctx: Offset_clauseContext) => void; + enterFetchstmt?: (ctx: FetchstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.offset_clause`. + * Exit a parse tree produced by `PostgreSqlParser.fetchstmt`. * @param ctx the parse tree */ - exitOffset_clause?: (ctx: Offset_clauseContext) => void; + exitFetchstmt?: (ctx: FetchstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.select_limit_value`. + * Enter a parse tree produced by `PostgreSqlParser.fetch_args`. * @param ctx the parse tree */ - enterSelect_limit_value?: (ctx: Select_limit_valueContext) => void; + enterFetch_args?: (ctx: Fetch_argsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.select_limit_value`. + * Exit a parse tree produced by `PostgreSqlParser.fetch_args`. * @param ctx the parse tree */ - exitSelect_limit_value?: (ctx: Select_limit_valueContext) => void; + exitFetch_args?: (ctx: Fetch_argsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.select_offset_value`. + * Enter a parse tree produced by `PostgreSqlParser.from_in`. * @param ctx the parse tree */ - enterSelect_offset_value?: (ctx: Select_offset_valueContext) => void; + enterFrom_in?: (ctx: From_inContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.select_offset_value`. + * Exit a parse tree produced by `PostgreSqlParser.from_in`. * @param ctx the parse tree */ - exitSelect_offset_value?: (ctx: Select_offset_valueContext) => void; + exitFrom_in?: (ctx: From_inContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.select_fetch_first_value`. + * Enter a parse tree produced by `PostgreSqlParser.grantstmt`. * @param ctx the parse tree */ - enterSelect_fetch_first_value?: (ctx: Select_fetch_first_valueContext) => void; + enterGrantstmt?: (ctx: GrantstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.select_fetch_first_value`. + * Exit a parse tree produced by `PostgreSqlParser.grantstmt`. * @param ctx the parse tree */ - exitSelect_fetch_first_value?: (ctx: Select_fetch_first_valueContext) => void; + exitGrantstmt?: (ctx: GrantstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.i_or_f_const`. + * Enter a parse tree produced by `PostgreSqlParser.revokestmt`. * @param ctx the parse tree */ - enterI_or_f_const?: (ctx: I_or_f_constContext) => void; + enterRevokestmt?: (ctx: RevokestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.i_or_f_const`. + * Exit a parse tree produced by `PostgreSqlParser.revokestmt`. * @param ctx the parse tree */ - exitI_or_f_const?: (ctx: I_or_f_constContext) => void; + exitRevokestmt?: (ctx: RevokestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.row_or_rows`. + * Enter a parse tree produced by `PostgreSqlParser.privileges`. * @param ctx the parse tree */ - enterRow_or_rows?: (ctx: Row_or_rowsContext) => void; + enterPrivileges?: (ctx: PrivilegesContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.row_or_rows`. + * Exit a parse tree produced by `PostgreSqlParser.privileges`. * @param ctx the parse tree */ - exitRow_or_rows?: (ctx: Row_or_rowsContext) => void; + exitPrivileges?: (ctx: PrivilegesContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.first_or_next`. + * Enter a parse tree produced by `PostgreSqlParser.beforeprivilegeselect`. * @param ctx the parse tree */ - enterFirst_or_next?: (ctx: First_or_nextContext) => void; + enterBeforeprivilegeselect?: (ctx: BeforeprivilegeselectContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.first_or_next`. + * Exit a parse tree produced by `PostgreSqlParser.beforeprivilegeselect`. * @param ctx the parse tree */ - exitFirst_or_next?: (ctx: First_or_nextContext) => void; + exitBeforeprivilegeselect?: (ctx: BeforeprivilegeselectContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.group_clause`. + * Enter a parse tree produced by `PostgreSqlParser.privilege`. * @param ctx the parse tree */ - enterGroup_clause?: (ctx: Group_clauseContext) => void; + enterPrivilege?: (ctx: PrivilegeContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.group_clause`. + * Exit a parse tree produced by `PostgreSqlParser.privilege`. * @param ctx the parse tree */ - exitGroup_clause?: (ctx: Group_clauseContext) => void; + exitPrivilege?: (ctx: PrivilegeContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.group_by_list`. + * Enter a parse tree produced by `PostgreSqlParser.privilege_target`. * @param ctx the parse tree */ - enterGroup_by_list?: (ctx: Group_by_listContext) => void; + enterPrivilege_target?: (ctx: Privilege_targetContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.group_by_list`. + * Exit a parse tree produced by `PostgreSqlParser.privilege_target`. * @param ctx the parse tree */ - exitGroup_by_list?: (ctx: Group_by_listContext) => void; + exitPrivilege_target?: (ctx: Privilege_targetContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.group_by_item`. + * Enter a parse tree produced by `PostgreSqlParser.grantee_list`. * @param ctx the parse tree */ - enterGroup_by_item?: (ctx: Group_by_itemContext) => void; + enterGrantee_list?: (ctx: Grantee_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.group_by_item`. + * Exit a parse tree produced by `PostgreSqlParser.grantee_list`. * @param ctx the parse tree */ - exitGroup_by_item?: (ctx: Group_by_itemContext) => void; + exitGrantee_list?: (ctx: Grantee_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.empty_grouping_set`. + * Enter a parse tree produced by `PostgreSqlParser.grantrolestmt`. * @param ctx the parse tree */ - enterEmpty_grouping_set?: (ctx: Empty_grouping_setContext) => void; + enterGrantrolestmt?: (ctx: GrantrolestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.empty_grouping_set`. + * Exit a parse tree produced by `PostgreSqlParser.grantrolestmt`. * @param ctx the parse tree */ - exitEmpty_grouping_set?: (ctx: Empty_grouping_setContext) => void; + exitGrantrolestmt?: (ctx: GrantrolestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.rollup_clause`. + * Enter a parse tree produced by `PostgreSqlParser.revokerolestmt`. * @param ctx the parse tree */ - enterRollup_clause?: (ctx: Rollup_clauseContext) => void; + enterRevokerolestmt?: (ctx: RevokerolestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.rollup_clause`. + * Exit a parse tree produced by `PostgreSqlParser.revokerolestmt`. * @param ctx the parse tree */ - exitRollup_clause?: (ctx: Rollup_clauseContext) => void; + exitRevokerolestmt?: (ctx: RevokerolestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.cube_clause`. + * Enter a parse tree produced by `PostgreSqlParser.alterdefaultprivilegesstmt`. * @param ctx the parse tree */ - enterCube_clause?: (ctx: Cube_clauseContext) => void; + enterAlterdefaultprivilegesstmt?: (ctx: AlterdefaultprivilegesstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.cube_clause`. + * Exit a parse tree produced by `PostgreSqlParser.alterdefaultprivilegesstmt`. * @param ctx the parse tree */ - exitCube_clause?: (ctx: Cube_clauseContext) => void; + exitAlterdefaultprivilegesstmt?: (ctx: AlterdefaultprivilegesstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.grouping_sets_clause`. + * Enter a parse tree produced by `PostgreSqlParser.defaclaction`. * @param ctx the parse tree */ - enterGrouping_sets_clause?: (ctx: Grouping_sets_clauseContext) => void; + enterDefaclaction?: (ctx: DefaclactionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.grouping_sets_clause`. + * Exit a parse tree produced by `PostgreSqlParser.defaclaction`. * @param ctx the parse tree */ - exitGrouping_sets_clause?: (ctx: Grouping_sets_clauseContext) => void; + exitDefaclaction?: (ctx: DefaclactionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.having_clause`. + * Enter a parse tree produced by `PostgreSqlParser.defacl_privilege_target`. * @param ctx the parse tree */ - enterHaving_clause?: (ctx: Having_clauseContext) => void; + enterDefacl_privilege_target?: (ctx: Defacl_privilege_targetContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.having_clause`. + * Exit a parse tree produced by `PostgreSqlParser.defacl_privilege_target`. * @param ctx the parse tree */ - exitHaving_clause?: (ctx: Having_clauseContext) => void; + exitDefacl_privilege_target?: (ctx: Defacl_privilege_targetContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.for_locking_clause`. + * Enter a parse tree produced by `PostgreSqlParser.indexstmt`. * @param ctx the parse tree */ - enterFor_locking_clause?: (ctx: For_locking_clauseContext) => void; + enterIndexstmt?: (ctx: IndexstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.for_locking_clause`. + * Exit a parse tree produced by `PostgreSqlParser.indexstmt`. * @param ctx the parse tree */ - exitFor_locking_clause?: (ctx: For_locking_clauseContext) => void; + exitIndexstmt?: (ctx: IndexstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_for_locking_clause`. + * Enter a parse tree produced by `PostgreSqlParser.index_params`. * @param ctx the parse tree */ - enterOpt_for_locking_clause?: (ctx: Opt_for_locking_clauseContext) => void; + enterIndex_params?: (ctx: Index_paramsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_for_locking_clause`. + * Exit a parse tree produced by `PostgreSqlParser.index_params`. * @param ctx the parse tree */ - exitOpt_for_locking_clause?: (ctx: Opt_for_locking_clauseContext) => void; + exitIndex_params?: (ctx: Index_paramsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.for_locking_items`. + * Enter a parse tree produced by `PostgreSqlParser.index_elem`. * @param ctx the parse tree */ - enterFor_locking_items?: (ctx: For_locking_itemsContext) => void; + enterIndex_elem?: (ctx: Index_elemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.for_locking_items`. + * Exit a parse tree produced by `PostgreSqlParser.index_elem`. * @param ctx the parse tree */ - exitFor_locking_items?: (ctx: For_locking_itemsContext) => void; + exitIndex_elem?: (ctx: Index_elemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.for_locking_item`. + * Enter a parse tree produced by `PostgreSqlParser.createfunctionstmt`. * @param ctx the parse tree */ - enterFor_locking_item?: (ctx: For_locking_itemContext) => void; + enterCreatefunctionstmt?: (ctx: CreatefunctionstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.for_locking_item`. + * Exit a parse tree produced by `PostgreSqlParser.createfunctionstmt`. * @param ctx the parse tree */ - exitFor_locking_item?: (ctx: For_locking_itemContext) => void; + exitCreatefunctionstmt?: (ctx: CreatefunctionstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.for_locking_strength`. + * Enter a parse tree produced by `PostgreSqlParser.opt_or_replace`. * @param ctx the parse tree */ - enterFor_locking_strength?: (ctx: For_locking_strengthContext) => void; + enterOpt_or_replace?: (ctx: Opt_or_replaceContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.for_locking_strength`. + * Exit a parse tree produced by `PostgreSqlParser.opt_or_replace`. * @param ctx the parse tree */ - exitFor_locking_strength?: (ctx: For_locking_strengthContext) => void; + exitOpt_or_replace?: (ctx: Opt_or_replaceContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.locked_rels_list`. + * Enter a parse tree produced by `PostgreSqlParser.func_args`. * @param ctx the parse tree */ - enterLocked_rels_list?: (ctx: Locked_rels_listContext) => void; + enterFunc_args?: (ctx: Func_argsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.locked_rels_list`. + * Exit a parse tree produced by `PostgreSqlParser.func_args`. * @param ctx the parse tree */ - exitLocked_rels_list?: (ctx: Locked_rels_listContext) => void; + exitFunc_args?: (ctx: Func_argsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.values_clause`. + * Enter a parse tree produced by `PostgreSqlParser.func_args_list`. * @param ctx the parse tree */ - enterValues_clause?: (ctx: Values_clauseContext) => void; + enterFunc_args_list?: (ctx: Func_args_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.values_clause`. + * Exit a parse tree produced by `PostgreSqlParser.func_args_list`. * @param ctx the parse tree */ - exitValues_clause?: (ctx: Values_clauseContext) => void; + exitFunc_args_list?: (ctx: Func_args_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.from_clause`. + * Enter a parse tree produced by `PostgreSqlParser.routine_with_argtypes_list`. * @param ctx the parse tree */ - enterFrom_clause?: (ctx: From_clauseContext) => void; + enterRoutine_with_argtypes_list?: (ctx: Routine_with_argtypes_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.from_clause`. + * Exit a parse tree produced by `PostgreSqlParser.routine_with_argtypes_list`. * @param ctx the parse tree */ - exitFrom_clause?: (ctx: From_clauseContext) => void; + exitRoutine_with_argtypes_list?: (ctx: Routine_with_argtypes_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.from_list`. + * Enter a parse tree produced by `PostgreSqlParser.routine_with_argtypes`. * @param ctx the parse tree */ - enterFrom_list?: (ctx: From_listContext) => void; + enterRoutine_with_argtypes?: (ctx: Routine_with_argtypesContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.from_list`. + * Exit a parse tree produced by `PostgreSqlParser.routine_with_argtypes`. * @param ctx the parse tree */ - exitFrom_list?: (ctx: From_listContext) => void; + exitRoutine_with_argtypes?: (ctx: Routine_with_argtypesContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.table_ref`. + * Enter a parse tree produced by `PostgreSqlParser.procedure_with_argtypes_list`. * @param ctx the parse tree */ - enterTable_ref?: (ctx: Table_refContext) => void; + enterProcedure_with_argtypes_list?: (ctx: Procedure_with_argtypes_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.table_ref`. + * Exit a parse tree produced by `PostgreSqlParser.procedure_with_argtypes_list`. * @param ctx the parse tree */ - exitTable_ref?: (ctx: Table_refContext) => void; + exitProcedure_with_argtypes_list?: (ctx: Procedure_with_argtypes_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.alias_clause`. + * Enter a parse tree produced by `PostgreSqlParser.procedure_with_argtypes`. * @param ctx the parse tree */ - enterAlias_clause?: (ctx: Alias_clauseContext) => void; + enterProcedure_with_argtypes?: (ctx: Procedure_with_argtypesContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.alias_clause`. + * Exit a parse tree produced by `PostgreSqlParser.procedure_with_argtypes`. * @param ctx the parse tree */ - exitAlias_clause?: (ctx: Alias_clauseContext) => void; + exitProcedure_with_argtypes?: (ctx: Procedure_with_argtypesContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_alias_clause`. + * Enter a parse tree produced by `PostgreSqlParser.function_with_argtypes_list`. * @param ctx the parse tree */ - enterOpt_alias_clause?: (ctx: Opt_alias_clauseContext) => void; + enterFunction_with_argtypes_list?: (ctx: Function_with_argtypes_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_alias_clause`. + * Exit a parse tree produced by `PostgreSqlParser.function_with_argtypes_list`. * @param ctx the parse tree */ - exitOpt_alias_clause?: (ctx: Opt_alias_clauseContext) => void; + exitFunction_with_argtypes_list?: (ctx: Function_with_argtypes_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.func_alias_clause`. + * Enter a parse tree produced by `PostgreSqlParser.function_with_argtypes`. * @param ctx the parse tree */ - enterFunc_alias_clause?: (ctx: Func_alias_clauseContext) => void; + enterFunction_with_argtypes?: (ctx: Function_with_argtypesContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.func_alias_clause`. + * Exit a parse tree produced by `PostgreSqlParser.function_with_argtypes`. * @param ctx the parse tree */ - exitFunc_alias_clause?: (ctx: Func_alias_clauseContext) => void; + exitFunction_with_argtypes?: (ctx: Function_with_argtypesContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.join_type`. + * Enter a parse tree produced by `PostgreSqlParser.func_arg`. * @param ctx the parse tree */ - enterJoin_type?: (ctx: Join_typeContext) => void; + enterFunc_arg?: (ctx: Func_argContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.join_type`. + * Exit a parse tree produced by `PostgreSqlParser.func_arg`. * @param ctx the parse tree */ - exitJoin_type?: (ctx: Join_typeContext) => void; + exitFunc_arg?: (ctx: Func_argContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.join_qual`. + * Enter a parse tree produced by `PostgreSqlParser.arg_class`. * @param ctx the parse tree */ - enterJoin_qual?: (ctx: Join_qualContext) => void; + enterArg_class?: (ctx: Arg_classContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.join_qual`. + * Exit a parse tree produced by `PostgreSqlParser.arg_class`. * @param ctx the parse tree */ - exitJoin_qual?: (ctx: Join_qualContext) => void; + exitArg_class?: (ctx: Arg_classContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.relation_expr`. + * Enter a parse tree produced by `PostgreSqlParser.func_type`. * @param ctx the parse tree */ - enterRelation_expr?: (ctx: Relation_exprContext) => void; + enterFunc_type?: (ctx: Func_typeContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.relation_expr`. + * Exit a parse tree produced by `PostgreSqlParser.func_type`. * @param ctx the parse tree */ - exitRelation_expr?: (ctx: Relation_exprContext) => void; + exitFunc_type?: (ctx: Func_typeContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.view_relation_expr`. + * Enter a parse tree produced by `PostgreSqlParser.func_arg_with_default`. * @param ctx the parse tree */ - enterView_relation_expr?: (ctx: View_relation_exprContext) => void; + enterFunc_arg_with_default?: (ctx: Func_arg_with_defaultContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.view_relation_expr`. + * Exit a parse tree produced by `PostgreSqlParser.func_arg_with_default`. * @param ctx the parse tree */ - exitView_relation_expr?: (ctx: View_relation_exprContext) => void; + exitFunc_arg_with_default?: (ctx: Func_arg_with_defaultContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.publication_relation_expr`. + * Enter a parse tree produced by `PostgreSqlParser.aggr_args`. * @param ctx the parse tree */ - enterPublication_relation_expr?: (ctx: Publication_relation_exprContext) => void; + enterAggr_args?: (ctx: Aggr_argsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.publication_relation_expr`. + * Exit a parse tree produced by `PostgreSqlParser.aggr_args`. * @param ctx the parse tree */ - exitPublication_relation_expr?: (ctx: Publication_relation_exprContext) => void; + exitAggr_args?: (ctx: Aggr_argsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.relation_expr_list`. + * Enter a parse tree produced by `PostgreSqlParser.aggregate_with_argtypes`. * @param ctx the parse tree */ - enterRelation_expr_list?: (ctx: Relation_expr_listContext) => void; + enterAggregate_with_argtypes?: (ctx: Aggregate_with_argtypesContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.relation_expr_list`. + * Exit a parse tree produced by `PostgreSqlParser.aggregate_with_argtypes`. * @param ctx the parse tree */ - exitRelation_expr_list?: (ctx: Relation_expr_listContext) => void; + exitAggregate_with_argtypes?: (ctx: Aggregate_with_argtypesContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.publication_relation_expr_list`. + * Enter a parse tree produced by `PostgreSqlParser.common_func_opt_item`. * @param ctx the parse tree */ - enterPublication_relation_expr_list?: (ctx: Publication_relation_expr_listContext) => void; + enterCommon_func_opt_item?: (ctx: Common_func_opt_itemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.publication_relation_expr_list`. + * Exit a parse tree produced by `PostgreSqlParser.common_func_opt_item`. * @param ctx the parse tree */ - exitPublication_relation_expr_list?: (ctx: Publication_relation_expr_listContext) => void; + exitCommon_func_opt_item?: (ctx: Common_func_opt_itemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.relation_expr_opt_alias`. + * Enter a parse tree produced by `PostgreSqlParser.createfunc_opt_item`. * @param ctx the parse tree */ - enterRelation_expr_opt_alias?: (ctx: Relation_expr_opt_aliasContext) => void; + enterCreatefunc_opt_item?: (ctx: Createfunc_opt_itemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.relation_expr_opt_alias`. + * Exit a parse tree produced by `PostgreSqlParser.createfunc_opt_item`. * @param ctx the parse tree */ - exitRelation_expr_opt_alias?: (ctx: Relation_expr_opt_aliasContext) => void; + exitCreatefunc_opt_item?: (ctx: Createfunc_opt_itemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.tablesample_clause`. + * Enter a parse tree produced by `PostgreSqlParser.opt_definition`. * @param ctx the parse tree */ - enterTablesample_clause?: (ctx: Tablesample_clauseContext) => void; + enterOpt_definition?: (ctx: Opt_definitionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.tablesample_clause`. + * Exit a parse tree produced by `PostgreSqlParser.opt_definition`. * @param ctx the parse tree */ - exitTablesample_clause?: (ctx: Tablesample_clauseContext) => void; + exitOpt_definition?: (ctx: Opt_definitionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_repeatable_clause`. + * Enter a parse tree produced by `PostgreSqlParser.table_func_column`. * @param ctx the parse tree */ - enterOpt_repeatable_clause?: (ctx: Opt_repeatable_clauseContext) => void; + enterTable_func_column?: (ctx: Table_func_columnContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_repeatable_clause`. + * Exit a parse tree produced by `PostgreSqlParser.table_func_column`. * @param ctx the parse tree */ - exitOpt_repeatable_clause?: (ctx: Opt_repeatable_clauseContext) => void; + exitTable_func_column?: (ctx: Table_func_columnContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.func_table`. + * Enter a parse tree produced by `PostgreSqlParser.alterfunctionstmt`. * @param ctx the parse tree */ - enterFunc_table?: (ctx: Func_tableContext) => void; + enterAlterfunctionstmt?: (ctx: AlterfunctionstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.func_table`. + * Exit a parse tree produced by `PostgreSqlParser.alterfunctionstmt`. * @param ctx the parse tree */ - exitFunc_table?: (ctx: Func_tableContext) => void; + exitAlterfunctionstmt?: (ctx: AlterfunctionstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.rowsfrom_item`. + * Enter a parse tree produced by `PostgreSqlParser.removefuncstmt`. * @param ctx the parse tree */ - enterRowsfrom_item?: (ctx: Rowsfrom_itemContext) => void; + enterRemovefuncstmt?: (ctx: RemovefuncstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.rowsfrom_item`. + * Exit a parse tree produced by `PostgreSqlParser.removefuncstmt`. * @param ctx the parse tree */ - exitRowsfrom_item?: (ctx: Rowsfrom_itemContext) => void; + exitRemovefuncstmt?: (ctx: RemovefuncstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.rowsfrom_list`. + * Enter a parse tree produced by `PostgreSqlParser.removeaggrstmt`. * @param ctx the parse tree */ - enterRowsfrom_list?: (ctx: Rowsfrom_listContext) => void; + enterRemoveaggrstmt?: (ctx: RemoveaggrstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.rowsfrom_list`. + * Exit a parse tree produced by `PostgreSqlParser.removeaggrstmt`. * @param ctx the parse tree */ - exitRowsfrom_list?: (ctx: Rowsfrom_listContext) => void; + exitRemoveaggrstmt?: (ctx: RemoveaggrstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_col_def_list`. + * Enter a parse tree produced by `PostgreSqlParser.removeoperstmt`. * @param ctx the parse tree */ - enterOpt_col_def_list?: (ctx: Opt_col_def_listContext) => void; + enterRemoveoperstmt?: (ctx: RemoveoperstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_col_def_list`. + * Exit a parse tree produced by `PostgreSqlParser.removeoperstmt`. * @param ctx the parse tree */ - exitOpt_col_def_list?: (ctx: Opt_col_def_listContext) => void; + exitRemoveoperstmt?: (ctx: RemoveoperstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_ordinality`. + * Enter a parse tree produced by `PostgreSqlParser.oper_argtypes`. * @param ctx the parse tree */ - enterOpt_ordinality?: (ctx: Opt_ordinalityContext) => void; + enterOper_argtypes?: (ctx: Oper_argtypesContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_ordinality`. + * Exit a parse tree produced by `PostgreSqlParser.oper_argtypes`. * @param ctx the parse tree */ - exitOpt_ordinality?: (ctx: Opt_ordinalityContext) => void; + exitOper_argtypes?: (ctx: Oper_argtypesContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.where_clause`. + * Enter a parse tree produced by `PostgreSqlParser.any_operator`. * @param ctx the parse tree */ - enterWhere_clause?: (ctx: Where_clauseContext) => void; + enterAny_operator?: (ctx: Any_operatorContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.where_clause`. + * Exit a parse tree produced by `PostgreSqlParser.any_operator`. * @param ctx the parse tree */ - exitWhere_clause?: (ctx: Where_clauseContext) => void; + exitAny_operator?: (ctx: Any_operatorContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.where_or_current_clause`. + * Enter a parse tree produced by `PostgreSqlParser.operator_with_argtypes`. * @param ctx the parse tree */ - enterWhere_or_current_clause?: (ctx: Where_or_current_clauseContext) => void; + enterOperator_with_argtypes?: (ctx: Operator_with_argtypesContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.where_or_current_clause`. + * Exit a parse tree produced by `PostgreSqlParser.operator_with_argtypes`. * @param ctx the parse tree */ - exitWhere_or_current_clause?: (ctx: Where_or_current_clauseContext) => void; + exitOperator_with_argtypes?: (ctx: Operator_with_argtypesContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opttablefuncelementlist`. + * Enter a parse tree produced by `PostgreSqlParser.dostmt`. * @param ctx the parse tree */ - enterOpttablefuncelementlist?: (ctx: OpttablefuncelementlistContext) => void; + enterDostmt?: (ctx: DostmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opttablefuncelementlist`. + * Exit a parse tree produced by `PostgreSqlParser.dostmt`. * @param ctx the parse tree */ - exitOpttablefuncelementlist?: (ctx: OpttablefuncelementlistContext) => void; + exitDostmt?: (ctx: DostmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.tablefuncelementlist`. + * Enter a parse tree produced by `PostgreSqlParser.createcaststmt`. * @param ctx the parse tree */ - enterTablefuncelementlist?: (ctx: TablefuncelementlistContext) => void; + enterCreatecaststmt?: (ctx: CreatecaststmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.tablefuncelementlist`. + * Exit a parse tree produced by `PostgreSqlParser.createcaststmt`. * @param ctx the parse tree */ - exitTablefuncelementlist?: (ctx: TablefuncelementlistContext) => void; + exitCreatecaststmt?: (ctx: CreatecaststmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.tablefuncelement`. + * Enter a parse tree produced by `PostgreSqlParser.opt_if_exists`. * @param ctx the parse tree */ - enterTablefuncelement?: (ctx: TablefuncelementContext) => void; + enterOpt_if_exists?: (ctx: Opt_if_existsContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.tablefuncelement`. + * Exit a parse tree produced by `PostgreSqlParser.opt_if_exists`. * @param ctx the parse tree */ - exitTablefuncelement?: (ctx: TablefuncelementContext) => void; + exitOpt_if_exists?: (ctx: Opt_if_existsContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xmltable`. + * Enter a parse tree produced by `PostgreSqlParser.createtransformstmt`. * @param ctx the parse tree */ - enterXmltable?: (ctx: XmltableContext) => void; + enterCreatetransformstmt?: (ctx: CreatetransformstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xmltable`. + * Exit a parse tree produced by `PostgreSqlParser.createtransformstmt`. * @param ctx the parse tree */ - exitXmltable?: (ctx: XmltableContext) => void; + exitCreatetransformstmt?: (ctx: CreatetransformstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xmltable_column_list`. + * Enter a parse tree produced by `PostgreSqlParser.sql_with_function`. * @param ctx the parse tree */ - enterXmltable_column_list?: (ctx: Xmltable_column_listContext) => void; + enterSql_with_function?: (ctx: Sql_with_functionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xmltable_column_list`. + * Exit a parse tree produced by `PostgreSqlParser.sql_with_function`. * @param ctx the parse tree */ - exitXmltable_column_list?: (ctx: Xmltable_column_listContext) => void; + exitSql_with_function?: (ctx: Sql_with_functionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xmltable_column_el`. + * Enter a parse tree produced by `PostgreSqlParser.reindexstmt`. * @param ctx the parse tree */ - enterXmltable_column_el?: (ctx: Xmltable_column_elContext) => void; + enterReindexstmt?: (ctx: ReindexstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xmltable_column_el`. + * Exit a parse tree produced by `PostgreSqlParser.reindexstmt`. * @param ctx the parse tree */ - exitXmltable_column_el?: (ctx: Xmltable_column_elContext) => void; + exitReindexstmt?: (ctx: ReindexstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xmltable_column_option_list`. + * Enter a parse tree produced by `PostgreSqlParser.altertblspcstmt`. * @param ctx the parse tree */ - enterXmltable_column_option_list?: (ctx: Xmltable_column_option_listContext) => void; + enterAltertblspcstmt?: (ctx: AltertblspcstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xmltable_column_option_list`. + * Exit a parse tree produced by `PostgreSqlParser.altertblspcstmt`. * @param ctx the parse tree */ - exitXmltable_column_option_list?: (ctx: Xmltable_column_option_listContext) => void; + exitAltertblspcstmt?: (ctx: AltertblspcstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xmltable_column_option_el`. + * Enter a parse tree produced by `PostgreSqlParser.renamestmt`. * @param ctx the parse tree */ - enterXmltable_column_option_el?: (ctx: Xmltable_column_option_elContext) => void; + enterRenamestmt?: (ctx: RenamestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xmltable_column_option_el`. + * Exit a parse tree produced by `PostgreSqlParser.renamestmt`. * @param ctx the parse tree */ - exitXmltable_column_option_el?: (ctx: Xmltable_column_option_elContext) => void; + exitRenamestmt?: (ctx: RenamestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xml_namespace_list`. + * Enter a parse tree produced by `PostgreSqlParser.alterobjectdependsstmt`. * @param ctx the parse tree */ - enterXml_namespace_list?: (ctx: Xml_namespace_listContext) => void; + enterAlterobjectdependsstmt?: (ctx: AlterobjectdependsstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xml_namespace_list`. + * Exit a parse tree produced by `PostgreSqlParser.alterobjectdependsstmt`. * @param ctx the parse tree */ - exitXml_namespace_list?: (ctx: Xml_namespace_listContext) => void; + exitAlterobjectdependsstmt?: (ctx: AlterobjectdependsstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xml_namespace_el`. + * Enter a parse tree produced by `PostgreSqlParser.alterobjectschemastmt`. * @param ctx the parse tree */ - enterXml_namespace_el?: (ctx: Xml_namespace_elContext) => void; + enterAlterobjectschemastmt?: (ctx: AlterobjectschemastmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xml_namespace_el`. + * Exit a parse tree produced by `PostgreSqlParser.alterobjectschemastmt`. * @param ctx the parse tree */ - exitXml_namespace_el?: (ctx: Xml_namespace_elContext) => void; + exitAlterobjectschemastmt?: (ctx: AlterobjectschemastmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.typename`. + * Enter a parse tree produced by `PostgreSqlParser.alteroperatorstmt`. * @param ctx the parse tree */ - enterTypename?: (ctx: TypenameContext) => void; + enterAlteroperatorstmt?: (ctx: AlteroperatorstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.typename`. + * Exit a parse tree produced by `PostgreSqlParser.alteroperatorstmt`. * @param ctx the parse tree */ - exitTypename?: (ctx: TypenameContext) => void; + exitAlteroperatorstmt?: (ctx: AlteroperatorstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_array_bounds`. + * Enter a parse tree produced by `PostgreSqlParser.operator_def_list`. * @param ctx the parse tree */ - enterOpt_array_bounds?: (ctx: Opt_array_boundsContext) => void; + enterOperator_def_list?: (ctx: Operator_def_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_array_bounds`. + * Exit a parse tree produced by `PostgreSqlParser.operator_def_list`. * @param ctx the parse tree */ - exitOpt_array_bounds?: (ctx: Opt_array_boundsContext) => void; + exitOperator_def_list?: (ctx: Operator_def_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.simpletypename`. + * Enter a parse tree produced by `PostgreSqlParser.operator_def_elem`. * @param ctx the parse tree */ - enterSimpletypename?: (ctx: SimpletypenameContext) => void; + enterOperator_def_elem?: (ctx: Operator_def_elemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.simpletypename`. + * Exit a parse tree produced by `PostgreSqlParser.operator_def_elem`. * @param ctx the parse tree */ - exitSimpletypename?: (ctx: SimpletypenameContext) => void; + exitOperator_def_elem?: (ctx: Operator_def_elemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.consttypename`. + * Enter a parse tree produced by `PostgreSqlParser.altertypestmt`. * @param ctx the parse tree */ - enterConsttypename?: (ctx: ConsttypenameContext) => void; + enterAltertypestmt?: (ctx: AltertypestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.consttypename`. + * Exit a parse tree produced by `PostgreSqlParser.altertypestmt`. * @param ctx the parse tree */ - exitConsttypename?: (ctx: ConsttypenameContext) => void; + exitAltertypestmt?: (ctx: AltertypestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.generictype`. + * Enter a parse tree produced by `PostgreSqlParser.alterownerstmt`. * @param ctx the parse tree */ - enterGenerictype?: (ctx: GenerictypeContext) => void; + enterAlterownerstmt?: (ctx: AlterownerstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.generictype`. + * Exit a parse tree produced by `PostgreSqlParser.alterownerstmt`. * @param ctx the parse tree */ - exitGenerictype?: (ctx: GenerictypeContext) => void; + exitAlterownerstmt?: (ctx: AlterownerstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_type_modifiers`. + * Enter a parse tree produced by `PostgreSqlParser.createpublicationstmt`. * @param ctx the parse tree */ - enterOpt_type_modifiers?: (ctx: Opt_type_modifiersContext) => void; + enterCreatepublicationstmt?: (ctx: CreatepublicationstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_type_modifiers`. + * Exit a parse tree produced by `PostgreSqlParser.createpublicationstmt`. * @param ctx the parse tree */ - exitOpt_type_modifiers?: (ctx: Opt_type_modifiersContext) => void; + exitCreatepublicationstmt?: (ctx: CreatepublicationstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.numeric`. + * Enter a parse tree produced by `PostgreSqlParser.alterpublicationstmt`. * @param ctx the parse tree */ - enterNumeric?: (ctx: NumericContext) => void; + enterAlterpublicationstmt?: (ctx: AlterpublicationstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.numeric`. + * Exit a parse tree produced by `PostgreSqlParser.alterpublicationstmt`. * @param ctx the parse tree */ - exitNumeric?: (ctx: NumericContext) => void; + exitAlterpublicationstmt?: (ctx: AlterpublicationstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_float`. + * Enter a parse tree produced by `PostgreSqlParser.createsubscriptionstmt`. * @param ctx the parse tree */ - enterOpt_float?: (ctx: Opt_floatContext) => void; + enterCreatesubscriptionstmt?: (ctx: CreatesubscriptionstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_float`. + * Exit a parse tree produced by `PostgreSqlParser.createsubscriptionstmt`. * @param ctx the parse tree */ - exitOpt_float?: (ctx: Opt_floatContext) => void; + exitCreatesubscriptionstmt?: (ctx: CreatesubscriptionstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.bit`. + * Enter a parse tree produced by `PostgreSqlParser.altersubscriptionstmt`. * @param ctx the parse tree */ - enterBit?: (ctx: BitContext) => void; + enterAltersubscriptionstmt?: (ctx: AltersubscriptionstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.bit`. + * Exit a parse tree produced by `PostgreSqlParser.altersubscriptionstmt`. * @param ctx the parse tree */ - exitBit?: (ctx: BitContext) => void; + exitAltersubscriptionstmt?: (ctx: AltersubscriptionstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.constbit`. + * Enter a parse tree produced by `PostgreSqlParser.rulestmt`. * @param ctx the parse tree */ - enterConstbit?: (ctx: ConstbitContext) => void; + enterRulestmt?: (ctx: RulestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.constbit`. + * Exit a parse tree produced by `PostgreSqlParser.rulestmt`. * @param ctx the parse tree */ - exitConstbit?: (ctx: ConstbitContext) => void; + exitRulestmt?: (ctx: RulestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.bitwithlength`. + * Enter a parse tree produced by `PostgreSqlParser.ruleactionstmt`. * @param ctx the parse tree */ - enterBitwithlength?: (ctx: BitwithlengthContext) => void; + enterRuleactionstmt?: (ctx: RuleactionstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.bitwithlength`. + * Exit a parse tree produced by `PostgreSqlParser.ruleactionstmt`. * @param ctx the parse tree */ - exitBitwithlength?: (ctx: BitwithlengthContext) => void; + exitRuleactionstmt?: (ctx: RuleactionstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.bitwithoutlength`. + * Enter a parse tree produced by `PostgreSqlParser.notifystmt`. * @param ctx the parse tree */ - enterBitwithoutlength?: (ctx: BitwithoutlengthContext) => void; + enterNotifystmt?: (ctx: NotifystmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.bitwithoutlength`. + * Exit a parse tree produced by `PostgreSqlParser.notifystmt`. * @param ctx the parse tree */ - exitBitwithoutlength?: (ctx: BitwithoutlengthContext) => void; + exitNotifystmt?: (ctx: NotifystmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.character`. + * Enter a parse tree produced by `PostgreSqlParser.notify_payload`. * @param ctx the parse tree */ - enterCharacter?: (ctx: CharacterContext) => void; + enterNotify_payload?: (ctx: Notify_payloadContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.character`. + * Exit a parse tree produced by `PostgreSqlParser.notify_payload`. * @param ctx the parse tree */ - exitCharacter?: (ctx: CharacterContext) => void; + exitNotify_payload?: (ctx: Notify_payloadContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.constcharacter`. + * Enter a parse tree produced by `PostgreSqlParser.listenstmt`. * @param ctx the parse tree */ - enterConstcharacter?: (ctx: ConstcharacterContext) => void; + enterListenstmt?: (ctx: ListenstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.constcharacter`. + * Exit a parse tree produced by `PostgreSqlParser.listenstmt`. * @param ctx the parse tree */ - exitConstcharacter?: (ctx: ConstcharacterContext) => void; + exitListenstmt?: (ctx: ListenstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.character_c`. + * Enter a parse tree produced by `PostgreSqlParser.unlistenstmt`. * @param ctx the parse tree */ - enterCharacter_c?: (ctx: Character_cContext) => void; + enterUnlistenstmt?: (ctx: UnlistenstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.character_c`. + * Exit a parse tree produced by `PostgreSqlParser.unlistenstmt`. * @param ctx the parse tree */ - exitCharacter_c?: (ctx: Character_cContext) => void; + exitUnlistenstmt?: (ctx: UnlistenstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_varying`. + * Enter a parse tree produced by `PostgreSqlParser.transactionstmt`. * @param ctx the parse tree */ - enterOpt_varying?: (ctx: Opt_varyingContext) => void; + enterTransactionstmt?: (ctx: TransactionstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_varying`. + * Exit a parse tree produced by `PostgreSqlParser.transactionstmt`. * @param ctx the parse tree */ - exitOpt_varying?: (ctx: Opt_varyingContext) => void; + exitTransactionstmt?: (ctx: TransactionstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.constdatetime`. + * Enter a parse tree produced by `PostgreSqlParser.opt_transaction`. * @param ctx the parse tree */ - enterConstdatetime?: (ctx: ConstdatetimeContext) => void; + enterOpt_transaction?: (ctx: Opt_transactionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.constdatetime`. + * Exit a parse tree produced by `PostgreSqlParser.opt_transaction`. * @param ctx the parse tree */ - exitConstdatetime?: (ctx: ConstdatetimeContext) => void; + exitOpt_transaction?: (ctx: Opt_transactionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.constinterval`. + * Enter a parse tree produced by `PostgreSqlParser.transaction_mode_item`. * @param ctx the parse tree */ - enterConstinterval?: (ctx: ConstintervalContext) => void; + enterTransaction_mode_item?: (ctx: Transaction_mode_itemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.constinterval`. + * Exit a parse tree produced by `PostgreSqlParser.transaction_mode_item`. * @param ctx the parse tree */ - exitConstinterval?: (ctx: ConstintervalContext) => void; + exitTransaction_mode_item?: (ctx: Transaction_mode_itemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_timezone`. + * Enter a parse tree produced by `PostgreSqlParser.transaction_mode_list`. * @param ctx the parse tree */ - enterOpt_timezone?: (ctx: Opt_timezoneContext) => void; + enterTransaction_mode_list?: (ctx: Transaction_mode_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_timezone`. + * Exit a parse tree produced by `PostgreSqlParser.transaction_mode_list`. * @param ctx the parse tree */ - exitOpt_timezone?: (ctx: Opt_timezoneContext) => void; + exitTransaction_mode_list?: (ctx: Transaction_mode_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_interval`. + * Enter a parse tree produced by the `createView` + * labeled alternative in `PostgreSqlParser.viewstmt`. * @param ctx the parse tree */ - enterOpt_interval?: (ctx: Opt_intervalContext) => void; + enterCreateView?: (ctx: CreateViewContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_interval`. + * Exit a parse tree produced by the `createView` + * labeled alternative in `PostgreSqlParser.viewstmt`. * @param ctx the parse tree */ - exitOpt_interval?: (ctx: Opt_intervalContext) => void; + exitCreateView?: (ctx: CreateViewContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.interval_second`. + * Enter a parse tree produced by `PostgreSqlParser.loadstmt`. * @param ctx the parse tree */ - enterInterval_second?: (ctx: Interval_secondContext) => void; + enterLoadstmt?: (ctx: LoadstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.interval_second`. + * Exit a parse tree produced by `PostgreSqlParser.loadstmt`. * @param ctx the parse tree */ - exitInterval_second?: (ctx: Interval_secondContext) => void; + exitLoadstmt?: (ctx: LoadstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_escape`. + * Enter a parse tree produced by the `createDatabase` + * labeled alternative in `PostgreSqlParser.createdbstmt`. * @param ctx the parse tree */ - enterOpt_escape?: (ctx: Opt_escapeContext) => void; + enterCreateDatabase?: (ctx: CreateDatabaseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_escape`. + * Exit a parse tree produced by the `createDatabase` + * labeled alternative in `PostgreSqlParser.createdbstmt`. * @param ctx the parse tree */ - exitOpt_escape?: (ctx: Opt_escapeContext) => void; + exitCreateDatabase?: (ctx: CreateDatabaseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr`. + * Enter a parse tree produced by `PostgreSqlParser.createdb_opt_item`. * @param ctx the parse tree */ - enterA_expr?: (ctx: A_exprContext) => void; + enterCreatedb_opt_item?: (ctx: Createdb_opt_itemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr`. + * Exit a parse tree produced by `PostgreSqlParser.createdb_opt_item`. * @param ctx the parse tree */ - exitA_expr?: (ctx: A_exprContext) => void; + exitCreatedb_opt_item?: (ctx: Createdb_opt_itemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_qual`. + * Enter a parse tree produced by `PostgreSqlParser.alterdatabasestmt`. * @param ctx the parse tree */ - enterA_expr_qual?: (ctx: A_expr_qualContext) => void; + enterAlterdatabasestmt?: (ctx: AlterdatabasestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_qual`. + * Exit a parse tree produced by `PostgreSqlParser.alterdatabasestmt`. * @param ctx the parse tree */ - exitA_expr_qual?: (ctx: A_expr_qualContext) => void; + exitAlterdatabasestmt?: (ctx: AlterdatabasestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_lessless`. + * Enter a parse tree produced by `PostgreSqlParser.alterdatabasesetstmt`. * @param ctx the parse tree */ - enterA_expr_lessless?: (ctx: A_expr_lesslessContext) => void; + enterAlterdatabasesetstmt?: (ctx: AlterdatabasesetstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_lessless`. + * Exit a parse tree produced by `PostgreSqlParser.alterdatabasesetstmt`. * @param ctx the parse tree */ - exitA_expr_lessless?: (ctx: A_expr_lesslessContext) => void; + exitAlterdatabasesetstmt?: (ctx: AlterdatabasesetstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_or`. + * Enter a parse tree produced by `PostgreSqlParser.altercollationstmt`. * @param ctx the parse tree */ - enterA_expr_or?: (ctx: A_expr_orContext) => void; + enterAltercollationstmt?: (ctx: AltercollationstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_or`. + * Exit a parse tree produced by `PostgreSqlParser.altercollationstmt`. * @param ctx the parse tree */ - exitA_expr_or?: (ctx: A_expr_orContext) => void; + exitAltercollationstmt?: (ctx: AltercollationstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_and`. + * Enter a parse tree produced by `PostgreSqlParser.altersystemstmt`. * @param ctx the parse tree */ - enterA_expr_and?: (ctx: A_expr_andContext) => void; + enterAltersystemstmt?: (ctx: AltersystemstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_and`. + * Exit a parse tree produced by `PostgreSqlParser.altersystemstmt`. * @param ctx the parse tree */ - exitA_expr_and?: (ctx: A_expr_andContext) => void; + exitAltersystemstmt?: (ctx: AltersystemstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_in`. + * Enter a parse tree produced by `PostgreSqlParser.createdomainstmt`. * @param ctx the parse tree */ - enterA_expr_in?: (ctx: A_expr_inContext) => void; + enterCreatedomainstmt?: (ctx: CreatedomainstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_in`. + * Exit a parse tree produced by `PostgreSqlParser.createdomainstmt`. * @param ctx the parse tree */ - exitA_expr_in?: (ctx: A_expr_inContext) => void; + exitCreatedomainstmt?: (ctx: CreatedomainstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_unary_not`. + * Enter a parse tree produced by `PostgreSqlParser.alterdomainstmt`. * @param ctx the parse tree */ - enterA_expr_unary_not?: (ctx: A_expr_unary_notContext) => void; + enterAlterdomainstmt?: (ctx: AlterdomainstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_unary_not`. + * Exit a parse tree produced by `PostgreSqlParser.alterdomainstmt`. * @param ctx the parse tree */ - exitA_expr_unary_not?: (ctx: A_expr_unary_notContext) => void; + exitAlterdomainstmt?: (ctx: AlterdomainstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_isnull`. + * Enter a parse tree produced by `PostgreSqlParser.altertsdictionarystmt`. * @param ctx the parse tree */ - enterA_expr_isnull?: (ctx: A_expr_isnullContext) => void; + enterAltertsdictionarystmt?: (ctx: AltertsdictionarystmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_isnull`. + * Exit a parse tree produced by `PostgreSqlParser.altertsdictionarystmt`. * @param ctx the parse tree */ - exitA_expr_isnull?: (ctx: A_expr_isnullContext) => void; + exitAltertsdictionarystmt?: (ctx: AltertsdictionarystmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_is_not`. + * Enter a parse tree produced by `PostgreSqlParser.altertsconfigurationstmt`. * @param ctx the parse tree */ - enterA_expr_is_not?: (ctx: A_expr_is_notContext) => void; + enterAltertsconfigurationstmt?: (ctx: AltertsconfigurationstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_is_not`. + * Exit a parse tree produced by `PostgreSqlParser.altertsconfigurationstmt`. * @param ctx the parse tree */ - exitA_expr_is_not?: (ctx: A_expr_is_notContext) => void; + exitAltertsconfigurationstmt?: (ctx: AltertsconfigurationstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_compare`. + * Enter a parse tree produced by `PostgreSqlParser.createconversionstmt`. * @param ctx the parse tree */ - enterA_expr_compare?: (ctx: A_expr_compareContext) => void; + enterCreateconversionstmt?: (ctx: CreateconversionstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_compare`. + * Exit a parse tree produced by `PostgreSqlParser.createconversionstmt`. * @param ctx the parse tree */ - exitA_expr_compare?: (ctx: A_expr_compareContext) => void; + exitCreateconversionstmt?: (ctx: CreateconversionstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_like`. + * Enter a parse tree produced by `PostgreSqlParser.clusterstmt`. * @param ctx the parse tree */ - enterA_expr_like?: (ctx: A_expr_likeContext) => void; + enterClusterstmt?: (ctx: ClusterstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_like`. + * Exit a parse tree produced by `PostgreSqlParser.clusterstmt`. * @param ctx the parse tree */ - exitA_expr_like?: (ctx: A_expr_likeContext) => void; + exitClusterstmt?: (ctx: ClusterstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_qual_op`. + * Enter a parse tree produced by `PostgreSqlParser.vacuumstmt`. * @param ctx the parse tree */ - enterA_expr_qual_op?: (ctx: A_expr_qual_opContext) => void; + enterVacuumstmt?: (ctx: VacuumstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_qual_op`. + * Exit a parse tree produced by `PostgreSqlParser.vacuumstmt`. * @param ctx the parse tree */ - exitA_expr_qual_op?: (ctx: A_expr_qual_opContext) => void; + exitVacuumstmt?: (ctx: VacuumstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_unary_qualop`. + * Enter a parse tree produced by `PostgreSqlParser.analyzestmt`. * @param ctx the parse tree */ - enterA_expr_unary_qualop?: (ctx: A_expr_unary_qualopContext) => void; + enterAnalyzestmt?: (ctx: AnalyzestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_unary_qualop`. + * Exit a parse tree produced by `PostgreSqlParser.analyzestmt`. * @param ctx the parse tree */ - exitA_expr_unary_qualop?: (ctx: A_expr_unary_qualopContext) => void; + exitAnalyzestmt?: (ctx: AnalyzestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_add`. + * Enter a parse tree produced by `PostgreSqlParser.analyze_keyword`. * @param ctx the parse tree */ - enterA_expr_add?: (ctx: A_expr_addContext) => void; + enterAnalyze_keyword?: (ctx: Analyze_keywordContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_add`. + * Exit a parse tree produced by `PostgreSqlParser.analyze_keyword`. * @param ctx the parse tree */ - exitA_expr_add?: (ctx: A_expr_addContext) => void; + exitAnalyze_keyword?: (ctx: Analyze_keywordContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_mul`. + * Enter a parse tree produced by `PostgreSqlParser.vac_analyze_option_elem`. * @param ctx the parse tree */ - enterA_expr_mul?: (ctx: A_expr_mulContext) => void; + enterVac_analyze_option_elem?: (ctx: Vac_analyze_option_elemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_mul`. + * Exit a parse tree produced by `PostgreSqlParser.vac_analyze_option_elem`. * @param ctx the parse tree */ - exitA_expr_mul?: (ctx: A_expr_mulContext) => void; + exitVac_analyze_option_elem?: (ctx: Vac_analyze_option_elemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_caret`. + * Enter a parse tree produced by `PostgreSqlParser.analyze_option_elem`. * @param ctx the parse tree */ - enterA_expr_caret?: (ctx: A_expr_caretContext) => void; + enterAnalyze_option_elem?: (ctx: Analyze_option_elemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_caret`. + * Exit a parse tree produced by `PostgreSqlParser.analyze_option_elem`. * @param ctx the parse tree */ - exitA_expr_caret?: (ctx: A_expr_caretContext) => void; + exitAnalyze_option_elem?: (ctx: Analyze_option_elemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_unary_sign`. + * Enter a parse tree produced by `PostgreSqlParser.opt_verbose`. * @param ctx the parse tree */ - enterA_expr_unary_sign?: (ctx: A_expr_unary_signContext) => void; + enterOpt_verbose?: (ctx: Opt_verboseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_unary_sign`. + * Exit a parse tree produced by `PostgreSqlParser.opt_verbose`. * @param ctx the parse tree */ - exitA_expr_unary_sign?: (ctx: A_expr_unary_signContext) => void; + exitOpt_verbose?: (ctx: Opt_verboseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_at_time_zone`. + * Enter a parse tree produced by `PostgreSqlParser.vacuum_relation`. * @param ctx the parse tree */ - enterA_expr_at_time_zone?: (ctx: A_expr_at_time_zoneContext) => void; + enterVacuum_relation?: (ctx: Vacuum_relationContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_at_time_zone`. + * Exit a parse tree produced by `PostgreSqlParser.vacuum_relation`. * @param ctx the parse tree */ - exitA_expr_at_time_zone?: (ctx: A_expr_at_time_zoneContext) => void; + exitVacuum_relation?: (ctx: Vacuum_relationContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_collate`. + * Enter a parse tree produced by `PostgreSqlParser.vacuum_relation_list`. * @param ctx the parse tree */ - enterA_expr_collate?: (ctx: A_expr_collateContext) => void; + enterVacuum_relation_list?: (ctx: Vacuum_relation_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_collate`. + * Exit a parse tree produced by `PostgreSqlParser.vacuum_relation_list`. * @param ctx the parse tree */ - exitA_expr_collate?: (ctx: A_expr_collateContext) => void; + exitVacuum_relation_list?: (ctx: Vacuum_relation_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.a_expr_typecast`. + * Enter a parse tree produced by `PostgreSqlParser.explainstmt`. * @param ctx the parse tree */ - enterA_expr_typecast?: (ctx: A_expr_typecastContext) => void; + enterExplainstmt?: (ctx: ExplainstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.a_expr_typecast`. + * Exit a parse tree produced by `PostgreSqlParser.explainstmt`. * @param ctx the parse tree */ - exitA_expr_typecast?: (ctx: A_expr_typecastContext) => void; + exitExplainstmt?: (ctx: ExplainstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.b_expr`. + * Enter a parse tree produced by `PostgreSqlParser.explainablestmt`. * @param ctx the parse tree */ - enterB_expr?: (ctx: B_exprContext) => void; + enterExplainablestmt?: (ctx: ExplainablestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.b_expr`. + * Exit a parse tree produced by `PostgreSqlParser.explainablestmt`. * @param ctx the parse tree */ - exitB_expr?: (ctx: B_exprContext) => void; + exitExplainablestmt?: (ctx: ExplainablestmtContext) => void; /** - * Enter a parse tree produced by the `c_expr_exists` - * labeled alternative in `PostgreSqlParser.c_expr`. + * Enter a parse tree produced by `PostgreSqlParser.explain_option_list`. * @param ctx the parse tree */ - enterC_expr_exists?: (ctx: C_expr_existsContext) => void; + enterExplain_option_list?: (ctx: Explain_option_listContext) => void; /** - * Exit a parse tree produced by the `c_expr_exists` - * labeled alternative in `PostgreSqlParser.c_expr`. + * Exit a parse tree produced by `PostgreSqlParser.explain_option_list`. * @param ctx the parse tree */ - exitC_expr_exists?: (ctx: C_expr_existsContext) => void; + exitExplain_option_list?: (ctx: Explain_option_listContext) => void; /** - * Enter a parse tree produced by the `c_expr_expr` - * labeled alternative in `PostgreSqlParser.c_expr`. + * Enter a parse tree produced by `PostgreSqlParser.preparestmt`. * @param ctx the parse tree */ - enterC_expr_expr?: (ctx: C_expr_exprContext) => void; + enterPreparestmt?: (ctx: PreparestmtContext) => void; /** - * Exit a parse tree produced by the `c_expr_expr` - * labeled alternative in `PostgreSqlParser.c_expr`. + * Exit a parse tree produced by `PostgreSqlParser.preparestmt`. * @param ctx the parse tree */ - exitC_expr_expr?: (ctx: C_expr_exprContext) => void; + exitPreparestmt?: (ctx: PreparestmtContext) => void; /** - * Enter a parse tree produced by the `c_expr_case` - * labeled alternative in `PostgreSqlParser.c_expr`. + * Enter a parse tree produced by `PostgreSqlParser.prep_type_clause`. * @param ctx the parse tree */ - enterC_expr_case?: (ctx: C_expr_caseContext) => void; + enterPrep_type_clause?: (ctx: Prep_type_clauseContext) => void; /** - * Exit a parse tree produced by the `c_expr_case` - * labeled alternative in `PostgreSqlParser.c_expr`. + * Exit a parse tree produced by `PostgreSqlParser.prep_type_clause`. * @param ctx the parse tree */ - exitC_expr_case?: (ctx: C_expr_caseContext) => void; + exitPrep_type_clause?: (ctx: Prep_type_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.plsqlvariablename`. + * Enter a parse tree produced by `PostgreSqlParser.preparablestmt`. * @param ctx the parse tree */ - enterPlsqlvariablename?: (ctx: PlsqlvariablenameContext) => void; + enterPreparablestmt?: (ctx: PreparablestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.plsqlvariablename`. + * Exit a parse tree produced by `PostgreSqlParser.preparablestmt`. * @param ctx the parse tree */ - exitPlsqlvariablename?: (ctx: PlsqlvariablenameContext) => void; + exitPreparablestmt?: (ctx: PreparablestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.func_application`. + * Enter a parse tree produced by `PostgreSqlParser.executestmt`. * @param ctx the parse tree */ - enterFunc_application?: (ctx: Func_applicationContext) => void; + enterExecutestmt?: (ctx: ExecutestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.func_application`. + * Exit a parse tree produced by `PostgreSqlParser.executestmt`. * @param ctx the parse tree */ - exitFunc_application?: (ctx: Func_applicationContext) => void; + exitExecutestmt?: (ctx: ExecutestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.func_expr`. + * Enter a parse tree produced by `PostgreSqlParser.execute_param_clause`. * @param ctx the parse tree */ - enterFunc_expr?: (ctx: Func_exprContext) => void; + enterExecute_param_clause?: (ctx: Execute_param_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.func_expr`. + * Exit a parse tree produced by `PostgreSqlParser.execute_param_clause`. * @param ctx the parse tree */ - exitFunc_expr?: (ctx: Func_exprContext) => void; + exitExecute_param_clause?: (ctx: Execute_param_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.func_expr_windowless`. + * Enter a parse tree produced by `PostgreSqlParser.deallocatestmt`. * @param ctx the parse tree */ - enterFunc_expr_windowless?: (ctx: Func_expr_windowlessContext) => void; + enterDeallocatestmt?: (ctx: DeallocatestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.func_expr_windowless`. + * Exit a parse tree produced by `PostgreSqlParser.deallocatestmt`. * @param ctx the parse tree */ - exitFunc_expr_windowless?: (ctx: Func_expr_windowlessContext) => void; + exitDeallocatestmt?: (ctx: DeallocatestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.func_expr_common_subexpr`. + * Enter a parse tree produced by the `insertStatement` + * labeled alternative in `PostgreSqlParser.insertstmt`. * @param ctx the parse tree */ - enterFunc_expr_common_subexpr?: (ctx: Func_expr_common_subexprContext) => void; + enterInsertStatement?: (ctx: InsertStatementContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.func_expr_common_subexpr`. + * Exit a parse tree produced by the `insertStatement` + * labeled alternative in `PostgreSqlParser.insertstmt`. * @param ctx the parse tree */ - exitFunc_expr_common_subexpr?: (ctx: Func_expr_common_subexprContext) => void; + exitInsertStatement?: (ctx: InsertStatementContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xml_root_version`. + * Enter a parse tree produced by `PostgreSqlParser.insert_rest`. * @param ctx the parse tree */ - enterXml_root_version?: (ctx: Xml_root_versionContext) => void; + enterInsert_rest?: (ctx: Insert_restContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xml_root_version`. + * Exit a parse tree produced by `PostgreSqlParser.insert_rest`. * @param ctx the parse tree */ - exitXml_root_version?: (ctx: Xml_root_versionContext) => void; + exitInsert_rest?: (ctx: Insert_restContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_xml_root_standalone`. + * Enter a parse tree produced by `PostgreSqlParser.insert_column_list`. * @param ctx the parse tree */ - enterOpt_xml_root_standalone?: (ctx: Opt_xml_root_standaloneContext) => void; + enterInsert_column_list?: (ctx: Insert_column_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_xml_root_standalone`. + * Exit a parse tree produced by `PostgreSqlParser.insert_column_list`. * @param ctx the parse tree */ - exitOpt_xml_root_standalone?: (ctx: Opt_xml_root_standaloneContext) => void; + exitInsert_column_list?: (ctx: Insert_column_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xml_attributes`. + * Enter a parse tree produced by `PostgreSqlParser.insert_column_item`. * @param ctx the parse tree */ - enterXml_attributes?: (ctx: Xml_attributesContext) => void; + enterInsert_column_item?: (ctx: Insert_column_itemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xml_attributes`. + * Exit a parse tree produced by `PostgreSqlParser.insert_column_item`. * @param ctx the parse tree */ - exitXml_attributes?: (ctx: Xml_attributesContext) => void; + exitInsert_column_item?: (ctx: Insert_column_itemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xml_attribute_list`. + * Enter a parse tree produced by `PostgreSqlParser.returning_clause`. * @param ctx the parse tree */ - enterXml_attribute_list?: (ctx: Xml_attribute_listContext) => void; + enterReturning_clause?: (ctx: Returning_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xml_attribute_list`. + * Exit a parse tree produced by `PostgreSqlParser.returning_clause`. * @param ctx the parse tree */ - exitXml_attribute_list?: (ctx: Xml_attribute_listContext) => void; + exitReturning_clause?: (ctx: Returning_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xml_attribute_el`. + * Enter a parse tree produced by `PostgreSqlParser.deletestmt`. * @param ctx the parse tree */ - enterXml_attribute_el?: (ctx: Xml_attribute_elContext) => void; + enterDeletestmt?: (ctx: DeletestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xml_attribute_el`. + * Exit a parse tree produced by `PostgreSqlParser.deletestmt`. * @param ctx the parse tree */ - exitXml_attribute_el?: (ctx: Xml_attribute_elContext) => void; + exitDeletestmt?: (ctx: DeletestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.document_or_content`. + * Enter a parse tree produced by `PostgreSqlParser.lockstmt`. * @param ctx the parse tree */ - enterDocument_or_content?: (ctx: Document_or_contentContext) => void; + enterLockstmt?: (ctx: LockstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.document_or_content`. + * Exit a parse tree produced by `PostgreSqlParser.lockstmt`. * @param ctx the parse tree */ - exitDocument_or_content?: (ctx: Document_or_contentContext) => void; + exitLockstmt?: (ctx: LockstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xml_whitespace_option`. + * Enter a parse tree produced by `PostgreSqlParser.updatestmt`. * @param ctx the parse tree */ - enterXml_whitespace_option?: (ctx: Xml_whitespace_optionContext) => void; + enterUpdatestmt?: (ctx: UpdatestmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xml_whitespace_option`. + * Exit a parse tree produced by `PostgreSqlParser.updatestmt`. * @param ctx the parse tree */ - exitXml_whitespace_option?: (ctx: Xml_whitespace_optionContext) => void; + exitUpdatestmt?: (ctx: UpdatestmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xmlexists_argument`. + * Enter a parse tree produced by `PostgreSqlParser.set_clause_list`. * @param ctx the parse tree */ - enterXmlexists_argument?: (ctx: Xmlexists_argumentContext) => void; + enterSet_clause_list?: (ctx: Set_clause_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xmlexists_argument`. + * Exit a parse tree produced by `PostgreSqlParser.set_clause_list`. * @param ctx the parse tree */ - exitXmlexists_argument?: (ctx: Xmlexists_argumentContext) => void; + exitSet_clause_list?: (ctx: Set_clause_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xml_passing_mech`. + * Enter a parse tree produced by `PostgreSqlParser.set_clause`. * @param ctx the parse tree */ - enterXml_passing_mech?: (ctx: Xml_passing_mechContext) => void; + enterSet_clause?: (ctx: Set_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xml_passing_mech`. + * Exit a parse tree produced by `PostgreSqlParser.set_clause`. * @param ctx the parse tree */ - exitXml_passing_mech?: (ctx: Xml_passing_mechContext) => void; + exitSet_clause?: (ctx: Set_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.within_group_clause`. + * Enter a parse tree produced by `PostgreSqlParser.declarecursorstmt`. * @param ctx the parse tree */ - enterWithin_group_clause?: (ctx: Within_group_clauseContext) => void; + enterDeclarecursorstmt?: (ctx: DeclarecursorstmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.within_group_clause`. + * Exit a parse tree produced by `PostgreSqlParser.declarecursorstmt`. * @param ctx the parse tree */ - exitWithin_group_clause?: (ctx: Within_group_clauseContext) => void; + exitDeclarecursorstmt?: (ctx: DeclarecursorstmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.filter_clause`. + * Enter a parse tree produced by the `selectStatement` + * labeled alternative in `PostgreSqlParser.selectstmt`. * @param ctx the parse tree */ - enterFilter_clause?: (ctx: Filter_clauseContext) => void; + enterSelectStatement?: (ctx: SelectStatementContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.filter_clause`. + * Exit a parse tree produced by the `selectStatement` + * labeled alternative in `PostgreSqlParser.selectstmt`. * @param ctx the parse tree */ - exitFilter_clause?: (ctx: Filter_clauseContext) => void; + exitSelectStatement?: (ctx: SelectStatementContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.window_clause`. + * Enter a parse tree produced by `PostgreSqlParser.select_with_parens`. * @param ctx the parse tree */ - enterWindow_clause?: (ctx: Window_clauseContext) => void; + enterSelect_with_parens?: (ctx: Select_with_parensContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.window_clause`. + * Exit a parse tree produced by `PostgreSqlParser.select_with_parens`. * @param ctx the parse tree */ - exitWindow_clause?: (ctx: Window_clauseContext) => void; + exitSelect_with_parens?: (ctx: Select_with_parensContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.window_definition_list`. + * Enter a parse tree produced by `PostgreSqlParser.select_no_parens`. * @param ctx the parse tree */ - enterWindow_definition_list?: (ctx: Window_definition_listContext) => void; + enterSelect_no_parens?: (ctx: Select_no_parensContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.window_definition_list`. + * Exit a parse tree produced by `PostgreSqlParser.select_no_parens`. * @param ctx the parse tree */ - exitWindow_definition_list?: (ctx: Window_definition_listContext) => void; + exitSelect_no_parens?: (ctx: Select_no_parensContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.window_definition`. + * Enter a parse tree produced by `PostgreSqlParser.select_clause`. * @param ctx the parse tree */ - enterWindow_definition?: (ctx: Window_definitionContext) => void; + enterSelect_clause?: (ctx: Select_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.window_definition`. + * Exit a parse tree produced by `PostgreSqlParser.select_clause`. * @param ctx the parse tree */ - exitWindow_definition?: (ctx: Window_definitionContext) => void; + exitSelect_clause?: (ctx: Select_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.over_clause`. + * Enter a parse tree produced by `PostgreSqlParser.simple_select`. * @param ctx the parse tree */ - enterOver_clause?: (ctx: Over_clauseContext) => void; + enterSimple_select?: (ctx: Simple_selectContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.over_clause`. + * Exit a parse tree produced by `PostgreSqlParser.simple_select`. * @param ctx the parse tree */ - exitOver_clause?: (ctx: Over_clauseContext) => void; + exitSimple_select?: (ctx: Simple_selectContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.window_specification`. + * Enter a parse tree produced by `PostgreSqlParser.set_operator_with_all_or_distinct`. * @param ctx the parse tree */ - enterWindow_specification?: (ctx: Window_specificationContext) => void; + enterSet_operator_with_all_or_distinct?: (ctx: Set_operator_with_all_or_distinctContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.window_specification`. + * Exit a parse tree produced by `PostgreSqlParser.set_operator_with_all_or_distinct`. * @param ctx the parse tree */ - exitWindow_specification?: (ctx: Window_specificationContext) => void; + exitSet_operator_with_all_or_distinct?: (ctx: Set_operator_with_all_or_distinctContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_existing_window_name`. + * Enter a parse tree produced by `PostgreSqlParser.with_clause`. * @param ctx the parse tree */ - enterOpt_existing_window_name?: (ctx: Opt_existing_window_nameContext) => void; + enterWith_clause?: (ctx: With_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_existing_window_name`. + * Exit a parse tree produced by `PostgreSqlParser.with_clause`. * @param ctx the parse tree */ - exitOpt_existing_window_name?: (ctx: Opt_existing_window_nameContext) => void; + exitWith_clause?: (ctx: With_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_partition_clause`. + * Enter a parse tree produced by `PostgreSqlParser.common_table_expr`. * @param ctx the parse tree */ - enterOpt_partition_clause?: (ctx: Opt_partition_clauseContext) => void; + enterCommon_table_expr?: (ctx: Common_table_exprContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_partition_clause`. + * Exit a parse tree produced by `PostgreSqlParser.common_table_expr`. * @param ctx the parse tree */ - exitOpt_partition_clause?: (ctx: Opt_partition_clauseContext) => void; + exitCommon_table_expr?: (ctx: Common_table_exprContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_frame_clause`. + * Enter a parse tree produced by `PostgreSqlParser.search_cluase`. * @param ctx the parse tree */ - enterOpt_frame_clause?: (ctx: Opt_frame_clauseContext) => void; + enterSearch_cluase?: (ctx: Search_cluaseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_frame_clause`. + * Exit a parse tree produced by `PostgreSqlParser.search_cluase`. * @param ctx the parse tree */ - exitOpt_frame_clause?: (ctx: Opt_frame_clauseContext) => void; + exitSearch_cluase?: (ctx: Search_cluaseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.frame_extent`. + * Enter a parse tree produced by `PostgreSqlParser.cycle_cluase`. * @param ctx the parse tree */ - enterFrame_extent?: (ctx: Frame_extentContext) => void; + enterCycle_cluase?: (ctx: Cycle_cluaseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.frame_extent`. + * Exit a parse tree produced by `PostgreSqlParser.cycle_cluase`. * @param ctx the parse tree */ - exitFrame_extent?: (ctx: Frame_extentContext) => void; + exitCycle_cluase?: (ctx: Cycle_cluaseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.frame_bound`. + * Enter a parse tree produced by `PostgreSqlParser.into_clause`. * @param ctx the parse tree */ - enterFrame_bound?: (ctx: Frame_boundContext) => void; + enterInto_clause?: (ctx: Into_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.frame_bound`. + * Exit a parse tree produced by `PostgreSqlParser.into_clause`. * @param ctx the parse tree */ - exitFrame_bound?: (ctx: Frame_boundContext) => void; + exitInto_clause?: (ctx: Into_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_window_exclusion_clause`. + * Enter a parse tree produced by `PostgreSqlParser.opttempTableName`. * @param ctx the parse tree */ - enterOpt_window_exclusion_clause?: (ctx: Opt_window_exclusion_clauseContext) => void; + enterOpttempTableName?: (ctx: OpttempTableNameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_window_exclusion_clause`. + * Exit a parse tree produced by `PostgreSqlParser.opttempTableName`. * @param ctx the parse tree */ - exitOpt_window_exclusion_clause?: (ctx: Opt_window_exclusion_clauseContext) => void; + exitOpttempTableName?: (ctx: OpttempTableNameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.row`. + * Enter a parse tree produced by `PostgreSqlParser.distinct_clause`. * @param ctx the parse tree */ - enterRow?: (ctx: RowContext) => void; + enterDistinct_clause?: (ctx: Distinct_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.row`. + * Exit a parse tree produced by `PostgreSqlParser.distinct_clause`. * @param ctx the parse tree */ - exitRow?: (ctx: RowContext) => void; + exitDistinct_clause?: (ctx: Distinct_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.explicit_row`. + * Enter a parse tree produced by `PostgreSqlParser.sort_clause`. * @param ctx the parse tree */ - enterExplicit_row?: (ctx: Explicit_rowContext) => void; + enterSort_clause?: (ctx: Sort_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.explicit_row`. + * Exit a parse tree produced by `PostgreSqlParser.sort_clause`. * @param ctx the parse tree */ - exitExplicit_row?: (ctx: Explicit_rowContext) => void; + exitSort_clause?: (ctx: Sort_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.implicit_row`. + * Enter a parse tree produced by `PostgreSqlParser.sortby`. * @param ctx the parse tree */ - enterImplicit_row?: (ctx: Implicit_rowContext) => void; + enterSortby?: (ctx: SortbyContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.implicit_row`. + * Exit a parse tree produced by `PostgreSqlParser.sortby`. * @param ctx the parse tree */ - exitImplicit_row?: (ctx: Implicit_rowContext) => void; + exitSortby?: (ctx: SortbyContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.sub_type`. + * Enter a parse tree produced by `PostgreSqlParser.select_limit`. * @param ctx the parse tree */ - enterSub_type?: (ctx: Sub_typeContext) => void; + enterSelect_limit?: (ctx: Select_limitContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.sub_type`. + * Exit a parse tree produced by `PostgreSqlParser.select_limit`. * @param ctx the parse tree */ - exitSub_type?: (ctx: Sub_typeContext) => void; + exitSelect_limit?: (ctx: Select_limitContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.all_op`. + * Enter a parse tree produced by `PostgreSqlParser.limit_clause`. * @param ctx the parse tree */ - enterAll_op?: (ctx: All_opContext) => void; + enterLimit_clause?: (ctx: Limit_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.all_op`. + * Exit a parse tree produced by `PostgreSqlParser.limit_clause`. * @param ctx the parse tree */ - exitAll_op?: (ctx: All_opContext) => void; + exitLimit_clause?: (ctx: Limit_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.mathop`. + * Enter a parse tree produced by `PostgreSqlParser.fetch_clause`. * @param ctx the parse tree */ - enterMathop?: (ctx: MathopContext) => void; + enterFetch_clause?: (ctx: Fetch_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.mathop`. + * Exit a parse tree produced by `PostgreSqlParser.fetch_clause`. * @param ctx the parse tree */ - exitMathop?: (ctx: MathopContext) => void; + exitFetch_clause?: (ctx: Fetch_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.qual_op`. + * Enter a parse tree produced by `PostgreSqlParser.offset_clause`. * @param ctx the parse tree */ - enterQual_op?: (ctx: Qual_opContext) => void; + enterOffset_clause?: (ctx: Offset_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.qual_op`. + * Exit a parse tree produced by `PostgreSqlParser.offset_clause`. * @param ctx the parse tree */ - exitQual_op?: (ctx: Qual_opContext) => void; + exitOffset_clause?: (ctx: Offset_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.qual_all_op`. + * Enter a parse tree produced by `PostgreSqlParser.select_fetch_first_value`. * @param ctx the parse tree */ - enterQual_all_op?: (ctx: Qual_all_opContext) => void; + enterSelect_fetch_first_value?: (ctx: Select_fetch_first_valueContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.qual_all_op`. + * Exit a parse tree produced by `PostgreSqlParser.select_fetch_first_value`. * @param ctx the parse tree */ - exitQual_all_op?: (ctx: Qual_all_opContext) => void; + exitSelect_fetch_first_value?: (ctx: Select_fetch_first_valueContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.subquery_Op`. + * Enter a parse tree produced by `PostgreSqlParser.group_clause`. * @param ctx the parse tree */ - enterSubquery_Op?: (ctx: Subquery_OpContext) => void; + enterGroup_clause?: (ctx: Group_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.subquery_Op`. + * Exit a parse tree produced by `PostgreSqlParser.group_clause`. * @param ctx the parse tree */ - exitSubquery_Op?: (ctx: Subquery_OpContext) => void; + exitGroup_clause?: (ctx: Group_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.expr_list`. + * Enter a parse tree produced by `PostgreSqlParser.group_by_list`. * @param ctx the parse tree */ - enterExpr_list?: (ctx: Expr_listContext) => void; + enterGroup_by_list?: (ctx: Group_by_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.expr_list`. + * Exit a parse tree produced by `PostgreSqlParser.group_by_list`. * @param ctx the parse tree */ - exitExpr_list?: (ctx: Expr_listContext) => void; + exitGroup_by_list?: (ctx: Group_by_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.column_expr_list_noparen`. + * Enter a parse tree produced by `PostgreSqlParser.group_by_item`. * @param ctx the parse tree */ - enterColumn_expr_list_noparen?: (ctx: Column_expr_list_noparenContext) => void; + enterGroup_by_item?: (ctx: Group_by_itemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.column_expr_list_noparen`. + * Exit a parse tree produced by `PostgreSqlParser.group_by_item`. * @param ctx the parse tree */ - exitColumn_expr_list_noparen?: (ctx: Column_expr_list_noparenContext) => void; + exitGroup_by_item?: (ctx: Group_by_itemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.column_expr_list`. + * Enter a parse tree produced by `PostgreSqlParser.for_locking_clause`. * @param ctx the parse tree */ - enterColumn_expr_list?: (ctx: Column_expr_listContext) => void; + enterFor_locking_clause?: (ctx: For_locking_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.column_expr_list`. + * Exit a parse tree produced by `PostgreSqlParser.for_locking_clause`. * @param ctx the parse tree */ - exitColumn_expr_list?: (ctx: Column_expr_listContext) => void; + exitFor_locking_clause?: (ctx: For_locking_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.column_expr`. + * Enter a parse tree produced by `PostgreSqlParser.values_clause`. * @param ctx the parse tree */ - enterColumn_expr?: (ctx: Column_exprContext) => void; + enterValues_clause?: (ctx: Values_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.column_expr`. + * Exit a parse tree produced by `PostgreSqlParser.values_clause`. * @param ctx the parse tree */ - exitColumn_expr?: (ctx: Column_exprContext) => void; + exitValues_clause?: (ctx: Values_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.column_expr_noparen`. + * Enter a parse tree produced by `PostgreSqlParser.from_clause`. * @param ctx the parse tree */ - enterColumn_expr_noparen?: (ctx: Column_expr_noparenContext) => void; + enterFrom_clause?: (ctx: From_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.column_expr_noparen`. + * Exit a parse tree produced by `PostgreSqlParser.from_clause`. * @param ctx the parse tree */ - exitColumn_expr_noparen?: (ctx: Column_expr_noparenContext) => void; + exitFrom_clause?: (ctx: From_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.func_arg_list`. + * Enter a parse tree produced by `PostgreSqlParser.from_list`. * @param ctx the parse tree */ - enterFunc_arg_list?: (ctx: Func_arg_listContext) => void; + enterFrom_list?: (ctx: From_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.func_arg_list`. + * Exit a parse tree produced by `PostgreSqlParser.from_list`. * @param ctx the parse tree */ - exitFunc_arg_list?: (ctx: Func_arg_listContext) => void; + exitFrom_list?: (ctx: From_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.func_arg_expr`. + * Enter a parse tree produced by `PostgreSqlParser.table_ref`. * @param ctx the parse tree */ - enterFunc_arg_expr?: (ctx: Func_arg_exprContext) => void; + enterTable_ref?: (ctx: Table_refContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.func_arg_expr`. + * Exit a parse tree produced by `PostgreSqlParser.table_ref`. * @param ctx the parse tree */ - exitFunc_arg_expr?: (ctx: Func_arg_exprContext) => void; + exitTable_ref?: (ctx: Table_refContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.type_list`. + * Enter a parse tree produced by `PostgreSqlParser.alias_clause`. * @param ctx the parse tree */ - enterType_list?: (ctx: Type_listContext) => void; + enterAlias_clause?: (ctx: Alias_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.type_list`. + * Exit a parse tree produced by `PostgreSqlParser.alias_clause`. * @param ctx the parse tree */ - exitType_list?: (ctx: Type_listContext) => void; + exitAlias_clause?: (ctx: Alias_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.array_expr`. + * Enter a parse tree produced by `PostgreSqlParser.func_alias_clause`. * @param ctx the parse tree */ - enterArray_expr?: (ctx: Array_exprContext) => void; + enterFunc_alias_clause?: (ctx: Func_alias_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.array_expr`. + * Exit a parse tree produced by `PostgreSqlParser.func_alias_clause`. * @param ctx the parse tree */ - exitArray_expr?: (ctx: Array_exprContext) => void; + exitFunc_alias_clause?: (ctx: Func_alias_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.array_expr_list`. + * Enter a parse tree produced by `PostgreSqlParser.join_type`. * @param ctx the parse tree */ - enterArray_expr_list?: (ctx: Array_expr_listContext) => void; + enterJoin_type?: (ctx: Join_typeContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.array_expr_list`. + * Exit a parse tree produced by `PostgreSqlParser.join_type`. * @param ctx the parse tree */ - exitArray_expr_list?: (ctx: Array_expr_listContext) => void; + exitJoin_type?: (ctx: Join_typeContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.extract_list`. + * Enter a parse tree produced by `PostgreSqlParser.join_qual`. * @param ctx the parse tree */ - enterExtract_list?: (ctx: Extract_listContext) => void; + enterJoin_qual?: (ctx: Join_qualContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.extract_list`. + * Exit a parse tree produced by `PostgreSqlParser.join_qual`. * @param ctx the parse tree */ - exitExtract_list?: (ctx: Extract_listContext) => void; + exitJoin_qual?: (ctx: Join_qualContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.extract_arg`. + * Enter a parse tree produced by `PostgreSqlParser.relation_expr`. * @param ctx the parse tree */ - enterExtract_arg?: (ctx: Extract_argContext) => void; + enterRelation_expr?: (ctx: Relation_exprContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.extract_arg`. + * Exit a parse tree produced by `PostgreSqlParser.relation_expr`. * @param ctx the parse tree */ - exitExtract_arg?: (ctx: Extract_argContext) => void; + exitRelation_expr?: (ctx: Relation_exprContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.unicode_normal_form`. + * Enter a parse tree produced by `PostgreSqlParser.publication_relation_expr`. * @param ctx the parse tree */ - enterUnicode_normal_form?: (ctx: Unicode_normal_formContext) => void; + enterPublication_relation_expr?: (ctx: Publication_relation_exprContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.unicode_normal_form`. + * Exit a parse tree produced by `PostgreSqlParser.publication_relation_expr`. * @param ctx the parse tree */ - exitUnicode_normal_form?: (ctx: Unicode_normal_formContext) => void; + exitPublication_relation_expr?: (ctx: Publication_relation_exprContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.overlay_list`. + * Enter a parse tree produced by `PostgreSqlParser.relation_expr_list`. * @param ctx the parse tree */ - enterOverlay_list?: (ctx: Overlay_listContext) => void; + enterRelation_expr_list?: (ctx: Relation_expr_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.overlay_list`. + * Exit a parse tree produced by `PostgreSqlParser.relation_expr_list`. * @param ctx the parse tree */ - exitOverlay_list?: (ctx: Overlay_listContext) => void; + exitRelation_expr_list?: (ctx: Relation_expr_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.position_list`. + * Enter a parse tree produced by `PostgreSqlParser.relation_expr_opt_alias`. * @param ctx the parse tree */ - enterPosition_list?: (ctx: Position_listContext) => void; + enterRelation_expr_opt_alias?: (ctx: Relation_expr_opt_aliasContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.position_list`. + * Exit a parse tree produced by `PostgreSqlParser.relation_expr_opt_alias`. * @param ctx the parse tree */ - exitPosition_list?: (ctx: Position_listContext) => void; + exitRelation_expr_opt_alias?: (ctx: Relation_expr_opt_aliasContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.substr_list`. + * Enter a parse tree produced by `PostgreSqlParser.tablesample_clause`. * @param ctx the parse tree */ - enterSubstr_list?: (ctx: Substr_listContext) => void; + enterTablesample_clause?: (ctx: Tablesample_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.substr_list`. + * Exit a parse tree produced by `PostgreSqlParser.tablesample_clause`. * @param ctx the parse tree */ - exitSubstr_list?: (ctx: Substr_listContext) => void; + exitTablesample_clause?: (ctx: Tablesample_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.trim_list`. + * Enter a parse tree produced by `PostgreSqlParser.func_table`. * @param ctx the parse tree */ - enterTrim_list?: (ctx: Trim_listContext) => void; + enterFunc_table?: (ctx: Func_tableContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.trim_list`. + * Exit a parse tree produced by `PostgreSqlParser.func_table`. * @param ctx the parse tree */ - exitTrim_list?: (ctx: Trim_listContext) => void; + exitFunc_table?: (ctx: Func_tableContext) => void; /** - * Enter a parse tree produced by the `in_expr_select` - * labeled alternative in `PostgreSqlParser.in_expr`. + * Enter a parse tree produced by `PostgreSqlParser.rowsfrom_item`. * @param ctx the parse tree */ - enterIn_expr_select?: (ctx: In_expr_selectContext) => void; + enterRowsfrom_item?: (ctx: Rowsfrom_itemContext) => void; /** - * Exit a parse tree produced by the `in_expr_select` - * labeled alternative in `PostgreSqlParser.in_expr`. + * Exit a parse tree produced by `PostgreSqlParser.rowsfrom_item`. * @param ctx the parse tree */ - exitIn_expr_select?: (ctx: In_expr_selectContext) => void; + exitRowsfrom_item?: (ctx: Rowsfrom_itemContext) => void; /** - * Enter a parse tree produced by the `in_expr_list` - * labeled alternative in `PostgreSqlParser.in_expr`. + * Enter a parse tree produced by `PostgreSqlParser.where_clause`. * @param ctx the parse tree */ - enterIn_expr_list?: (ctx: In_expr_listContext) => void; + enterWhere_clause?: (ctx: Where_clauseContext) => void; /** - * Exit a parse tree produced by the `in_expr_list` - * labeled alternative in `PostgreSqlParser.in_expr`. + * Exit a parse tree produced by `PostgreSqlParser.where_clause`. * @param ctx the parse tree */ - exitIn_expr_list?: (ctx: In_expr_listContext) => void; + exitWhere_clause?: (ctx: Where_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.case_expr`. + * Enter a parse tree produced by `PostgreSqlParser.where_or_current_clause`. * @param ctx the parse tree */ - enterCase_expr?: (ctx: Case_exprContext) => void; + enterWhere_or_current_clause?: (ctx: Where_or_current_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.case_expr`. + * Exit a parse tree produced by `PostgreSqlParser.where_or_current_clause`. * @param ctx the parse tree */ - exitCase_expr?: (ctx: Case_exprContext) => void; + exitWhere_or_current_clause?: (ctx: Where_or_current_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.when_clause_list`. + * Enter a parse tree produced by `PostgreSqlParser.tablefuncelementlist`. * @param ctx the parse tree */ - enterWhen_clause_list?: (ctx: When_clause_listContext) => void; + enterTablefuncelementlist?: (ctx: TablefuncelementlistContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.when_clause_list`. + * Exit a parse tree produced by `PostgreSqlParser.tablefuncelementlist`. * @param ctx the parse tree */ - exitWhen_clause_list?: (ctx: When_clause_listContext) => void; + exitTablefuncelementlist?: (ctx: TablefuncelementlistContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.when_clause`. + * Enter a parse tree produced by `PostgreSqlParser.tablefuncelement`. * @param ctx the parse tree */ - enterWhen_clause?: (ctx: When_clauseContext) => void; + enterTablefuncelement?: (ctx: TablefuncelementContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.when_clause`. + * Exit a parse tree produced by `PostgreSqlParser.tablefuncelement`. * @param ctx the parse tree */ - exitWhen_clause?: (ctx: When_clauseContext) => void; + exitTablefuncelement?: (ctx: TablefuncelementContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.case_default`. + * Enter a parse tree produced by `PostgreSqlParser.xmltable`. * @param ctx the parse tree */ - enterCase_default?: (ctx: Case_defaultContext) => void; + enterXmltable?: (ctx: XmltableContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.case_default`. + * Exit a parse tree produced by `PostgreSqlParser.xmltable`. * @param ctx the parse tree */ - exitCase_default?: (ctx: Case_defaultContext) => void; + exitXmltable?: (ctx: XmltableContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.case_arg`. + * Enter a parse tree produced by `PostgreSqlParser.xmltable_column_el`. * @param ctx the parse tree */ - enterCase_arg?: (ctx: Case_argContext) => void; + enterXmltable_column_el?: (ctx: Xmltable_column_elContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.case_arg`. + * Exit a parse tree produced by `PostgreSqlParser.xmltable_column_el`. * @param ctx the parse tree */ - exitCase_arg?: (ctx: Case_argContext) => void; + exitXmltable_column_el?: (ctx: Xmltable_column_elContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.columnref`. + * Enter a parse tree produced by `PostgreSqlParser.xml_namespace_el`. * @param ctx the parse tree */ - enterColumnref?: (ctx: ColumnrefContext) => void; + enterXml_namespace_el?: (ctx: Xml_namespace_elContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.columnref`. + * Exit a parse tree produced by `PostgreSqlParser.xml_namespace_el`. * @param ctx the parse tree */ - exitColumnref?: (ctx: ColumnrefContext) => void; + exitXml_namespace_el?: (ctx: Xml_namespace_elContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.indirection_el`. + * Enter a parse tree produced by `PostgreSqlParser.typename`. * @param ctx the parse tree */ - enterIndirection_el?: (ctx: Indirection_elContext) => void; + enterTypename?: (ctx: TypenameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.indirection_el`. + * Exit a parse tree produced by `PostgreSqlParser.typename`. * @param ctx the parse tree */ - exitIndirection_el?: (ctx: Indirection_elContext) => void; + exitTypename?: (ctx: TypenameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_slice_bound`. + * Enter a parse tree produced by `PostgreSqlParser.simpletypename`. * @param ctx the parse tree */ - enterOpt_slice_bound?: (ctx: Opt_slice_boundContext) => void; + enterSimpletypename?: (ctx: SimpletypenameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_slice_bound`. + * Exit a parse tree produced by `PostgreSqlParser.simpletypename`. * @param ctx the parse tree */ - exitOpt_slice_bound?: (ctx: Opt_slice_boundContext) => void; + exitSimpletypename?: (ctx: SimpletypenameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.indirection`. + * Enter a parse tree produced by `PostgreSqlParser.consttypename`. * @param ctx the parse tree */ - enterIndirection?: (ctx: IndirectionContext) => void; + enterConsttypename?: (ctx: ConsttypenameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.indirection`. + * Exit a parse tree produced by `PostgreSqlParser.consttypename`. * @param ctx the parse tree */ - exitIndirection?: (ctx: IndirectionContext) => void; + exitConsttypename?: (ctx: ConsttypenameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_indirection`. + * Enter a parse tree produced by `PostgreSqlParser.numeric`. * @param ctx the parse tree */ - enterOpt_indirection?: (ctx: Opt_indirectionContext) => void; + enterNumeric?: (ctx: NumericContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_indirection`. + * Exit a parse tree produced by `PostgreSqlParser.numeric`. * @param ctx the parse tree */ - exitOpt_indirection?: (ctx: Opt_indirectionContext) => void; + exitNumeric?: (ctx: NumericContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_target_list`. + * Enter a parse tree produced by `PostgreSqlParser.opt_float`. * @param ctx the parse tree */ - enterOpt_target_list?: (ctx: Opt_target_listContext) => void; + enterOpt_float?: (ctx: Opt_floatContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_target_list`. + * Exit a parse tree produced by `PostgreSqlParser.opt_float`. * @param ctx the parse tree */ - exitOpt_target_list?: (ctx: Opt_target_listContext) => void; + exitOpt_float?: (ctx: Opt_floatContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.target_list`. + * Enter a parse tree produced by `PostgreSqlParser.bit`. * @param ctx the parse tree */ - enterTarget_list?: (ctx: Target_listContext) => void; + enterBit?: (ctx: BitContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.target_list`. + * Exit a parse tree produced by `PostgreSqlParser.bit`. * @param ctx the parse tree */ - exitTarget_list?: (ctx: Target_listContext) => void; + exitBit?: (ctx: BitContext) => void; /** - * Enter a parse tree produced by the `target_label` - * labeled alternative in `PostgreSqlParser.target_el`. + * Enter a parse tree produced by `PostgreSqlParser.character`. * @param ctx the parse tree */ - enterTarget_label?: (ctx: Target_labelContext) => void; + enterCharacter?: (ctx: CharacterContext) => void; /** - * Exit a parse tree produced by the `target_label` - * labeled alternative in `PostgreSqlParser.target_el`. + * Exit a parse tree produced by `PostgreSqlParser.character`. * @param ctx the parse tree */ - exitTarget_label?: (ctx: Target_labelContext) => void; + exitCharacter?: (ctx: CharacterContext) => void; /** - * Enter a parse tree produced by the `target_star` - * labeled alternative in `PostgreSqlParser.target_el`. + * Enter a parse tree produced by `PostgreSqlParser.constdatetime`. * @param ctx the parse tree */ - enterTarget_star?: (ctx: Target_starContext) => void; + enterConstdatetime?: (ctx: ConstdatetimeContext) => void; /** - * Exit a parse tree produced by the `target_star` - * labeled alternative in `PostgreSqlParser.target_el`. + * Exit a parse tree produced by `PostgreSqlParser.constdatetime`. * @param ctx the parse tree */ - exitTarget_star?: (ctx: Target_starContext) => void; + exitConstdatetime?: (ctx: ConstdatetimeContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.qualified_name_list`. + * Enter a parse tree produced by `PostgreSqlParser.opt_interval`. * @param ctx the parse tree */ - enterQualified_name_list?: (ctx: Qualified_name_listContext) => void; + enterOpt_interval?: (ctx: Opt_intervalContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.qualified_name_list`. + * Exit a parse tree produced by `PostgreSqlParser.opt_interval`. * @param ctx the parse tree */ - exitQualified_name_list?: (ctx: Qualified_name_listContext) => void; + exitOpt_interval?: (ctx: Opt_intervalContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.table_name_list`. + * Enter a parse tree produced by `PostgreSqlParser.interval_second`. * @param ctx the parse tree */ - enterTable_name_list?: (ctx: Table_name_listContext) => void; + enterInterval_second?: (ctx: Interval_secondContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.table_name_list`. + * Exit a parse tree produced by `PostgreSqlParser.interval_second`. * @param ctx the parse tree */ - exitTable_name_list?: (ctx: Table_name_listContext) => void; + exitInterval_second?: (ctx: Interval_secondContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.schema_name_list`. + * Enter a parse tree produced by `PostgreSqlParser.comparisonOperator`. * @param ctx the parse tree */ - enterSchema_name_list?: (ctx: Schema_name_listContext) => void; + enterComparisonOperator?: (ctx: ComparisonOperatorContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.schema_name_list`. + * Exit a parse tree produced by `PostgreSqlParser.comparisonOperator`. * @param ctx the parse tree */ - exitSchema_name_list?: (ctx: Schema_name_listContext) => void; + exitComparisonOperator?: (ctx: ComparisonOperatorContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.database_nameList`. + * Enter a parse tree produced by `PostgreSqlParser.expression`. * @param ctx the parse tree */ - enterDatabase_nameList?: (ctx: Database_nameListContext) => void; + enterExpression?: (ctx: ExpressionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.database_nameList`. + * Exit a parse tree produced by `PostgreSqlParser.expression`. * @param ctx the parse tree */ - exitDatabase_nameList?: (ctx: Database_nameListContext) => void; + exitExpression?: (ctx: ExpressionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.procedure_name_list`. + * Enter a parse tree produced by the `logicalNot` + * labeled alternative in `PostgreSqlParser.booleanExpression`. * @param ctx the parse tree */ - enterProcedure_name_list?: (ctx: Procedure_name_listContext) => void; + enterLogicalNot?: (ctx: LogicalNotContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.procedure_name_list`. + * Exit a parse tree produced by the `logicalNot` + * labeled alternative in `PostgreSqlParser.booleanExpression`. * @param ctx the parse tree */ - exitProcedure_name_list?: (ctx: Procedure_name_listContext) => void; + exitLogicalNot?: (ctx: LogicalNotContext) => void; /** - * Enter a parse tree produced by the `tablespaceNameCreate` - * labeled alternative in `PostgreSqlParser.tablespace_name_create`. + * Enter a parse tree produced by the `predicated` + * labeled alternative in `PostgreSqlParser.booleanExpression`. * @param ctx the parse tree */ - enterTablespaceNameCreate?: (ctx: TablespaceNameCreateContext) => void; + enterPredicated?: (ctx: PredicatedContext) => void; /** - * Exit a parse tree produced by the `tablespaceNameCreate` - * labeled alternative in `PostgreSqlParser.tablespace_name_create`. + * Exit a parse tree produced by the `predicated` + * labeled alternative in `PostgreSqlParser.booleanExpression`. * @param ctx the parse tree */ - exitTablespaceNameCreate?: (ctx: TablespaceNameCreateContext) => void; + exitPredicated?: (ctx: PredicatedContext) => void; /** - * Enter a parse tree produced by the `tablespaceName` - * labeled alternative in `PostgreSqlParser.tablespace_name`. + * Enter a parse tree produced by the `logicalBinary` + * labeled alternative in `PostgreSqlParser.booleanExpression`. * @param ctx the parse tree */ - enterTablespaceName?: (ctx: TablespaceNameContext) => void; + enterLogicalBinary?: (ctx: LogicalBinaryContext) => void; /** - * Exit a parse tree produced by the `tablespaceName` - * labeled alternative in `PostgreSqlParser.tablespace_name`. + * Exit a parse tree produced by the `logicalBinary` + * labeled alternative in `PostgreSqlParser.booleanExpression`. * @param ctx the parse tree */ - exitTablespaceName?: (ctx: TablespaceNameContext) => void; + exitLogicalBinary?: (ctx: LogicalBinaryContext) => void; /** - * Enter a parse tree produced by the `tableNameCreate` - * labeled alternative in `PostgreSqlParser.table_name_create`. + * Enter a parse tree produced by the `comparison` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - enterTableNameCreate?: (ctx: TableNameCreateContext) => void; + enterComparison?: (ctx: ComparisonContext) => void; /** - * Exit a parse tree produced by the `tableNameCreate` - * labeled alternative in `PostgreSqlParser.table_name_create`. + * Exit a parse tree produced by the `comparison` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - exitTableNameCreate?: (ctx: TableNameCreateContext) => void; + exitComparison?: (ctx: ComparisonContext) => void; /** - * Enter a parse tree produced by the `tableName` - * labeled alternative in `PostgreSqlParser.table_name`. + * Enter a parse tree produced by the `quantifiedComparison` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - enterTableName?: (ctx: TableNameContext) => void; + enterQuantifiedComparison?: (ctx: QuantifiedComparisonContext) => void; /** - * Exit a parse tree produced by the `tableName` - * labeled alternative in `PostgreSqlParser.table_name`. + * Exit a parse tree produced by the `quantifiedComparison` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - exitTableName?: (ctx: TableNameContext) => void; + exitQuantifiedComparison?: (ctx: QuantifiedComparisonContext) => void; /** - * Enter a parse tree produced by the `viewNameCreate` - * labeled alternative in `PostgreSqlParser.view_name_create`. + * Enter a parse tree produced by the `between` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - enterViewNameCreate?: (ctx: ViewNameCreateContext) => void; + enterBetween?: (ctx: BetweenContext) => void; /** - * Exit a parse tree produced by the `viewNameCreate` - * labeled alternative in `PostgreSqlParser.view_name_create`. + * Exit a parse tree produced by the `between` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - exitViewNameCreate?: (ctx: ViewNameCreateContext) => void; + exitBetween?: (ctx: BetweenContext) => void; /** - * Enter a parse tree produced by the `viewName` - * labeled alternative in `PostgreSqlParser.view_name`. + * Enter a parse tree produced by the `inList` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - enterViewName?: (ctx: ViewNameContext) => void; + enterInList?: (ctx: InListContext) => void; /** - * Exit a parse tree produced by the `viewName` - * labeled alternative in `PostgreSqlParser.view_name`. + * Exit a parse tree produced by the `inList` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - exitViewName?: (ctx: ViewNameContext) => void; + exitInList?: (ctx: InListContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.qualified_name`. + * Enter a parse tree produced by the `inSubquery` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - enterQualified_name?: (ctx: Qualified_nameContext) => void; + enterInSubquery?: (ctx: InSubqueryContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.qualified_name`. + * Exit a parse tree produced by the `inSubquery` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - exitQualified_name?: (ctx: Qualified_nameContext) => void; + exitInSubquery?: (ctx: InSubqueryContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.tablespace_name_list`. + * Enter a parse tree produced by the `like` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - enterTablespace_name_list?: (ctx: Tablespace_name_listContext) => void; + enterLike?: (ctx: LikeContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.tablespace_name_list`. + * Exit a parse tree produced by the `like` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - exitTablespace_name_list?: (ctx: Tablespace_name_listContext) => void; + exitLike?: (ctx: LikeContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.name_list`. + * Enter a parse tree produced by the `nullPredicate` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - enterName_list?: (ctx: Name_listContext) => void; + enterNullPredicate?: (ctx: NullPredicateContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.name_list`. + * Exit a parse tree produced by the `nullPredicate` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - exitName_list?: (ctx: Name_listContext) => void; + exitNullPredicate?: (ctx: NullPredicateContext) => void; /** - * Enter a parse tree produced by the `databaseNameCreate` - * labeled alternative in `PostgreSqlParser.database_name_create`. + * Enter a parse tree produced by the `distinctFrom` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - enterDatabaseNameCreate?: (ctx: DatabaseNameCreateContext) => void; + enterDistinctFrom?: (ctx: DistinctFromContext) => void; /** - * Exit a parse tree produced by the `databaseNameCreate` - * labeled alternative in `PostgreSqlParser.database_name_create`. + * Exit a parse tree produced by the `distinctFrom` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree */ - exitDatabaseNameCreate?: (ctx: DatabaseNameCreateContext) => void; + exitDistinctFrom?: (ctx: DistinctFromContext) => void; /** - * Enter a parse tree produced by the `databaseName` - * labeled alternative in `PostgreSqlParser.database_name`. + * Enter a parse tree produced by the `valueExpressionDefault` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree */ - enterDatabaseName?: (ctx: DatabaseNameContext) => void; + enterValueExpressionDefault?: (ctx: ValueExpressionDefaultContext) => void; /** - * Exit a parse tree produced by the `databaseName` - * labeled alternative in `PostgreSqlParser.database_name`. + * Exit a parse tree produced by the `valueExpressionDefault` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree */ - exitDatabaseName?: (ctx: DatabaseNameContext) => void; + exitValueExpressionDefault?: (ctx: ValueExpressionDefaultContext) => void; /** - * Enter a parse tree produced by the `schemaName` - * labeled alternative in `PostgreSqlParser.schema_name`. + * Enter a parse tree produced by the `concatenation` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree */ - enterSchemaName?: (ctx: SchemaNameContext) => void; + enterConcatenation?: (ctx: ConcatenationContext) => void; /** - * Exit a parse tree produced by the `schemaName` - * labeled alternative in `PostgreSqlParser.schema_name`. + * Exit a parse tree produced by the `concatenation` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree */ - exitSchemaName?: (ctx: SchemaNameContext) => void; + exitConcatenation?: (ctx: ConcatenationContext) => void; /** - * Enter a parse tree produced by the `routineNameCreate` - * labeled alternative in `PostgreSqlParser.routine_name_create`. + * Enter a parse tree produced by the `arithmeticBinary` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree */ - enterRoutineNameCreate?: (ctx: RoutineNameCreateContext) => void; + enterArithmeticBinary?: (ctx: ArithmeticBinaryContext) => void; /** - * Exit a parse tree produced by the `routineNameCreate` - * labeled alternative in `PostgreSqlParser.routine_name_create`. + * Exit a parse tree produced by the `arithmeticBinary` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree */ - exitRoutineNameCreate?: (ctx: RoutineNameCreateContext) => void; + exitArithmeticBinary?: (ctx: ArithmeticBinaryContext) => void; /** - * Enter a parse tree produced by the `routineName` - * labeled alternative in `PostgreSqlParser.routine_name`. + * Enter a parse tree produced by the `arithmeticUnary` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree */ - enterRoutineName?: (ctx: RoutineNameContext) => void; + enterArithmeticUnary?: (ctx: ArithmeticUnaryContext) => void; /** - * Exit a parse tree produced by the `routineName` - * labeled alternative in `PostgreSqlParser.routine_name`. + * Exit a parse tree produced by the `arithmeticUnary` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree */ - exitRoutineName?: (ctx: RoutineNameContext) => void; + exitArithmeticUnary?: (ctx: ArithmeticUnaryContext) => void; /** - * Enter a parse tree produced by the `procedureName` - * labeled alternative in `PostgreSqlParser.procedure_name`. + * Enter a parse tree produced by the `atTimeZone` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree */ - enterProcedureName?: (ctx: ProcedureNameContext) => void; + enterAtTimeZone?: (ctx: AtTimeZoneContext) => void; /** - * Exit a parse tree produced by the `procedureName` - * labeled alternative in `PostgreSqlParser.procedure_name`. + * Exit a parse tree produced by the `atTimeZone` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree */ - exitProcedureName?: (ctx: ProcedureNameContext) => void; + exitAtTimeZone?: (ctx: AtTimeZoneContext) => void; /** - * Enter a parse tree produced by the `procedureNameCreate` - * labeled alternative in `PostgreSqlParser.procedure_name_create`. + * Enter a parse tree produced by `PostgreSqlParser.primaryExpression`. * @param ctx the parse tree */ - enterProcedureNameCreate?: (ctx: ProcedureNameCreateContext) => void; + enterPrimaryExpression?: (ctx: PrimaryExpressionContext) => void; /** - * Exit a parse tree produced by the `procedureNameCreate` - * labeled alternative in `PostgreSqlParser.procedure_name_create`. + * Exit a parse tree produced by `PostgreSqlParser.primaryExpression`. * @param ctx the parse tree */ - exitProcedureNameCreate?: (ctx: ProcedureNameCreateContext) => void; + exitPrimaryExpression?: (ctx: PrimaryExpressionContext) => void; /** - * Enter a parse tree produced by the `columnName` - * labeled alternative in `PostgreSqlParser.column_name`. + * Enter a parse tree produced by `PostgreSqlParser.func_application`. * @param ctx the parse tree */ - enterColumnName?: (ctx: ColumnNameContext) => void; + enterFunc_application?: (ctx: Func_applicationContext) => void; /** - * Exit a parse tree produced by the `columnName` - * labeled alternative in `PostgreSqlParser.column_name`. + * Exit a parse tree produced by `PostgreSqlParser.func_application`. * @param ctx the parse tree */ - exitColumnName?: (ctx: ColumnNameContext) => void; + exitFunc_application?: (ctx: Func_applicationContext) => void; /** - * Enter a parse tree produced by the `columnNameMatch` - * labeled alternative in `PostgreSqlParser.column_name`. + * Enter a parse tree produced by `PostgreSqlParser.func_expr`. * @param ctx the parse tree */ - enterColumnNameMatch?: (ctx: ColumnNameMatchContext) => void; + enterFunc_expr?: (ctx: Func_exprContext) => void; /** - * Exit a parse tree produced by the `columnNameMatch` - * labeled alternative in `PostgreSqlParser.column_name`. + * Exit a parse tree produced by `PostgreSqlParser.func_expr`. * @param ctx the parse tree */ - exitColumnNameMatch?: (ctx: ColumnNameMatchContext) => void; + exitFunc_expr?: (ctx: Func_exprContext) => void; /** - * Enter a parse tree produced by the `columnNameCreate` - * labeled alternative in `PostgreSqlParser.column_name_create`. + * Enter a parse tree produced by `PostgreSqlParser.func_expr_windowless`. * @param ctx the parse tree */ - enterColumnNameCreate?: (ctx: ColumnNameCreateContext) => void; + enterFunc_expr_windowless?: (ctx: Func_expr_windowlessContext) => void; /** - * Exit a parse tree produced by the `columnNameCreate` - * labeled alternative in `PostgreSqlParser.column_name_create`. + * Exit a parse tree produced by `PostgreSqlParser.func_expr_windowless`. * @param ctx the parse tree */ - exitColumnNameCreate?: (ctx: ColumnNameCreateContext) => void; + exitFunc_expr_windowless?: (ctx: Func_expr_windowlessContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.name`. + * Enter a parse tree produced by `PostgreSqlParser.func_expr_common_subexpr`. * @param ctx the parse tree */ - enterName?: (ctx: NameContext) => void; + enterFunc_expr_common_subexpr?: (ctx: Func_expr_common_subexprContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.name`. + * Exit a parse tree produced by `PostgreSqlParser.func_expr_common_subexpr`. * @param ctx the parse tree */ - exitName?: (ctx: NameContext) => void; + exitFunc_expr_common_subexpr?: (ctx: Func_expr_common_subexprContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.attr_name`. + * Enter a parse tree produced by `PostgreSqlParser.xml_attribute_list`. * @param ctx the parse tree */ - enterAttr_name?: (ctx: Attr_nameContext) => void; + enterXml_attribute_list?: (ctx: Xml_attribute_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.attr_name`. + * Exit a parse tree produced by `PostgreSqlParser.xml_attribute_list`. * @param ctx the parse tree */ - exitAttr_name?: (ctx: Attr_nameContext) => void; + exitXml_attribute_list?: (ctx: Xml_attribute_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.file_name`. + * Enter a parse tree produced by `PostgreSqlParser.xml_attribute_el`. * @param ctx the parse tree */ - enterFile_name?: (ctx: File_nameContext) => void; + enterXml_attribute_el?: (ctx: Xml_attribute_elContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.file_name`. + * Exit a parse tree produced by `PostgreSqlParser.xml_attribute_el`. * @param ctx the parse tree */ - exitFile_name?: (ctx: File_nameContext) => void; + exitXml_attribute_el?: (ctx: Xml_attribute_elContext) => void; /** - * Enter a parse tree produced by the `functionNameCreate` - * labeled alternative in `PostgreSqlParser.function_name_create`. + * Enter a parse tree produced by `PostgreSqlParser.document_or_content`. * @param ctx the parse tree */ - enterFunctionNameCreate?: (ctx: FunctionNameCreateContext) => void; + enterDocument_or_content?: (ctx: Document_or_contentContext) => void; /** - * Exit a parse tree produced by the `functionNameCreate` - * labeled alternative in `PostgreSqlParser.function_name_create`. + * Exit a parse tree produced by `PostgreSqlParser.document_or_content`. * @param ctx the parse tree */ - exitFunctionNameCreate?: (ctx: FunctionNameCreateContext) => void; + exitDocument_or_content?: (ctx: Document_or_contentContext) => void; /** - * Enter a parse tree produced by the `functionName` - * labeled alternative in `PostgreSqlParser.function_name`. + * Enter a parse tree produced by `PostgreSqlParser.xmlexists_argument`. * @param ctx the parse tree */ - enterFunctionName?: (ctx: FunctionNameContext) => void; + enterXmlexists_argument?: (ctx: Xmlexists_argumentContext) => void; /** - * Exit a parse tree produced by the `functionName` - * labeled alternative in `PostgreSqlParser.function_name`. + * Exit a parse tree produced by `PostgreSqlParser.xmlexists_argument`. * @param ctx the parse tree */ - exitFunctionName?: (ctx: FunctionNameContext) => void; + exitXmlexists_argument?: (ctx: Xmlexists_argumentContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.usual_name`. + * Enter a parse tree produced by `PostgreSqlParser.xml_passing_mech`. * @param ctx the parse tree */ - enterUsual_name?: (ctx: Usual_nameContext) => void; + enterXml_passing_mech?: (ctx: Xml_passing_mechContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.usual_name`. + * Exit a parse tree produced by `PostgreSqlParser.xml_passing_mech`. * @param ctx the parse tree */ - exitUsual_name?: (ctx: Usual_nameContext) => void; + exitXml_passing_mech?: (ctx: Xml_passing_mechContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.aexprconst`. + * Enter a parse tree produced by `PostgreSqlParser.window_clause`. * @param ctx the parse tree */ - enterAexprconst?: (ctx: AexprconstContext) => void; + enterWindow_clause?: (ctx: Window_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.aexprconst`. + * Exit a parse tree produced by `PostgreSqlParser.window_clause`. * @param ctx the parse tree */ - exitAexprconst?: (ctx: AexprconstContext) => void; + exitWindow_clause?: (ctx: Window_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.xconst`. + * Enter a parse tree produced by `PostgreSqlParser.window_definition`. * @param ctx the parse tree */ - enterXconst?: (ctx: XconstContext) => void; + enterWindow_definition?: (ctx: Window_definitionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.xconst`. + * Exit a parse tree produced by `PostgreSqlParser.window_definition`. * @param ctx the parse tree */ - exitXconst?: (ctx: XconstContext) => void; + exitWindow_definition?: (ctx: Window_definitionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.bconst`. + * Enter a parse tree produced by `PostgreSqlParser.over_clause`. * @param ctx the parse tree */ - enterBconst?: (ctx: BconstContext) => void; + enterOver_clause?: (ctx: Over_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.bconst`. + * Exit a parse tree produced by `PostgreSqlParser.over_clause`. * @param ctx the parse tree */ - exitBconst?: (ctx: BconstContext) => void; + exitOver_clause?: (ctx: Over_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.fconst`. + * Enter a parse tree produced by `PostgreSqlParser.window_specification`. * @param ctx the parse tree */ - enterFconst?: (ctx: FconstContext) => void; + enterWindow_specification?: (ctx: Window_specificationContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.fconst`. + * Exit a parse tree produced by `PostgreSqlParser.window_specification`. * @param ctx the parse tree */ - exitFconst?: (ctx: FconstContext) => void; + exitWindow_specification?: (ctx: Window_specificationContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.iconst`. + * Enter a parse tree produced by `PostgreSqlParser.opt_frame_clause`. * @param ctx the parse tree */ - enterIconst?: (ctx: IconstContext) => void; + enterOpt_frame_clause?: (ctx: Opt_frame_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.iconst`. + * Exit a parse tree produced by `PostgreSqlParser.opt_frame_clause`. * @param ctx the parse tree */ - exitIconst?: (ctx: IconstContext) => void; + exitOpt_frame_clause?: (ctx: Opt_frame_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.sconst`. + * Enter a parse tree produced by `PostgreSqlParser.frame_bound`. * @param ctx the parse tree */ - enterSconst?: (ctx: SconstContext) => void; + enterFrame_bound?: (ctx: Frame_boundContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.sconst`. + * Exit a parse tree produced by `PostgreSqlParser.frame_bound`. * @param ctx the parse tree */ - exitSconst?: (ctx: SconstContext) => void; + exitFrame_bound?: (ctx: Frame_boundContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.anysconst`. + * Enter a parse tree produced by `PostgreSqlParser.row`. * @param ctx the parse tree */ - enterAnysconst?: (ctx: AnysconstContext) => void; + enterRow?: (ctx: RowContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.anysconst`. + * Exit a parse tree produced by `PostgreSqlParser.row`. * @param ctx the parse tree */ - exitAnysconst?: (ctx: AnysconstContext) => void; + exitRow?: (ctx: RowContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_uescape`. + * Enter a parse tree produced by `PostgreSqlParser.explicit_row`. * @param ctx the parse tree */ - enterOpt_uescape?: (ctx: Opt_uescapeContext) => void; + enterExplicit_row?: (ctx: Explicit_rowContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_uescape`. + * Exit a parse tree produced by `PostgreSqlParser.explicit_row`. * @param ctx the parse tree */ - exitOpt_uescape?: (ctx: Opt_uescapeContext) => void; + exitExplicit_row?: (ctx: Explicit_rowContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.signediconst`. + * Enter a parse tree produced by `PostgreSqlParser.sub_type`. * @param ctx the parse tree */ - enterSignediconst?: (ctx: SignediconstContext) => void; + enterSub_type?: (ctx: Sub_typeContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.signediconst`. + * Exit a parse tree produced by `PostgreSqlParser.sub_type`. * @param ctx the parse tree */ - exitSignediconst?: (ctx: SignediconstContext) => void; + exitSub_type?: (ctx: Sub_typeContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.groupname`. + * Enter a parse tree produced by `PostgreSqlParser.all_op`. * @param ctx the parse tree */ - enterGroupname?: (ctx: GroupnameContext) => void; + enterAll_op?: (ctx: All_opContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.groupname`. + * Exit a parse tree produced by `PostgreSqlParser.all_op`. * @param ctx the parse tree */ - exitGroupname?: (ctx: GroupnameContext) => void; + exitAll_op?: (ctx: All_opContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.roleid`. + * Enter a parse tree produced by `PostgreSqlParser.mathop`. * @param ctx the parse tree */ - enterRoleid?: (ctx: RoleidContext) => void; + enterMathop?: (ctx: MathopContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.roleid`. + * Exit a parse tree produced by `PostgreSqlParser.mathop`. * @param ctx the parse tree */ - exitRoleid?: (ctx: RoleidContext) => void; + exitMathop?: (ctx: MathopContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.rolespec`. + * Enter a parse tree produced by `PostgreSqlParser.qual_op`. * @param ctx the parse tree */ - enterRolespec?: (ctx: RolespecContext) => void; + enterQual_op?: (ctx: Qual_opContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.rolespec`. + * Exit a parse tree produced by `PostgreSqlParser.qual_op`. * @param ctx the parse tree */ - exitRolespec?: (ctx: RolespecContext) => void; + exitQual_op?: (ctx: Qual_opContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.role_list`. + * Enter a parse tree produced by `PostgreSqlParser.qual_all_op`. * @param ctx the parse tree */ - enterRole_list?: (ctx: Role_listContext) => void; + enterQual_all_op?: (ctx: Qual_all_opContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.role_list`. + * Exit a parse tree produced by `PostgreSqlParser.qual_all_op`. * @param ctx the parse tree */ - exitRole_list?: (ctx: Role_listContext) => void; + exitQual_all_op?: (ctx: Qual_all_opContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.colid`. + * Enter a parse tree produced by `PostgreSqlParser.subquery_Op`. * @param ctx the parse tree */ - enterColid?: (ctx: ColidContext) => void; + enterSubquery_Op?: (ctx: Subquery_OpContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.colid`. + * Exit a parse tree produced by `PostgreSqlParser.subquery_Op`. * @param ctx the parse tree */ - exitColid?: (ctx: ColidContext) => void; + exitSubquery_Op?: (ctx: Subquery_OpContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.index_method_choices`. + * Enter a parse tree produced by `PostgreSqlParser.expr_list`. * @param ctx the parse tree */ - enterIndex_method_choices?: (ctx: Index_method_choicesContext) => void; + enterExpr_list?: (ctx: Expr_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.index_method_choices`. + * Exit a parse tree produced by `PostgreSqlParser.expr_list`. * @param ctx the parse tree */ - exitIndex_method_choices?: (ctx: Index_method_choicesContext) => void; + exitExpr_list?: (ctx: Expr_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.exclude_element`. + * Enter a parse tree produced by `PostgreSqlParser.column_expr`. * @param ctx the parse tree */ - enterExclude_element?: (ctx: Exclude_elementContext) => void; + enterColumn_expr?: (ctx: Column_exprContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.exclude_element`. + * Exit a parse tree produced by `PostgreSqlParser.column_expr`. * @param ctx the parse tree */ - exitExclude_element?: (ctx: Exclude_elementContext) => void; + exitColumn_expr?: (ctx: Column_exprContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.index_paramenters`. + * Enter a parse tree produced by `PostgreSqlParser.column_expr_noparen`. * @param ctx the parse tree */ - enterIndex_paramenters?: (ctx: Index_paramentersContext) => void; + enterColumn_expr_noparen?: (ctx: Column_expr_noparenContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.index_paramenters`. + * Exit a parse tree produced by `PostgreSqlParser.column_expr_noparen`. * @param ctx the parse tree */ - exitIndex_paramenters?: (ctx: Index_paramentersContext) => void; + exitColumn_expr_noparen?: (ctx: Column_expr_noparenContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.type_function_name`. + * Enter a parse tree produced by `PostgreSqlParser.func_arg_list`. * @param ctx the parse tree */ - enterType_function_name?: (ctx: Type_function_nameContext) => void; + enterFunc_arg_list?: (ctx: Func_arg_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.type_function_name`. + * Exit a parse tree produced by `PostgreSqlParser.func_arg_list`. * @param ctx the parse tree */ - exitType_function_name?: (ctx: Type_function_nameContext) => void; + exitFunc_arg_list?: (ctx: Func_arg_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.type_usual_name`. + * Enter a parse tree produced by `PostgreSqlParser.func_arg_expr`. * @param ctx the parse tree */ - enterType_usual_name?: (ctx: Type_usual_nameContext) => void; + enterFunc_arg_expr?: (ctx: Func_arg_exprContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.type_usual_name`. + * Exit a parse tree produced by `PostgreSqlParser.func_arg_expr`. * @param ctx the parse tree */ - exitType_usual_name?: (ctx: Type_usual_nameContext) => void; + exitFunc_arg_expr?: (ctx: Func_arg_exprContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.nonreservedword_column`. + * Enter a parse tree produced by `PostgreSqlParser.array_expr`. * @param ctx the parse tree */ - enterNonreservedword_column?: (ctx: Nonreservedword_columnContext) => void; + enterArray_expr?: (ctx: Array_exprContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.nonreservedword_column`. + * Exit a parse tree produced by `PostgreSqlParser.array_expr`. * @param ctx the parse tree */ - exitNonreservedword_column?: (ctx: Nonreservedword_columnContext) => void; + exitArray_expr?: (ctx: Array_exprContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.nonreservedword`. + * Enter a parse tree produced by `PostgreSqlParser.extract_arg`. * @param ctx the parse tree */ - enterNonreservedword?: (ctx: NonreservedwordContext) => void; + enterExtract_arg?: (ctx: Extract_argContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.nonreservedword`. + * Exit a parse tree produced by `PostgreSqlParser.extract_arg`. * @param ctx the parse tree */ - exitNonreservedword?: (ctx: NonreservedwordContext) => void; + exitExtract_arg?: (ctx: Extract_argContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.collabel`. + * Enter a parse tree produced by `PostgreSqlParser.unicode_normal_form`. * @param ctx the parse tree */ - enterCollabel?: (ctx: CollabelContext) => void; + enterUnicode_normal_form?: (ctx: Unicode_normal_formContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.collabel`. + * Exit a parse tree produced by `PostgreSqlParser.unicode_normal_form`. * @param ctx the parse tree */ - exitCollabel?: (ctx: CollabelContext) => void; + exitUnicode_normal_form?: (ctx: Unicode_normal_formContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.identifier`. + * Enter a parse tree produced by `PostgreSqlParser.substr_list`. * @param ctx the parse tree */ - enterIdentifier?: (ctx: IdentifierContext) => void; + enterSubstr_list?: (ctx: Substr_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.identifier`. + * Exit a parse tree produced by `PostgreSqlParser.substr_list`. * @param ctx the parse tree */ - exitIdentifier?: (ctx: IdentifierContext) => void; + exitSubstr_list?: (ctx: Substr_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.plsqlidentifier`. + * Enter a parse tree produced by `PostgreSqlParser.when_clause`. * @param ctx the parse tree */ - enterPlsqlidentifier?: (ctx: PlsqlidentifierContext) => void; + enterWhen_clause?: (ctx: When_clauseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.plsqlidentifier`. + * Exit a parse tree produced by `PostgreSqlParser.when_clause`. * @param ctx the parse tree */ - exitPlsqlidentifier?: (ctx: PlsqlidentifierContext) => void; + exitWhen_clause?: (ctx: When_clauseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.unreserved_keyword`. + * Enter a parse tree produced by `PostgreSqlParser.indirection_el`. * @param ctx the parse tree */ - enterUnreserved_keyword?: (ctx: Unreserved_keywordContext) => void; + enterIndirection_el?: (ctx: Indirection_elContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.unreserved_keyword`. + * Exit a parse tree produced by `PostgreSqlParser.indirection_el`. * @param ctx the parse tree */ - exitUnreserved_keyword?: (ctx: Unreserved_keywordContext) => void; + exitIndirection_el?: (ctx: Indirection_elContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.col_name_keyword`. + * Enter a parse tree produced by `PostgreSqlParser.indirection`. * @param ctx the parse tree */ - enterCol_name_keyword?: (ctx: Col_name_keywordContext) => void; + enterIndirection?: (ctx: IndirectionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.col_name_keyword`. + * Exit a parse tree produced by `PostgreSqlParser.indirection`. * @param ctx the parse tree */ - exitCol_name_keyword?: (ctx: Col_name_keywordContext) => void; + exitIndirection?: (ctx: IndirectionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.type_func_name_keyword`. + * Enter a parse tree produced by `PostgreSqlParser.opt_indirection`. * @param ctx the parse tree */ - enterType_func_name_keyword?: (ctx: Type_func_name_keywordContext) => void; + enterOpt_indirection?: (ctx: Opt_indirectionContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.type_func_name_keyword`. + * Exit a parse tree produced by `PostgreSqlParser.opt_indirection`. * @param ctx the parse tree */ - exitType_func_name_keyword?: (ctx: Type_func_name_keywordContext) => void; + exitOpt_indirection?: (ctx: Opt_indirectionContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.reserved_keyword`. + * Enter a parse tree produced by `PostgreSqlParser.target_list`. * @param ctx the parse tree */ - enterReserved_keyword?: (ctx: Reserved_keywordContext) => void; + enterTarget_list?: (ctx: Target_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.reserved_keyword`. + * Exit a parse tree produced by `PostgreSqlParser.target_list`. * @param ctx the parse tree */ - exitReserved_keyword?: (ctx: Reserved_keywordContext) => void; + exitTarget_list?: (ctx: Target_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.pl_function`. + * Enter a parse tree produced by the `target_label` + * labeled alternative in `PostgreSqlParser.target_el`. * @param ctx the parse tree */ - enterPl_function?: (ctx: Pl_functionContext) => void; + enterTarget_label?: (ctx: Target_labelContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.pl_function`. + * Exit a parse tree produced by the `target_label` + * labeled alternative in `PostgreSqlParser.target_el`. * @param ctx the parse tree */ - exitPl_function?: (ctx: Pl_functionContext) => void; + exitTarget_label?: (ctx: Target_labelContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.comp_options`. + * Enter a parse tree produced by the `target_star` + * labeled alternative in `PostgreSqlParser.target_el`. * @param ctx the parse tree */ - enterComp_options?: (ctx: Comp_optionsContext) => void; + enterTarget_star?: (ctx: Target_starContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.comp_options`. + * Exit a parse tree produced by the `target_star` + * labeled alternative in `PostgreSqlParser.target_el`. * @param ctx the parse tree */ - exitComp_options?: (ctx: Comp_optionsContext) => void; + exitTarget_star?: (ctx: Target_starContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.comp_option`. + * Enter a parse tree produced by `PostgreSqlParser.qualified_name_list`. * @param ctx the parse tree */ - enterComp_option?: (ctx: Comp_optionContext) => void; + enterQualified_name_list?: (ctx: Qualified_name_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.comp_option`. + * Exit a parse tree produced by `PostgreSqlParser.qualified_name_list`. * @param ctx the parse tree */ - exitComp_option?: (ctx: Comp_optionContext) => void; + exitQualified_name_list?: (ctx: Qualified_name_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.sharp`. + * Enter a parse tree produced by `PostgreSqlParser.table_name_list`. * @param ctx the parse tree */ - enterSharp?: (ctx: SharpContext) => void; + enterTable_name_list?: (ctx: Table_name_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.sharp`. + * Exit a parse tree produced by `PostgreSqlParser.table_name_list`. * @param ctx the parse tree */ - exitSharp?: (ctx: SharpContext) => void; + exitTable_name_list?: (ctx: Table_name_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.option_value`. + * Enter a parse tree produced by `PostgreSqlParser.schema_name_list`. * @param ctx the parse tree */ - enterOption_value?: (ctx: Option_valueContext) => void; + enterSchema_name_list?: (ctx: Schema_name_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.option_value`. + * Exit a parse tree produced by `PostgreSqlParser.schema_name_list`. * @param ctx the parse tree */ - exitOption_value?: (ctx: Option_valueContext) => void; + exitSchema_name_list?: (ctx: Schema_name_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_semi`. + * Enter a parse tree produced by `PostgreSqlParser.database_nameList`. * @param ctx the parse tree */ - enterOpt_semi?: (ctx: Opt_semiContext) => void; + enterDatabase_nameList?: (ctx: Database_nameListContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_semi`. + * Exit a parse tree produced by `PostgreSqlParser.database_nameList`. * @param ctx the parse tree */ - exitOpt_semi?: (ctx: Opt_semiContext) => void; + exitDatabase_nameList?: (ctx: Database_nameListContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.pl_block`. + * Enter a parse tree produced by the `tablespaceNameCreate` + * labeled alternative in `PostgreSqlParser.tablespace_name_create`. * @param ctx the parse tree */ - enterPl_block?: (ctx: Pl_blockContext) => void; + enterTablespaceNameCreate?: (ctx: TablespaceNameCreateContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.pl_block`. + * Exit a parse tree produced by the `tablespaceNameCreate` + * labeled alternative in `PostgreSqlParser.tablespace_name_create`. * @param ctx the parse tree */ - exitPl_block?: (ctx: Pl_blockContext) => void; + exitTablespaceNameCreate?: (ctx: TablespaceNameCreateContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_sect`. + * Enter a parse tree produced by the `tablespaceName` + * labeled alternative in `PostgreSqlParser.tablespace_name`. * @param ctx the parse tree */ - enterDecl_sect?: (ctx: Decl_sectContext) => void; + enterTablespaceName?: (ctx: TablespaceNameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_sect`. + * Exit a parse tree produced by the `tablespaceName` + * labeled alternative in `PostgreSqlParser.tablespace_name`. * @param ctx the parse tree */ - exitDecl_sect?: (ctx: Decl_sectContext) => void; + exitTablespaceName?: (ctx: TablespaceNameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_start`. + * Enter a parse tree produced by the `tableNameCreate` + * labeled alternative in `PostgreSqlParser.table_name_create`. * @param ctx the parse tree */ - enterDecl_start?: (ctx: Decl_startContext) => void; + enterTableNameCreate?: (ctx: TableNameCreateContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_start`. + * Exit a parse tree produced by the `tableNameCreate` + * labeled alternative in `PostgreSqlParser.table_name_create`. * @param ctx the parse tree */ - exitDecl_start?: (ctx: Decl_startContext) => void; + exitTableNameCreate?: (ctx: TableNameCreateContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_stmts`. + * Enter a parse tree produced by the `tableName` + * labeled alternative in `PostgreSqlParser.table_name`. * @param ctx the parse tree */ - enterDecl_stmts?: (ctx: Decl_stmtsContext) => void; + enterTableName?: (ctx: TableNameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_stmts`. + * Exit a parse tree produced by the `tableName` + * labeled alternative in `PostgreSqlParser.table_name`. * @param ctx the parse tree */ - exitDecl_stmts?: (ctx: Decl_stmtsContext) => void; + exitTableName?: (ctx: TableNameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.label_decl`. + * Enter a parse tree produced by the `viewNameCreate` + * labeled alternative in `PostgreSqlParser.view_name_create`. * @param ctx the parse tree */ - enterLabel_decl?: (ctx: Label_declContext) => void; + enterViewNameCreate?: (ctx: ViewNameCreateContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.label_decl`. + * Exit a parse tree produced by the `viewNameCreate` + * labeled alternative in `PostgreSqlParser.view_name_create`. * @param ctx the parse tree */ - exitLabel_decl?: (ctx: Label_declContext) => void; + exitViewNameCreate?: (ctx: ViewNameCreateContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_stmt`. + * Enter a parse tree produced by the `viewName` + * labeled alternative in `PostgreSqlParser.view_name`. * @param ctx the parse tree */ - enterDecl_stmt?: (ctx: Decl_stmtContext) => void; + enterViewName?: (ctx: ViewNameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_stmt`. + * Exit a parse tree produced by the `viewName` + * labeled alternative in `PostgreSqlParser.view_name`. * @param ctx the parse tree */ - exitDecl_stmt?: (ctx: Decl_stmtContext) => void; + exitViewName?: (ctx: ViewNameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_statement`. + * Enter a parse tree produced by `PostgreSqlParser.qualified_name`. * @param ctx the parse tree */ - enterDecl_statement?: (ctx: Decl_statementContext) => void; + enterQualified_name?: (ctx: Qualified_nameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_statement`. + * Exit a parse tree produced by `PostgreSqlParser.qualified_name`. * @param ctx the parse tree */ - exitDecl_statement?: (ctx: Decl_statementContext) => void; + exitQualified_name?: (ctx: Qualified_nameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_scrollable`. + * Enter a parse tree produced by `PostgreSqlParser.tablespace_name_list`. * @param ctx the parse tree */ - enterOpt_scrollable?: (ctx: Opt_scrollableContext) => void; + enterTablespace_name_list?: (ctx: Tablespace_name_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_scrollable`. + * Exit a parse tree produced by `PostgreSqlParser.tablespace_name_list`. * @param ctx the parse tree */ - exitOpt_scrollable?: (ctx: Opt_scrollableContext) => void; + exitTablespace_name_list?: (ctx: Tablespace_name_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_cursor_query`. + * Enter a parse tree produced by `PostgreSqlParser.name_list`. * @param ctx the parse tree */ - enterDecl_cursor_query?: (ctx: Decl_cursor_queryContext) => void; + enterName_list?: (ctx: Name_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_cursor_query`. + * Exit a parse tree produced by `PostgreSqlParser.name_list`. * @param ctx the parse tree */ - exitDecl_cursor_query?: (ctx: Decl_cursor_queryContext) => void; + exitName_list?: (ctx: Name_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_cursor_args`. + * Enter a parse tree produced by the `databaseNameCreate` + * labeled alternative in `PostgreSqlParser.database_name_create`. * @param ctx the parse tree */ - enterDecl_cursor_args?: (ctx: Decl_cursor_argsContext) => void; + enterDatabaseNameCreate?: (ctx: DatabaseNameCreateContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_cursor_args`. + * Exit a parse tree produced by the `databaseNameCreate` + * labeled alternative in `PostgreSqlParser.database_name_create`. * @param ctx the parse tree */ - exitDecl_cursor_args?: (ctx: Decl_cursor_argsContext) => void; + exitDatabaseNameCreate?: (ctx: DatabaseNameCreateContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_cursor_arglist`. + * Enter a parse tree produced by the `databaseName` + * labeled alternative in `PostgreSqlParser.database_name`. * @param ctx the parse tree */ - enterDecl_cursor_arglist?: (ctx: Decl_cursor_arglistContext) => void; + enterDatabaseName?: (ctx: DatabaseNameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_cursor_arglist`. + * Exit a parse tree produced by the `databaseName` + * labeled alternative in `PostgreSqlParser.database_name`. * @param ctx the parse tree */ - exitDecl_cursor_arglist?: (ctx: Decl_cursor_arglistContext) => void; + exitDatabaseName?: (ctx: DatabaseNameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_cursor_arg`. + * Enter a parse tree produced by the `schemaName` + * labeled alternative in `PostgreSqlParser.schema_name`. * @param ctx the parse tree */ - enterDecl_cursor_arg?: (ctx: Decl_cursor_argContext) => void; + enterSchemaName?: (ctx: SchemaNameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_cursor_arg`. + * Exit a parse tree produced by the `schemaName` + * labeled alternative in `PostgreSqlParser.schema_name`. * @param ctx the parse tree */ - exitDecl_cursor_arg?: (ctx: Decl_cursor_argContext) => void; + exitSchemaName?: (ctx: SchemaNameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_is_for`. + * Enter a parse tree produced by the `routineNameCreate` + * labeled alternative in `PostgreSqlParser.routine_name_create`. * @param ctx the parse tree */ - enterDecl_is_for?: (ctx: Decl_is_forContext) => void; + enterRoutineNameCreate?: (ctx: RoutineNameCreateContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_is_for`. + * Exit a parse tree produced by the `routineNameCreate` + * labeled alternative in `PostgreSqlParser.routine_name_create`. * @param ctx the parse tree */ - exitDecl_is_for?: (ctx: Decl_is_forContext) => void; + exitRoutineNameCreate?: (ctx: RoutineNameCreateContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_aliasitem`. + * Enter a parse tree produced by the `routineName` + * labeled alternative in `PostgreSqlParser.routine_name`. * @param ctx the parse tree */ - enterDecl_aliasitem?: (ctx: Decl_aliasitemContext) => void; + enterRoutineName?: (ctx: RoutineNameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_aliasitem`. + * Exit a parse tree produced by the `routineName` + * labeled alternative in `PostgreSqlParser.routine_name`. * @param ctx the parse tree */ - exitDecl_aliasitem?: (ctx: Decl_aliasitemContext) => void; + exitRoutineName?: (ctx: RoutineNameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_varname`. + * Enter a parse tree produced by the `procedureName` + * labeled alternative in `PostgreSqlParser.procedure_name`. * @param ctx the parse tree */ - enterDecl_varname?: (ctx: Decl_varnameContext) => void; + enterProcedureName?: (ctx: ProcedureNameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_varname`. + * Exit a parse tree produced by the `procedureName` + * labeled alternative in `PostgreSqlParser.procedure_name`. * @param ctx the parse tree */ - exitDecl_varname?: (ctx: Decl_varnameContext) => void; + exitProcedureName?: (ctx: ProcedureNameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_const`. + * Enter a parse tree produced by the `procedureNameCreate` + * labeled alternative in `PostgreSqlParser.procedure_name_create`. * @param ctx the parse tree */ - enterDecl_const?: (ctx: Decl_constContext) => void; + enterProcedureNameCreate?: (ctx: ProcedureNameCreateContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_const`. + * Exit a parse tree produced by the `procedureNameCreate` + * labeled alternative in `PostgreSqlParser.procedure_name_create`. * @param ctx the parse tree */ - exitDecl_const?: (ctx: Decl_constContext) => void; + exitProcedureNameCreate?: (ctx: ProcedureNameCreateContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_datatype`. + * Enter a parse tree produced by the `columnName` + * labeled alternative in `PostgreSqlParser.column_name`. * @param ctx the parse tree */ - enterDecl_datatype?: (ctx: Decl_datatypeContext) => void; + enterColumnName?: (ctx: ColumnNameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_datatype`. + * Exit a parse tree produced by the `columnName` + * labeled alternative in `PostgreSqlParser.column_name`. * @param ctx the parse tree */ - exitDecl_datatype?: (ctx: Decl_datatypeContext) => void; + exitColumnName?: (ctx: ColumnNameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_collate`. + * Enter a parse tree produced by the `columnNameMatch` + * labeled alternative in `PostgreSqlParser.column_name`. * @param ctx the parse tree */ - enterDecl_collate?: (ctx: Decl_collateContext) => void; + enterColumnNameMatch?: (ctx: ColumnNameMatchContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_collate`. + * Exit a parse tree produced by the `columnNameMatch` + * labeled alternative in `PostgreSqlParser.column_name`. * @param ctx the parse tree */ - exitDecl_collate?: (ctx: Decl_collateContext) => void; + exitColumnNameMatch?: (ctx: ColumnNameMatchContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_notnull`. + * Enter a parse tree produced by the `columnNameCreate` + * labeled alternative in `PostgreSqlParser.column_name_create`. * @param ctx the parse tree */ - enterDecl_notnull?: (ctx: Decl_notnullContext) => void; + enterColumnNameCreate?: (ctx: ColumnNameCreateContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_notnull`. + * Exit a parse tree produced by the `columnNameCreate` + * labeled alternative in `PostgreSqlParser.column_name_create`. * @param ctx the parse tree */ - exitDecl_notnull?: (ctx: Decl_notnullContext) => void; + exitColumnNameCreate?: (ctx: ColumnNameCreateContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_defval`. + * Enter a parse tree produced by the `functionNameCreate` + * labeled alternative in `PostgreSqlParser.function_name_create`. * @param ctx the parse tree */ - enterDecl_defval?: (ctx: Decl_defvalContext) => void; + enterFunctionNameCreate?: (ctx: FunctionNameCreateContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_defval`. + * Exit a parse tree produced by the `functionNameCreate` + * labeled alternative in `PostgreSqlParser.function_name_create`. * @param ctx the parse tree */ - exitDecl_defval?: (ctx: Decl_defvalContext) => void; + exitFunctionNameCreate?: (ctx: FunctionNameCreateContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.decl_defkey`. + * Enter a parse tree produced by the `functionName` + * labeled alternative in `PostgreSqlParser.function_name`. * @param ctx the parse tree */ - enterDecl_defkey?: (ctx: Decl_defkeyContext) => void; + enterFunctionName?: (ctx: FunctionNameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.decl_defkey`. + * Exit a parse tree produced by the `functionName` + * labeled alternative in `PostgreSqlParser.function_name`. * @param ctx the parse tree */ - exitDecl_defkey?: (ctx: Decl_defkeyContext) => void; + exitFunctionName?: (ctx: FunctionNameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.assign_operator`. + * Enter a parse tree produced by `PostgreSqlParser.sconst`. * @param ctx the parse tree */ - enterAssign_operator?: (ctx: Assign_operatorContext) => void; + enterSconst?: (ctx: SconstContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.assign_operator`. + * Exit a parse tree produced by `PostgreSqlParser.sconst`. * @param ctx the parse tree */ - exitAssign_operator?: (ctx: Assign_operatorContext) => void; + exitSconst?: (ctx: SconstContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.proc_sect`. + * Enter a parse tree produced by `PostgreSqlParser.anysconst`. * @param ctx the parse tree */ - enterProc_sect?: (ctx: Proc_sectContext) => void; + enterAnysconst?: (ctx: AnysconstContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.proc_sect`. + * Exit a parse tree produced by `PostgreSqlParser.anysconst`. * @param ctx the parse tree */ - exitProc_sect?: (ctx: Proc_sectContext) => void; + exitAnysconst?: (ctx: AnysconstContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.proc_stmt`. + * Enter a parse tree produced by `PostgreSqlParser.signediconst`. * @param ctx the parse tree */ - enterProc_stmt?: (ctx: Proc_stmtContext) => void; + enterSignediconst?: (ctx: SignediconstContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.proc_stmt`. + * Exit a parse tree produced by `PostgreSqlParser.signediconst`. * @param ctx the parse tree */ - exitProc_stmt?: (ctx: Proc_stmtContext) => void; + exitSignediconst?: (ctx: SignediconstContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_perform`. + * Enter a parse tree produced by `PostgreSqlParser.rolespec`. * @param ctx the parse tree */ - enterStmt_perform?: (ctx: Stmt_performContext) => void; + enterRolespec?: (ctx: RolespecContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_perform`. + * Exit a parse tree produced by `PostgreSqlParser.rolespec`. * @param ctx the parse tree */ - exitStmt_perform?: (ctx: Stmt_performContext) => void; + exitRolespec?: (ctx: RolespecContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_call`. + * Enter a parse tree produced by `PostgreSqlParser.role_list`. * @param ctx the parse tree */ - enterStmt_call?: (ctx: Stmt_callContext) => void; + enterRole_list?: (ctx: Role_listContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_call`. + * Exit a parse tree produced by `PostgreSqlParser.role_list`. * @param ctx the parse tree */ - exitStmt_call?: (ctx: Stmt_callContext) => void; + exitRole_list?: (ctx: Role_listContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_expr_list`. + * Enter a parse tree produced by `PostgreSqlParser.colid`. * @param ctx the parse tree */ - enterOpt_expr_list?: (ctx: Opt_expr_listContext) => void; + enterColid?: (ctx: ColidContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_expr_list`. + * Exit a parse tree produced by `PostgreSqlParser.colid`. * @param ctx the parse tree */ - exitOpt_expr_list?: (ctx: Opt_expr_listContext) => void; + exitColid?: (ctx: ColidContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_assign`. + * Enter a parse tree produced by `PostgreSqlParser.type_function_name`. * @param ctx the parse tree */ - enterStmt_assign?: (ctx: Stmt_assignContext) => void; + enterType_function_name?: (ctx: Type_function_nameContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_assign`. + * Exit a parse tree produced by `PostgreSqlParser.type_function_name`. * @param ctx the parse tree */ - exitStmt_assign?: (ctx: Stmt_assignContext) => void; + exitType_function_name?: (ctx: Type_function_nameContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_getdiag`. + * Enter a parse tree produced by `PostgreSqlParser.nonreservedword`. * @param ctx the parse tree */ - enterStmt_getdiag?: (ctx: Stmt_getdiagContext) => void; + enterNonreservedword?: (ctx: NonreservedwordContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_getdiag`. + * Exit a parse tree produced by `PostgreSqlParser.nonreservedword`. * @param ctx the parse tree */ - exitStmt_getdiag?: (ctx: Stmt_getdiagContext) => void; + exitNonreservedword?: (ctx: NonreservedwordContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.getdiag_area_opt`. + * Enter a parse tree produced by `PostgreSqlParser.collabel`. * @param ctx the parse tree */ - enterGetdiag_area_opt?: (ctx: Getdiag_area_optContext) => void; + enterCollabel?: (ctx: CollabelContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.getdiag_area_opt`. + * Exit a parse tree produced by `PostgreSqlParser.collabel`. * @param ctx the parse tree */ - exitGetdiag_area_opt?: (ctx: Getdiag_area_optContext) => void; + exitCollabel?: (ctx: CollabelContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.getdiag_list`. + * Enter a parse tree produced by `PostgreSqlParser.identifier`. * @param ctx the parse tree */ - enterGetdiag_list?: (ctx: Getdiag_listContext) => void; + enterIdentifier?: (ctx: IdentifierContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.getdiag_list`. + * Exit a parse tree produced by `PostgreSqlParser.identifier`. * @param ctx the parse tree */ - exitGetdiag_list?: (ctx: Getdiag_listContext) => void; + exitIdentifier?: (ctx: IdentifierContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.getdiag_list_item`. + * Enter a parse tree produced by `PostgreSqlParser.unreserved_keyword`. * @param ctx the parse tree */ - enterGetdiag_list_item?: (ctx: Getdiag_list_itemContext) => void; + enterUnreserved_keyword?: (ctx: Unreserved_keywordContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.getdiag_list_item`. + * Exit a parse tree produced by `PostgreSqlParser.unreserved_keyword`. * @param ctx the parse tree */ - exitGetdiag_list_item?: (ctx: Getdiag_list_itemContext) => void; + exitUnreserved_keyword?: (ctx: Unreserved_keywordContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.getdiag_item`. + * Enter a parse tree produced by `PostgreSqlParser.col_name_keyword`. * @param ctx the parse tree */ - enterGetdiag_item?: (ctx: Getdiag_itemContext) => void; + enterCol_name_keyword?: (ctx: Col_name_keywordContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.getdiag_item`. + * Exit a parse tree produced by `PostgreSqlParser.col_name_keyword`. * @param ctx the parse tree */ - exitGetdiag_item?: (ctx: Getdiag_itemContext) => void; + exitCol_name_keyword?: (ctx: Col_name_keywordContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.getdiag_target`. + * Enter a parse tree produced by `PostgreSqlParser.type_func_name_keyword`. * @param ctx the parse tree */ - enterGetdiag_target?: (ctx: Getdiag_targetContext) => void; + enterType_func_name_keyword?: (ctx: Type_func_name_keywordContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.getdiag_target`. + * Exit a parse tree produced by `PostgreSqlParser.type_func_name_keyword`. * @param ctx the parse tree */ - exitGetdiag_target?: (ctx: Getdiag_targetContext) => void; + exitType_func_name_keyword?: (ctx: Type_func_name_keywordContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.assign_var`. + * Enter a parse tree produced by `PostgreSqlParser.reserved_keyword`. * @param ctx the parse tree */ - enterAssign_var?: (ctx: Assign_varContext) => void; + enterReserved_keyword?: (ctx: Reserved_keywordContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.assign_var`. + * Exit a parse tree produced by `PostgreSqlParser.reserved_keyword`. * @param ctx the parse tree */ - exitAssign_var?: (ctx: Assign_varContext) => void; + exitReserved_keyword?: (ctx: Reserved_keywordContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_if`. + * Enter a parse tree produced by `PostgreSqlParser.pl_block`. * @param ctx the parse tree */ - enterStmt_if?: (ctx: Stmt_ifContext) => void; + enterPl_block?: (ctx: Pl_blockContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_if`. + * Exit a parse tree produced by `PostgreSqlParser.pl_block`. * @param ctx the parse tree */ - exitStmt_if?: (ctx: Stmt_ifContext) => void; + exitPl_block?: (ctx: Pl_blockContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_elsifs`. + * Enter a parse tree produced by `PostgreSqlParser.label_decl`. * @param ctx the parse tree */ - enterStmt_elsifs?: (ctx: Stmt_elsifsContext) => void; + enterLabel_decl?: (ctx: Label_declContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_elsifs`. + * Exit a parse tree produced by `PostgreSqlParser.label_decl`. * @param ctx the parse tree */ - exitStmt_elsifs?: (ctx: Stmt_elsifsContext) => void; + exitLabel_decl?: (ctx: Label_declContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_else`. + * Enter a parse tree produced by `PostgreSqlParser.decl_statement`. * @param ctx the parse tree */ - enterStmt_else?: (ctx: Stmt_elseContext) => void; + enterDecl_statement?: (ctx: Decl_statementContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_else`. + * Exit a parse tree produced by `PostgreSqlParser.decl_statement`. * @param ctx the parse tree */ - exitStmt_else?: (ctx: Stmt_elseContext) => void; + exitDecl_statement?: (ctx: Decl_statementContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_case`. + * Enter a parse tree produced by `PostgreSqlParser.decl_cursor_arg`. * @param ctx the parse tree */ - enterStmt_case?: (ctx: Stmt_caseContext) => void; + enterDecl_cursor_arg?: (ctx: Decl_cursor_argContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_case`. + * Exit a parse tree produced by `PostgreSqlParser.decl_cursor_arg`. * @param ctx the parse tree */ - exitStmt_case?: (ctx: Stmt_caseContext) => void; + exitDecl_cursor_arg?: (ctx: Decl_cursor_argContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_expr_until_when`. + * Enter a parse tree produced by `PostgreSqlParser.assign_operator`. * @param ctx the parse tree */ - enterOpt_expr_until_when?: (ctx: Opt_expr_until_whenContext) => void; + enterAssign_operator?: (ctx: Assign_operatorContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_expr_until_when`. + * Exit a parse tree produced by `PostgreSqlParser.assign_operator`. * @param ctx the parse tree */ - exitOpt_expr_until_when?: (ctx: Opt_expr_until_whenContext) => void; + exitAssign_operator?: (ctx: Assign_operatorContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.case_when_list`. + * Enter a parse tree produced by `PostgreSqlParser.proc_stmt`. * @param ctx the parse tree */ - enterCase_when_list?: (ctx: Case_when_listContext) => void; + enterProc_stmt?: (ctx: Proc_stmtContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.case_when_list`. + * Exit a parse tree produced by `PostgreSqlParser.proc_stmt`. * @param ctx the parse tree */ - exitCase_when_list?: (ctx: Case_when_listContext) => void; + exitProc_stmt?: (ctx: Proc_stmtContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.case_when`. + * Enter a parse tree produced by `PostgreSqlParser.stmt_perform`. * @param ctx the parse tree */ - enterCase_when?: (ctx: Case_whenContext) => void; + enterStmt_perform?: (ctx: Stmt_performContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.case_when`. + * Exit a parse tree produced by `PostgreSqlParser.stmt_perform`. * @param ctx the parse tree */ - exitCase_when?: (ctx: Case_whenContext) => void; + exitStmt_perform?: (ctx: Stmt_performContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_case_else`. + * Enter a parse tree produced by `PostgreSqlParser.stmt_call`. * @param ctx the parse tree */ - enterOpt_case_else?: (ctx: Opt_case_elseContext) => void; + enterStmt_call?: (ctx: Stmt_callContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_case_else`. + * Exit a parse tree produced by `PostgreSqlParser.stmt_call`. * @param ctx the parse tree */ - exitOpt_case_else?: (ctx: Opt_case_elseContext) => void; + exitStmt_call?: (ctx: Stmt_callContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_loop`. + * Enter a parse tree produced by `PostgreSqlParser.stmt_assign`. * @param ctx the parse tree */ - enterStmt_loop?: (ctx: Stmt_loopContext) => void; + enterStmt_assign?: (ctx: Stmt_assignContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_loop`. + * Exit a parse tree produced by `PostgreSqlParser.stmt_assign`. * @param ctx the parse tree */ - exitStmt_loop?: (ctx: Stmt_loopContext) => void; + exitStmt_assign?: (ctx: Stmt_assignContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_while`. + * Enter a parse tree produced by `PostgreSqlParser.stmt_getdiag`. * @param ctx the parse tree */ - enterStmt_while?: (ctx: Stmt_whileContext) => void; + enterStmt_getdiag?: (ctx: Stmt_getdiagContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_while`. + * Exit a parse tree produced by `PostgreSqlParser.stmt_getdiag`. * @param ctx the parse tree */ - exitStmt_while?: (ctx: Stmt_whileContext) => void; + exitStmt_getdiag?: (ctx: Stmt_getdiagContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_for`. + * Enter a parse tree produced by `PostgreSqlParser.getdiag_list_item`. * @param ctx the parse tree */ - enterStmt_for?: (ctx: Stmt_forContext) => void; + enterGetdiag_list_item?: (ctx: Getdiag_list_itemContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_for`. + * Exit a parse tree produced by `PostgreSqlParser.getdiag_list_item`. * @param ctx the parse tree */ - exitStmt_for?: (ctx: Stmt_forContext) => void; + exitGetdiag_list_item?: (ctx: Getdiag_list_itemContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.for_control`. + * Enter a parse tree produced by `PostgreSqlParser.assign_var`. * @param ctx the parse tree */ - enterFor_control?: (ctx: For_controlContext) => void; + enterAssign_var?: (ctx: Assign_varContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.for_control`. + * Exit a parse tree produced by `PostgreSqlParser.assign_var`. * @param ctx the parse tree */ - exitFor_control?: (ctx: For_controlContext) => void; + exitAssign_var?: (ctx: Assign_varContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_for_using_expression`. + * Enter a parse tree produced by `PostgreSqlParser.stmt_if`. * @param ctx the parse tree */ - enterOpt_for_using_expression?: (ctx: Opt_for_using_expressionContext) => void; + enterStmt_if?: (ctx: Stmt_ifContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_for_using_expression`. + * Exit a parse tree produced by `PostgreSqlParser.stmt_if`. * @param ctx the parse tree */ - exitOpt_for_using_expression?: (ctx: Opt_for_using_expressionContext) => void; + exitStmt_if?: (ctx: Stmt_ifContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_cursor_parameters`. + * Enter a parse tree produced by `PostgreSqlParser.stmt_else`. * @param ctx the parse tree */ - enterOpt_cursor_parameters?: (ctx: Opt_cursor_parametersContext) => void; + enterStmt_else?: (ctx: Stmt_elseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_cursor_parameters`. + * Exit a parse tree produced by `PostgreSqlParser.stmt_else`. * @param ctx the parse tree */ - exitOpt_cursor_parameters?: (ctx: Opt_cursor_parametersContext) => void; + exitStmt_else?: (ctx: Stmt_elseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_reverse`. + * Enter a parse tree produced by `PostgreSqlParser.stmt_case`. * @param ctx the parse tree */ - enterOpt_reverse?: (ctx: Opt_reverseContext) => void; + enterStmt_case?: (ctx: Stmt_caseContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_reverse`. + * Exit a parse tree produced by `PostgreSqlParser.stmt_case`. * @param ctx the parse tree */ - exitOpt_reverse?: (ctx: Opt_reverseContext) => void; + exitStmt_case?: (ctx: Stmt_caseContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.opt_by_expression`. + * Enter a parse tree produced by `PostgreSqlParser.stmt_loop_while_for`. * @param ctx the parse tree */ - enterOpt_by_expression?: (ctx: Opt_by_expressionContext) => void; + enterStmt_loop_while_for?: (ctx: Stmt_loop_while_forContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.opt_by_expression`. + * Exit a parse tree produced by `PostgreSqlParser.stmt_loop_while_for`. * @param ctx the parse tree */ - exitOpt_by_expression?: (ctx: Opt_by_expressionContext) => void; + exitStmt_loop_while_for?: (ctx: Stmt_loop_while_forContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.for_variable`. + * Enter a parse tree produced by `PostgreSqlParser.for_control`. * @param ctx the parse tree */ - enterFor_variable?: (ctx: For_variableContext) => void; + enterFor_control?: (ctx: For_controlContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.for_variable`. + * Exit a parse tree produced by `PostgreSqlParser.for_control`. * @param ctx the parse tree */ - exitFor_variable?: (ctx: For_variableContext) => void; + exitFor_control?: (ctx: For_controlContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.stmt_foreach_a`. * @param ctx the parse tree @@ -9164,16 +5110,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitStmt_foreach_a?: (ctx: Stmt_foreach_aContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.foreach_slice`. - * @param ctx the parse tree - */ - enterForeach_slice?: (ctx: Foreach_sliceContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.foreach_slice`. - * @param ctx the parse tree - */ - exitForeach_slice?: (ctx: Foreach_sliceContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.stmt_exit`. * @param ctx the parse tree @@ -9184,16 +5120,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitStmt_exit?: (ctx: Stmt_exitContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.exit_type`. - * @param ctx the parse tree - */ - enterExit_type?: (ctx: Exit_typeContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.exit_type`. - * @param ctx the parse tree - */ - exitExit_type?: (ctx: Exit_typeContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.stmt_return`. * @param ctx the parse tree @@ -9204,16 +5130,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitStmt_return?: (ctx: Stmt_returnContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_return_result`. - * @param ctx the parse tree - */ - enterOpt_return_result?: (ctx: Opt_return_resultContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_return_result`. - * @param ctx the parse tree - */ - exitOpt_return_result?: (ctx: Opt_return_resultContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.stmt_raise`. * @param ctx the parse tree @@ -9224,36 +5140,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitStmt_raise?: (ctx: Stmt_raiseContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_stmt_raise_level`. - * @param ctx the parse tree - */ - enterOpt_stmt_raise_level?: (ctx: Opt_stmt_raise_levelContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_stmt_raise_level`. - * @param ctx the parse tree - */ - exitOpt_stmt_raise_level?: (ctx: Opt_stmt_raise_levelContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_raise_list`. - * @param ctx the parse tree - */ - enterOpt_raise_list?: (ctx: Opt_raise_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_raise_list`. - * @param ctx the parse tree - */ - exitOpt_raise_list?: (ctx: Opt_raise_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_raise_using`. - * @param ctx the parse tree - */ - enterOpt_raise_using?: (ctx: Opt_raise_usingContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_raise_using`. - * @param ctx the parse tree - */ - exitOpt_raise_using?: (ctx: Opt_raise_usingContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.opt_raise_using_elem`. * @param ctx the parse tree @@ -9264,16 +5150,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitOpt_raise_using_elem?: (ctx: Opt_raise_using_elemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_raise_using_elem_list`. - * @param ctx the parse tree - */ - enterOpt_raise_using_elem_list?: (ctx: Opt_raise_using_elem_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_raise_using_elem_list`. - * @param ctx the parse tree - */ - exitOpt_raise_using_elem_list?: (ctx: Opt_raise_using_elem_listContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.stmt_assert`. * @param ctx the parse tree @@ -9284,16 +5160,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitStmt_assert?: (ctx: Stmt_assertContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_stmt_assert_message`. - * @param ctx the parse tree - */ - enterOpt_stmt_assert_message?: (ctx: Opt_stmt_assert_messageContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_stmt_assert_message`. - * @param ctx the parse tree - */ - exitOpt_stmt_assert_message?: (ctx: Opt_stmt_assert_messageContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.loop_body`. * @param ctx the parse tree @@ -9324,26 +5190,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitStmt_dynexecute?: (ctx: Stmt_dynexecuteContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_execute_using`. - * @param ctx the parse tree - */ - enterOpt_execute_using?: (ctx: Opt_execute_usingContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_execute_using`. - * @param ctx the parse tree - */ - exitOpt_execute_using?: (ctx: Opt_execute_usingContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_execute_using_list`. - * @param ctx the parse tree - */ - enterOpt_execute_using_list?: (ctx: Opt_execute_using_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_execute_using_list`. - * @param ctx the parse tree - */ - exitOpt_execute_using_list?: (ctx: Opt_execute_using_listContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.opt_execute_into`. * @param ctx the parse tree @@ -9374,46 +5220,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitOpt_open_bound_list_item?: (ctx: Opt_open_bound_list_itemContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_open_bound_list`. - * @param ctx the parse tree - */ - enterOpt_open_bound_list?: (ctx: Opt_open_bound_listContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_open_bound_list`. - * @param ctx the parse tree - */ - exitOpt_open_bound_list?: (ctx: Opt_open_bound_listContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_open_using`. - * @param ctx the parse tree - */ - enterOpt_open_using?: (ctx: Opt_open_usingContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_open_using`. - * @param ctx the parse tree - */ - exitOpt_open_using?: (ctx: Opt_open_usingContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_scroll_option`. - * @param ctx the parse tree - */ - enterOpt_scroll_option?: (ctx: Opt_scroll_optionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_scroll_option`. - * @param ctx the parse tree - */ - exitOpt_scroll_option?: (ctx: Opt_scroll_optionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_scroll_option_no`. - * @param ctx the parse tree - */ - enterOpt_scroll_option_no?: (ctx: Opt_scroll_option_noContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_scroll_option_no`. - * @param ctx the parse tree - */ - exitOpt_scroll_option_no?: (ctx: Opt_scroll_option_noContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.stmt_fetch`. * @param ctx the parse tree @@ -9424,26 +5230,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitStmt_fetch?: (ctx: Stmt_fetchContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.into_target`. - * @param ctx the parse tree - */ - enterInto_target?: (ctx: Into_targetContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.into_target`. - * @param ctx the parse tree - */ - exitInto_target?: (ctx: Into_targetContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_cursor_from`. - * @param ctx the parse tree - */ - enterOpt_cursor_from?: (ctx: Opt_cursor_fromContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_cursor_from`. - * @param ctx the parse tree - */ - exitOpt_cursor_from?: (ctx: Opt_cursor_fromContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.opt_fetch_direction`. * @param ctx the parse tree @@ -9484,16 +5270,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitData_source?: (ctx: Data_sourceContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.join_condition`. - * @param ctx the parse tree - */ - enterJoin_condition?: (ctx: Join_conditionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.join_condition`. - * @param ctx the parse tree - */ - exitJoin_condition?: (ctx: Join_conditionContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.merge_when_clause`. * @param ctx the parse tree @@ -9534,16 +5310,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitDefault_values_or_values?: (ctx: Default_values_or_valuesContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.exprofdefaultlist`. - * @param ctx the parse tree - */ - enterExprofdefaultlist?: (ctx: ExprofdefaultlistContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.exprofdefaultlist`. - * @param ctx the parse tree - */ - exitExprofdefaultlist?: (ctx: ExprofdefaultlistContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.exprofdefault`. * @param ctx the parse tree @@ -9575,35 +5341,15 @@ export class PostgreSqlParserListener implements ParseTreeListener { */ exitStmt_null?: (ctx: Stmt_nullContext) => void; /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_commit`. - * @param ctx the parse tree - */ - enterStmt_commit?: (ctx: Stmt_commitContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_commit`. - * @param ctx the parse tree - */ - exitStmt_commit?: (ctx: Stmt_commitContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.stmt_rollback`. - * @param ctx the parse tree - */ - enterStmt_rollback?: (ctx: Stmt_rollbackContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.stmt_rollback`. - * @param ctx the parse tree - */ - exitStmt_rollback?: (ctx: Stmt_rollbackContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.plsql_opt_transaction_chain`. + * Enter a parse tree produced by `PostgreSqlParser.stmt_commit_or_rollback`. * @param ctx the parse tree */ - enterPlsql_opt_transaction_chain?: (ctx: Plsql_opt_transaction_chainContext) => void; + enterStmt_commit_or_rollback?: (ctx: Stmt_commit_or_rollbackContext) => void; /** - * Exit a parse tree produced by `PostgreSqlParser.plsql_opt_transaction_chain`. + * Exit a parse tree produced by `PostgreSqlParser.stmt_commit_or_rollback`. * @param ctx the parse tree */ - exitPlsql_opt_transaction_chain?: (ctx: Plsql_opt_transaction_chainContext) => void; + exitStmt_commit_or_rollback?: (ctx: Stmt_commit_or_rollbackContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.stmt_set`. * @param ctx the parse tree @@ -9634,36 +5380,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitException_sect?: (ctx: Exception_sectContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.proc_exceptions`. - * @param ctx the parse tree - */ - enterProc_exceptions?: (ctx: Proc_exceptionsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.proc_exceptions`. - * @param ctx the parse tree - */ - exitProc_exceptions?: (ctx: Proc_exceptionsContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.proc_exception`. - * @param ctx the parse tree - */ - enterProc_exception?: (ctx: Proc_exceptionContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.proc_exception`. - * @param ctx the parse tree - */ - exitProc_exception?: (ctx: Proc_exceptionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.proc_conditions`. - * @param ctx the parse tree - */ - enterProc_conditions?: (ctx: Proc_conditionsContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.proc_conditions`. - * @param ctx the parse tree - */ - exitProc_conditions?: (ctx: Proc_conditionsContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.proc_condition`. * @param ctx the parse tree @@ -9674,46 +5390,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitProc_condition?: (ctx: Proc_conditionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_block_label`. - * @param ctx the parse tree - */ - enterOpt_block_label?: (ctx: Opt_block_labelContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_block_label`. - * @param ctx the parse tree - */ - exitOpt_block_label?: (ctx: Opt_block_labelContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_loop_label`. - * @param ctx the parse tree - */ - enterOpt_loop_label?: (ctx: Opt_loop_labelContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_loop_label`. - * @param ctx the parse tree - */ - exitOpt_loop_label?: (ctx: Opt_loop_labelContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_label`. - * @param ctx the parse tree - */ - enterOpt_label?: (ctx: Opt_labelContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_label`. - * @param ctx the parse tree - */ - exitOpt_label?: (ctx: Opt_labelContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_exitcond`. - * @param ctx the parse tree - */ - enterOpt_exitcond?: (ctx: Opt_exitcondContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_exitcond`. - * @param ctx the parse tree - */ - exitOpt_exitcond?: (ctx: Opt_exitcondContext) => void; /** * Enter a parse tree produced by `PostgreSqlParser.any_identifier`. * @param ctx the parse tree @@ -9744,66 +5420,6 @@ export class PostgreSqlParserListener implements ParseTreeListener { * @param ctx the parse tree */ exitSql_expression?: (ctx: Sql_expressionContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.expr_until_then`. - * @param ctx the parse tree - */ - enterExpr_until_then?: (ctx: Expr_until_thenContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.expr_until_then`. - * @param ctx the parse tree - */ - exitExpr_until_then?: (ctx: Expr_until_thenContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.expr_until_semi`. - * @param ctx the parse tree - */ - enterExpr_until_semi?: (ctx: Expr_until_semiContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.expr_until_semi`. - * @param ctx the parse tree - */ - exitExpr_until_semi?: (ctx: Expr_until_semiContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.expr_until_rightbracket`. - * @param ctx the parse tree - */ - enterExpr_until_rightbracket?: (ctx: Expr_until_rightbracketContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.expr_until_rightbracket`. - * @param ctx the parse tree - */ - exitExpr_until_rightbracket?: (ctx: Expr_until_rightbracketContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.expr_until_loop`. - * @param ctx the parse tree - */ - enterExpr_until_loop?: (ctx: Expr_until_loopContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.expr_until_loop`. - * @param ctx the parse tree - */ - exitExpr_until_loop?: (ctx: Expr_until_loopContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.make_execsql_stmt`. - * @param ctx the parse tree - */ - enterMake_execsql_stmt?: (ctx: Make_execsql_stmtContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.make_execsql_stmt`. - * @param ctx the parse tree - */ - exitMake_execsql_stmt?: (ctx: Make_execsql_stmtContext) => void; - /** - * Enter a parse tree produced by `PostgreSqlParser.opt_returning_clause_into`. - * @param ctx the parse tree - */ - enterOpt_returning_clause_into?: (ctx: Opt_returning_clause_intoContext) => void; - /** - * Exit a parse tree produced by `PostgreSqlParser.opt_returning_clause_into`. - * @param ctx the parse tree - */ - exitOpt_returning_clause_into?: (ctx: Opt_returning_clause_intoContext) => void; visitTerminal(node: TerminalNode): void {} visitErrorNode(node: ErrorNode): void {} diff --git a/src/lib/postgresql/PostgreSqlParserVisitor.ts b/src/lib/postgresql/PostgreSqlParserVisitor.ts index 2457867d..fabf31ee 100644 --- a/src/lib/postgresql/PostgreSqlParserVisitor.ts +++ b/src/lib/postgresql/PostgreSqlParserVisitor.ts @@ -9,31 +9,22 @@ import { SQLParserBase } from '../SQLParserBase'; import { ProgramContext } from "./PostgreSqlParser.js"; -import { PlsqlrootContext } from "./PostgreSqlParser.js"; import { SingleStmtContext } from "./PostgreSqlParser.js"; import { StmtContext } from "./PostgreSqlParser.js"; -import { PlsqlconsolecommandContext } from "./PostgreSqlParser.js"; import { CallstmtContext } from "./PostgreSqlParser.js"; import { CreaterolestmtContext } from "./PostgreSqlParser.js"; -import { Opt_withContext } from "./PostgreSqlParser.js"; -import { OptrolelistContext } from "./PostgreSqlParser.js"; -import { AlteroptrolelistContext } from "./PostgreSqlParser.js"; import { AlteroptroleelemContext } from "./PostgreSqlParser.js"; import { CreateoptroleelemContext } from "./PostgreSqlParser.js"; import { CreateuserstmtContext } from "./PostgreSqlParser.js"; import { AlterrolestmtContext } from "./PostgreSqlParser.js"; -import { Opt_in_databaseContext } from "./PostgreSqlParser.js"; import { AlterrolesetstmtContext } from "./PostgreSqlParser.js"; import { AlterroutinestmtContext } from "./PostgreSqlParser.js"; import { Alter_routine_cluaseContext } from "./PostgreSqlParser.js"; -import { Routine_action_listContext } from "./PostgreSqlParser.js"; import { Routine_actionContext } from "./PostgreSqlParser.js"; import { CreategroupstmtContext } from "./PostgreSqlParser.js"; import { AltergroupstmtContext } from "./PostgreSqlParser.js"; -import { Add_dropContext } from "./PostgreSqlParser.js"; import { CreateschemastmtContext } from "./PostgreSqlParser.js"; import { SchemaNameCreateContext } from "./PostgreSqlParser.js"; -import { OptschemaeltlistContext } from "./PostgreSqlParser.js"; import { Schema_stmtContext } from "./PostgreSqlParser.js"; import { VariablesetstmtContext } from "./PostgreSqlParser.js"; import { Set_restContext } from "./PostgreSqlParser.js"; @@ -46,18 +37,13 @@ import { Iso_levelContext } from "./PostgreSqlParser.js"; import { Opt_boolean_or_string_columnContext } from "./PostgreSqlParser.js"; import { Opt_boolean_or_stringContext } from "./PostgreSqlParser.js"; import { Zone_valueContext } from "./PostgreSqlParser.js"; -import { Opt_encodingContext } from "./PostgreSqlParser.js"; -import { Nonreservedword_or_sconst_columnContext } from "./PostgreSqlParser.js"; import { Nonreservedword_or_sconstContext } from "./PostgreSqlParser.js"; import { VariableresetstmtContext } from "./PostgreSqlParser.js"; import { Reset_restContext } from "./PostgreSqlParser.js"; -import { Generic_resetContext } from "./PostgreSqlParser.js"; import { SetresetclauseContext } from "./PostgreSqlParser.js"; import { FunctionsetresetclauseContext } from "./PostgreSqlParser.js"; import { VariableshowstmtContext } from "./PostgreSqlParser.js"; import { ConstraintssetstmtContext } from "./PostgreSqlParser.js"; -import { Constraints_set_listContext } from "./PostgreSqlParser.js"; -import { Constraints_set_modeContext } from "./PostgreSqlParser.js"; import { CheckpointstmtContext } from "./PostgreSqlParser.js"; import { DiscardstmtContext } from "./PostgreSqlParser.js"; import { AltertablestmtContext } from "./PostgreSqlParser.js"; @@ -72,85 +58,45 @@ import { Alter_table_cmdContext } from "./PostgreSqlParser.js"; import { Alter_column_defaultContext } from "./PostgreSqlParser.js"; import { Opt_drop_behaviorContext } from "./PostgreSqlParser.js"; import { Opt_collate_clauseContext } from "./PostgreSqlParser.js"; -import { Alter_usingContext } from "./PostgreSqlParser.js"; -import { Replica_identityContext } from "./PostgreSqlParser.js"; import { ReloptionsContext } from "./PostgreSqlParser.js"; import { Opt_reloptionsContext } from "./PostgreSqlParser.js"; -import { Reloption_listContext } from "./PostgreSqlParser.js"; import { Reloption_elemContext } from "./PostgreSqlParser.js"; -import { Alter_identity_column_option_listContext } from "./PostgreSqlParser.js"; -import { Alter_identity_column_optionContext } from "./PostgreSqlParser.js"; import { PartitionboundspecContext } from "./PostgreSqlParser.js"; -import { Hash_partbound_elemContext } from "./PostgreSqlParser.js"; -import { Hash_partboundContext } from "./PostgreSqlParser.js"; import { AltercompositetypestmtContext } from "./PostgreSqlParser.js"; -import { Alter_type_cmdsContext } from "./PostgreSqlParser.js"; import { Alter_type_cmdContext } from "./PostgreSqlParser.js"; import { CloseportalstmtContext } from "./PostgreSqlParser.js"; import { CopystmtContext } from "./PostgreSqlParser.js"; -import { Copy_fromContext } from "./PostgreSqlParser.js"; -import { Opt_programContext } from "./PostgreSqlParser.js"; -import { Copy_file_nameContext } from "./PostgreSqlParser.js"; import { Copy_optionsContext } from "./PostgreSqlParser.js"; -import { Copy_opt_listContext } from "./PostgreSqlParser.js"; -import { Copy_opt_itemContext } from "./PostgreSqlParser.js"; -import { Opt_binaryContext } from "./PostgreSqlParser.js"; -import { Copy_delimiterContext } from "./PostgreSqlParser.js"; -import { Opt_usingContext } from "./PostgreSqlParser.js"; -import { Copy_generic_opt_listContext } from "./PostgreSqlParser.js"; import { Copy_generic_opt_elemContext } from "./PostgreSqlParser.js"; -import { Copy_generic_opt_argContext } from "./PostgreSqlParser.js"; -import { Copy_generic_opt_arg_listContext } from "./PostgreSqlParser.js"; -import { Copy_generic_opt_arg_list_itemContext } from "./PostgreSqlParser.js"; import { ColumnCreateTableContext } from "./PostgreSqlParser.js"; import { OpttempContext } from "./PostgreSqlParser.js"; -import { Table_column_listContext } from "./PostgreSqlParser.js"; -import { OpttableelementlistContext } from "./PostgreSqlParser.js"; import { OpttypedtableelementlistContext } from "./PostgreSqlParser.js"; import { TableelementlistContext } from "./PostgreSqlParser.js"; -import { TypedtableelementlistContext } from "./PostgreSqlParser.js"; import { TableelementContext } from "./PostgreSqlParser.js"; import { TypedtableelementContext } from "./PostgreSqlParser.js"; import { Column_defContext } from "./PostgreSqlParser.js"; -import { CompressionCluaseContext } from "./PostgreSqlParser.js"; -import { StorageCluaseContext } from "./PostgreSqlParser.js"; -import { ColumnOptionsContext } from "./PostgreSqlParser.js"; -import { ColquallistContext } from "./PostgreSqlParser.js"; import { ColconstraintContext } from "./PostgreSqlParser.js"; import { ColconstraintelemContext } from "./PostgreSqlParser.js"; -import { Nulls_distinctContext } from "./PostgreSqlParser.js"; import { Generated_whenContext } from "./PostgreSqlParser.js"; -import { Deferrable_triggerContext } from "./PostgreSqlParser.js"; -import { Initially_triggerContext } from "./PostgreSqlParser.js"; -import { TablelikeclauseContext } from "./PostgreSqlParser.js"; -import { TablelikeoptionlistContext } from "./PostgreSqlParser.js"; import { TablelikeoptionContext } from "./PostgreSqlParser.js"; -import { TableconstraintContext } from "./PostgreSqlParser.js"; import { ConstraintelemContext } from "./PostgreSqlParser.js"; -import { Opt_no_inheritContext } from "./PostgreSqlParser.js"; import { Opt_column_listContext } from "./PostgreSqlParser.js"; import { Opt_column_list_createContext } from "./PostgreSqlParser.js"; import { Column_listContext } from "./PostgreSqlParser.js"; -import { Column_list_createContext } from "./PostgreSqlParser.js"; import { Opt_c_includeContext } from "./PostgreSqlParser.js"; import { Key_matchContext } from "./PostgreSqlParser.js"; -import { ExclusionconstraintlistContext } from "./PostgreSqlParser.js"; import { ExclusionconstraintelemContext } from "./PostgreSqlParser.js"; -import { ExclusionwhereclauseContext } from "./PostgreSqlParser.js"; import { Key_actionsContext } from "./PostgreSqlParser.js"; import { Key_updateContext } from "./PostgreSqlParser.js"; import { Key_deleteContext } from "./PostgreSqlParser.js"; import { Key_actionContext } from "./PostgreSqlParser.js"; import { OptinheritContext } from "./PostgreSqlParser.js"; -import { OptpartitionspecContext } from "./PostgreSqlParser.js"; import { PartitionspecContext } from "./PostgreSqlParser.js"; -import { Part_paramsContext } from "./PostgreSqlParser.js"; import { Part_elemContext } from "./PostgreSqlParser.js"; import { Table_access_method_clauseContext } from "./PostgreSqlParser.js"; import { OptwithContext } from "./PostgreSqlParser.js"; import { OncommitoptionContext } from "./PostgreSqlParser.js"; import { OpttablespaceContext } from "./PostgreSqlParser.js"; -import { Index_paramenters_createContext } from "./PostgreSqlParser.js"; import { OptconstablespaceContext } from "./PostgreSqlParser.js"; import { ExistingindexContext } from "./PostgreSqlParser.js"; import { CreatestatsstmtContext } from "./PostgreSqlParser.js"; @@ -159,185 +105,93 @@ import { QueryCreateTableContext } from "./PostgreSqlParser.js"; import { Create_as_targetContext } from "./PostgreSqlParser.js"; import { Opt_with_dataContext } from "./PostgreSqlParser.js"; import { CreateMaterializedViewContext } from "./PostgreSqlParser.js"; -import { Create_mv_targetContext } from "./PostgreSqlParser.js"; -import { OptnologContext } from "./PostgreSqlParser.js"; import { RefreshmatviewstmtContext } from "./PostgreSqlParser.js"; import { CreateseqstmtContext } from "./PostgreSqlParser.js"; import { AlterseqstmtContext } from "./PostgreSqlParser.js"; -import { OptseqoptlistContext } from "./PostgreSqlParser.js"; -import { OptparenthesizedseqoptlistContext } from "./PostgreSqlParser.js"; -import { SeqoptlistContext } from "./PostgreSqlParser.js"; import { SeqoptelemContext } from "./PostgreSqlParser.js"; -import { Opt_byContext } from "./PostgreSqlParser.js"; import { NumericonlyContext } from "./PostgreSqlParser.js"; -import { Numericonly_listContext } from "./PostgreSqlParser.js"; import { CreateplangstmtContext } from "./PostgreSqlParser.js"; -import { Opt_trustedContext } from "./PostgreSqlParser.js"; -import { Handler_nameContext } from "./PostgreSqlParser.js"; -import { Opt_inline_handlerContext } from "./PostgreSqlParser.js"; -import { Validator_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_validatorContext } from "./PostgreSqlParser.js"; -import { Opt_proceduralContext } from "./PostgreSqlParser.js"; import { CreatetablespacestmtContext } from "./PostgreSqlParser.js"; -import { OpttablespaceownerContext } from "./PostgreSqlParser.js"; import { CreateextensionstmtContext } from "./PostgreSqlParser.js"; -import { Create_extension_opt_listContext } from "./PostgreSqlParser.js"; -import { Create_extension_opt_itemContext } from "./PostgreSqlParser.js"; import { AlterextensionstmtContext } from "./PostgreSqlParser.js"; -import { Alter_extension_opt_listContext } from "./PostgreSqlParser.js"; -import { Alter_extension_opt_itemContext } from "./PostgreSqlParser.js"; import { AlterextensioncontentsstmtContext } from "./PostgreSqlParser.js"; import { CreatefdwstmtContext } from "./PostgreSqlParser.js"; import { Fdw_optionContext } from "./PostgreSqlParser.js"; -import { Fdw_optionsContext } from "./PostgreSqlParser.js"; -import { Opt_fdw_optionsContext } from "./PostgreSqlParser.js"; import { AlterfdwstmtContext } from "./PostgreSqlParser.js"; import { Create_generic_optionsContext } from "./PostgreSqlParser.js"; -import { Generic_option_listContext } from "./PostgreSqlParser.js"; import { Alter_generic_optionsContext } from "./PostgreSqlParser.js"; -import { Alter_generic_option_listContext } from "./PostgreSqlParser.js"; import { Alter_generic_option_elemContext } from "./PostgreSqlParser.js"; import { Generic_option_elemContext } from "./PostgreSqlParser.js"; -import { Generic_option_nameContext } from "./PostgreSqlParser.js"; -import { Generic_option_argContext } from "./PostgreSqlParser.js"; import { CreateforeignserverstmtContext } from "./PostgreSqlParser.js"; -import { Opt_typeContext } from "./PostgreSqlParser.js"; import { Foreign_server_versionContext } from "./PostgreSqlParser.js"; -import { Opt_foreign_server_versionContext } from "./PostgreSqlParser.js"; import { AlterforeignserverstmtContext } from "./PostgreSqlParser.js"; import { CreateForeignTableContext } from "./PostgreSqlParser.js"; import { CreatePartitionForeignTableContext } from "./PostgreSqlParser.js"; import { ImportforeignschemastmtContext } from "./PostgreSqlParser.js"; -import { Import_qualification_typeContext } from "./PostgreSqlParser.js"; -import { Import_qualificationContext } from "./PostgreSqlParser.js"; import { CreateusermappingstmtContext } from "./PostgreSqlParser.js"; -import { Auth_identContext } from "./PostgreSqlParser.js"; import { AlterusermappingstmtContext } from "./PostgreSqlParser.js"; import { CreatepolicystmtContext } from "./PostgreSqlParser.js"; import { AlterpolicystmtContext } from "./PostgreSqlParser.js"; import { AlterprocedurestmtContext } from "./PostgreSqlParser.js"; -import { Procedure_cluaseContext } from "./PostgreSqlParser.js"; import { Procedure_actionContext } from "./PostgreSqlParser.js"; import { RowsecurityoptionalexprContext } from "./PostgreSqlParser.js"; import { RowsecurityoptionalwithcheckContext } from "./PostgreSqlParser.js"; -import { RowsecuritydefaulttoroleContext } from "./PostgreSqlParser.js"; -import { RowsecurityoptionaltoroleContext } from "./PostgreSqlParser.js"; -import { RowsecuritydefaultpermissiveContext } from "./PostgreSqlParser.js"; -import { RowsecuritydefaultforcmdContext } from "./PostgreSqlParser.js"; -import { Row_security_cmdContext } from "./PostgreSqlParser.js"; import { CreateamstmtContext } from "./PostgreSqlParser.js"; -import { Am_typeContext } from "./PostgreSqlParser.js"; import { CreatetrigstmtContext } from "./PostgreSqlParser.js"; import { TriggeractiontimeContext } from "./PostgreSqlParser.js"; -import { ForeachrowContext } from "./PostgreSqlParser.js"; -import { RoworstatmentContext } from "./PostgreSqlParser.js"; import { TriggereventsContext } from "./PostgreSqlParser.js"; import { TriggeroneeventContext } from "./PostgreSqlParser.js"; -import { TriggerreferencingContext } from "./PostgreSqlParser.js"; -import { TriggertransitionsContext } from "./PostgreSqlParser.js"; -import { TriggertransitionContext } from "./PostgreSqlParser.js"; -import { TransitionoldornewContext } from "./PostgreSqlParser.js"; -import { TransitionrowortableContext } from "./PostgreSqlParser.js"; -import { TransitionrelnameContext } from "./PostgreSqlParser.js"; -import { TriggerforspecContext } from "./PostgreSqlParser.js"; -import { TriggerforopteachContext } from "./PostgreSqlParser.js"; -import { TriggerfortypeContext } from "./PostgreSqlParser.js"; import { TriggerwhenContext } from "./PostgreSqlParser.js"; import { Function_or_procedureContext } from "./PostgreSqlParser.js"; import { TriggerfuncargsContext } from "./PostgreSqlParser.js"; import { TriggerfuncargContext } from "./PostgreSqlParser.js"; -import { OptconstrfromtableContext } from "./PostgreSqlParser.js"; -import { ConstraintattributespecContext } from "./PostgreSqlParser.js"; import { ConstraintattributeElemContext } from "./PostgreSqlParser.js"; import { CreateeventtrigstmtContext } from "./PostgreSqlParser.js"; -import { Event_trigger_when_listContext } from "./PostgreSqlParser.js"; import { Event_trigger_when_itemContext } from "./PostgreSqlParser.js"; -import { Event_trigger_value_listContext } from "./PostgreSqlParser.js"; import { AltereventtrigstmtContext } from "./PostgreSqlParser.js"; -import { Enable_triggerContext } from "./PostgreSqlParser.js"; import { CreateassertionstmtContext } from "./PostgreSqlParser.js"; import { DefinestmtContext } from "./PostgreSqlParser.js"; import { DefinitionContext } from "./PostgreSqlParser.js"; -import { Def_listContext } from "./PostgreSqlParser.js"; import { Def_elemContext } from "./PostgreSqlParser.js"; import { Def_argContext } from "./PostgreSqlParser.js"; -import { Old_aggr_definitionContext } from "./PostgreSqlParser.js"; -import { Old_aggr_listContext } from "./PostgreSqlParser.js"; import { Old_aggr_elemContext } from "./PostgreSqlParser.js"; -import { Opt_enum_val_listContext } from "./PostgreSqlParser.js"; -import { Enum_val_listContext } from "./PostgreSqlParser.js"; import { AlterenumstmtContext } from "./PostgreSqlParser.js"; import { Opt_if_not_existsContext } from "./PostgreSqlParser.js"; import { CreateopclassstmtContext } from "./PostgreSqlParser.js"; -import { Opclass_item_listContext } from "./PostgreSqlParser.js"; import { Opclass_itemContext } from "./PostgreSqlParser.js"; -import { Opt_defaultContext } from "./PostgreSqlParser.js"; -import { Opt_opfamilyContext } from "./PostgreSqlParser.js"; -import { Opclass_purposeContext } from "./PostgreSqlParser.js"; -import { Opt_recheckContext } from "./PostgreSqlParser.js"; import { CreateopfamilystmtContext } from "./PostgreSqlParser.js"; import { AlteropfamilystmtContext } from "./PostgreSqlParser.js"; -import { Opclass_drop_listContext } from "./PostgreSqlParser.js"; import { Opclass_dropContext } from "./PostgreSqlParser.js"; import { ReassignownedstmtContext } from "./PostgreSqlParser.js"; import { DropstmtContext } from "./PostgreSqlParser.js"; -import { View_nameListContext } from "./PostgreSqlParser.js"; import { Object_type_any_nameContext } from "./PostgreSqlParser.js"; import { Object_type_nameContext } from "./PostgreSqlParser.js"; -import { Object_type_name_on_any_nameContext } from "./PostgreSqlParser.js"; import { Any_name_listContext } from "./PostgreSqlParser.js"; -import { Relation_column_nameContext } from "./PostgreSqlParser.js"; -import { Relation_nameContext } from "./PostgreSqlParser.js"; import { Any_nameContext } from "./PostgreSqlParser.js"; import { AttrsContext } from "./PostgreSqlParser.js"; -import { Type_name_listContext } from "./PostgreSqlParser.js"; import { TruncatestmtContext } from "./PostgreSqlParser.js"; import { Truncate_tableContext } from "./PostgreSqlParser.js"; import { CommentstmtContext } from "./PostgreSqlParser.js"; -import { Comment_textContext } from "./PostgreSqlParser.js"; import { SeclabelstmtContext } from "./PostgreSqlParser.js"; -import { Opt_providerContext } from "./PostgreSqlParser.js"; -import { Security_labelContext } from "./PostgreSqlParser.js"; import { FetchstmtContext } from "./PostgreSqlParser.js"; import { Fetch_argsContext } from "./PostgreSqlParser.js"; import { From_inContext } from "./PostgreSqlParser.js"; -import { Opt_from_inContext } from "./PostgreSqlParser.js"; import { GrantstmtContext } from "./PostgreSqlParser.js"; import { RevokestmtContext } from "./PostgreSqlParser.js"; import { PrivilegesContext } from "./PostgreSqlParser.js"; -import { BeforeprivilegeselectlistContext } from "./PostgreSqlParser.js"; import { BeforeprivilegeselectContext } from "./PostgreSqlParser.js"; -import { Privilege_listContext } from "./PostgreSqlParser.js"; import { PrivilegeContext } from "./PostgreSqlParser.js"; import { Privilege_targetContext } from "./PostgreSqlParser.js"; import { Grantee_listContext } from "./PostgreSqlParser.js"; -import { GranteeContext } from "./PostgreSqlParser.js"; -import { Opt_grant_grant_optionContext } from "./PostgreSqlParser.js"; import { GrantrolestmtContext } from "./PostgreSqlParser.js"; import { RevokerolestmtContext } from "./PostgreSqlParser.js"; -import { Opt_grant_admin_optionContext } from "./PostgreSqlParser.js"; -import { Opt_granted_byContext } from "./PostgreSqlParser.js"; import { AlterdefaultprivilegesstmtContext } from "./PostgreSqlParser.js"; -import { DefacloptionlistContext } from "./PostgreSqlParser.js"; -import { DefacloptionContext } from "./PostgreSqlParser.js"; import { DefaclactionContext } from "./PostgreSqlParser.js"; import { Defacl_privilege_targetContext } from "./PostgreSqlParser.js"; import { IndexstmtContext } from "./PostgreSqlParser.js"; -import { Opt_uniqueContext } from "./PostgreSqlParser.js"; -import { Opt_concurrentlyContext } from "./PostgreSqlParser.js"; -import { Opt_index_nameContext } from "./PostgreSqlParser.js"; -import { Access_method_clauseContext } from "./PostgreSqlParser.js"; import { Index_paramsContext } from "./PostgreSqlParser.js"; -import { Index_elem_optionsContext } from "./PostgreSqlParser.js"; import { Index_elemContext } from "./PostgreSqlParser.js"; -import { Opt_includeContext } from "./PostgreSqlParser.js"; -import { Index_including_paramsContext } from "./PostgreSqlParser.js"; -import { Opt_collateContext } from "./PostgreSqlParser.js"; -import { Opt_classContext } from "./PostgreSqlParser.js"; -import { Opt_asc_descContext } from "./PostgreSqlParser.js"; -import { Opt_nulls_orderContext } from "./PostgreSqlParser.js"; import { CreatefunctionstmtContext } from "./PostgreSqlParser.js"; -import { AttrilistContext } from "./PostgreSqlParser.js"; import { Opt_or_replaceContext } from "./PostgreSqlParser.js"; import { Func_argsContext } from "./PostgreSqlParser.js"; import { Func_args_listContext } from "./PostgreSqlParser.js"; @@ -347,77 +201,44 @@ import { Procedure_with_argtypes_listContext } from "./PostgreSqlParser.js"; import { Procedure_with_argtypesContext } from "./PostgreSqlParser.js"; import { Function_with_argtypes_listContext } from "./PostgreSqlParser.js"; import { Function_with_argtypesContext } from "./PostgreSqlParser.js"; -import { Func_args_with_defaultsContext } from "./PostgreSqlParser.js"; -import { Func_args_with_defaults_listContext } from "./PostgreSqlParser.js"; import { Func_argContext } from "./PostgreSqlParser.js"; import { Arg_classContext } from "./PostgreSqlParser.js"; -import { Param_nameContext } from "./PostgreSqlParser.js"; -import { Func_returnContext } from "./PostgreSqlParser.js"; import { Func_typeContext } from "./PostgreSqlParser.js"; import { Func_arg_with_defaultContext } from "./PostgreSqlParser.js"; -import { Aggr_argContext } from "./PostgreSqlParser.js"; import { Aggr_argsContext } from "./PostgreSqlParser.js"; -import { Aggr_args_listContext } from "./PostgreSqlParser.js"; import { Aggregate_with_argtypesContext } from "./PostgreSqlParser.js"; -import { Aggregate_with_argtypes_listContext } from "./PostgreSqlParser.js"; -import { Createfunc_opt_listContext } from "./PostgreSqlParser.js"; import { Common_func_opt_itemContext } from "./PostgreSqlParser.js"; import { Createfunc_opt_itemContext } from "./PostgreSqlParser.js"; -import { Transform_type_listContext } from "./PostgreSqlParser.js"; import { Opt_definitionContext } from "./PostgreSqlParser.js"; import { Table_func_columnContext } from "./PostgreSqlParser.js"; -import { Table_func_column_listContext } from "./PostgreSqlParser.js"; import { AlterfunctionstmtContext } from "./PostgreSqlParser.js"; -import { AlterFunctionTypeClauseContext } from "./PostgreSqlParser.js"; -import { Alterfunc_opt_listContext } from "./PostgreSqlParser.js"; -import { Opt_restrictContext } from "./PostgreSqlParser.js"; import { RemovefuncstmtContext } from "./PostgreSqlParser.js"; import { RemoveaggrstmtContext } from "./PostgreSqlParser.js"; import { RemoveoperstmtContext } from "./PostgreSqlParser.js"; import { Oper_argtypesContext } from "./PostgreSqlParser.js"; import { Any_operatorContext } from "./PostgreSqlParser.js"; -import { Operator_with_argtypes_listContext } from "./PostgreSqlParser.js"; import { Operator_with_argtypesContext } from "./PostgreSqlParser.js"; import { DostmtContext } from "./PostgreSqlParser.js"; -import { Dostmt_opt_listContext } from "./PostgreSqlParser.js"; -import { Dostmt_opt_itemContext } from "./PostgreSqlParser.js"; import { CreatecaststmtContext } from "./PostgreSqlParser.js"; -import { Cast_contextContext } from "./PostgreSqlParser.js"; import { Opt_if_existsContext } from "./PostgreSqlParser.js"; import { CreatetransformstmtContext } from "./PostgreSqlParser.js"; -import { Transform_element_listContext } from "./PostgreSqlParser.js"; +import { Sql_with_functionContext } from "./PostgreSqlParser.js"; import { ReindexstmtContext } from "./PostgreSqlParser.js"; -import { Reindex_target_typeContext } from "./PostgreSqlParser.js"; -import { Reindex_target_multitableContext } from "./PostgreSqlParser.js"; -import { Reindex_option_listContext } from "./PostgreSqlParser.js"; -import { Reindex_option_elemContext } from "./PostgreSqlParser.js"; import { AltertblspcstmtContext } from "./PostgreSqlParser.js"; import { RenamestmtContext } from "./PostgreSqlParser.js"; -import { Opt_set_dataContext } from "./PostgreSqlParser.js"; import { AlterobjectdependsstmtContext } from "./PostgreSqlParser.js"; -import { Opt_noContext } from "./PostgreSqlParser.js"; import { AlterobjectschemastmtContext } from "./PostgreSqlParser.js"; import { AlteroperatorstmtContext } from "./PostgreSqlParser.js"; import { Operator_def_listContext } from "./PostgreSqlParser.js"; import { Operator_def_elemContext } from "./PostgreSqlParser.js"; -import { Operator_def_argContext } from "./PostgreSqlParser.js"; import { AltertypestmtContext } from "./PostgreSqlParser.js"; import { AlterownerstmtContext } from "./PostgreSqlParser.js"; import { CreatepublicationstmtContext } from "./PostgreSqlParser.js"; -import { Opt_publication_for_tablesContext } from "./PostgreSqlParser.js"; -import { Publication_for_tablesContext } from "./PostgreSqlParser.js"; import { AlterpublicationstmtContext } from "./PostgreSqlParser.js"; import { CreatesubscriptionstmtContext } from "./PostgreSqlParser.js"; -import { Publication_name_listContext } from "./PostgreSqlParser.js"; -import { Publication_name_itemContext } from "./PostgreSqlParser.js"; import { AltersubscriptionstmtContext } from "./PostgreSqlParser.js"; import { RulestmtContext } from "./PostgreSqlParser.js"; -import { RuleactionlistContext } from "./PostgreSqlParser.js"; -import { RuleactionmultiContext } from "./PostgreSqlParser.js"; import { RuleactionstmtContext } from "./PostgreSqlParser.js"; -import { RuleactionstmtOrEmptyContext } from "./PostgreSqlParser.js"; -import { EventContext } from "./PostgreSqlParser.js"; -import { Opt_insteadContext } from "./PostgreSqlParser.js"; import { NotifystmtContext } from "./PostgreSqlParser.js"; import { Notify_payloadContext } from "./PostgreSqlParser.js"; import { ListenstmtContext } from "./PostgreSqlParser.js"; @@ -426,58 +247,31 @@ import { TransactionstmtContext } from "./PostgreSqlParser.js"; import { Opt_transactionContext } from "./PostgreSqlParser.js"; import { Transaction_mode_itemContext } from "./PostgreSqlParser.js"; import { Transaction_mode_listContext } from "./PostgreSqlParser.js"; -import { Transaction_mode_list_or_emptyContext } from "./PostgreSqlParser.js"; -import { Opt_transaction_chainContext } from "./PostgreSqlParser.js"; import { CreateViewContext } from "./PostgreSqlParser.js"; -import { Opt_check_optionContext } from "./PostgreSqlParser.js"; import { LoadstmtContext } from "./PostgreSqlParser.js"; import { CreateDatabaseContext } from "./PostgreSqlParser.js"; -import { Createdb_opt_listContext } from "./PostgreSqlParser.js"; -import { Createdb_opt_itemsContext } from "./PostgreSqlParser.js"; import { Createdb_opt_itemContext } from "./PostgreSqlParser.js"; -import { Createdb_opt_nameContext } from "./PostgreSqlParser.js"; -import { Opt_equalContext } from "./PostgreSqlParser.js"; import { AlterdatabasestmtContext } from "./PostgreSqlParser.js"; import { AlterdatabasesetstmtContext } from "./PostgreSqlParser.js"; -import { Drop_option_listContext } from "./PostgreSqlParser.js"; -import { Drop_optionContext } from "./PostgreSqlParser.js"; import { AltercollationstmtContext } from "./PostgreSqlParser.js"; import { AltersystemstmtContext } from "./PostgreSqlParser.js"; import { CreatedomainstmtContext } from "./PostgreSqlParser.js"; import { AlterdomainstmtContext } from "./PostgreSqlParser.js"; -import { Opt_asContext } from "./PostgreSqlParser.js"; import { AltertsdictionarystmtContext } from "./PostgreSqlParser.js"; import { AltertsconfigurationstmtContext } from "./PostgreSqlParser.js"; -import { Any_withContext } from "./PostgreSqlParser.js"; import { CreateconversionstmtContext } from "./PostgreSqlParser.js"; import { ClusterstmtContext } from "./PostgreSqlParser.js"; -import { Opt_verbose_listContext } from "./PostgreSqlParser.js"; -import { Cluster_index_specificationContext } from "./PostgreSqlParser.js"; import { VacuumstmtContext } from "./PostgreSqlParser.js"; import { AnalyzestmtContext } from "./PostgreSqlParser.js"; -import { Vac_analyze_option_listContext } from "./PostgreSqlParser.js"; import { Analyze_keywordContext } from "./PostgreSqlParser.js"; import { Vac_analyze_option_elemContext } from "./PostgreSqlParser.js"; -import { Vac_analyze_option_nameContext } from "./PostgreSqlParser.js"; -import { Vac_analyze_option_argContext } from "./PostgreSqlParser.js"; -import { Opt_analyzeContext } from "./PostgreSqlParser.js"; -import { Analyze_options_listContext } from "./PostgreSqlParser.js"; import { Analyze_option_elemContext } from "./PostgreSqlParser.js"; import { Opt_verboseContext } from "./PostgreSqlParser.js"; -import { Opt_skiplockContext } from "./PostgreSqlParser.js"; -import { Opt_buffer_usage_limitContext } from "./PostgreSqlParser.js"; -import { Opt_fullContext } from "./PostgreSqlParser.js"; -import { Opt_freezeContext } from "./PostgreSqlParser.js"; -import { Opt_name_listContext } from "./PostgreSqlParser.js"; import { Vacuum_relationContext } from "./PostgreSqlParser.js"; import { Vacuum_relation_listContext } from "./PostgreSqlParser.js"; -import { Opt_vacuum_relation_listContext } from "./PostgreSqlParser.js"; import { ExplainstmtContext } from "./PostgreSqlParser.js"; import { ExplainablestmtContext } from "./PostgreSqlParser.js"; import { Explain_option_listContext } from "./PostgreSqlParser.js"; -import { Explain_option_elemContext } from "./PostgreSqlParser.js"; -import { Explain_option_nameContext } from "./PostgreSqlParser.js"; -import { Explain_option_argContext } from "./PostgreSqlParser.js"; import { PreparestmtContext } from "./PostgreSqlParser.js"; import { Prep_type_clauseContext } from "./PostgreSqlParser.js"; import { PreparablestmtContext } from "./PostgreSqlParser.js"; @@ -485,192 +279,108 @@ import { ExecutestmtContext } from "./PostgreSqlParser.js"; import { Execute_param_clauseContext } from "./PostgreSqlParser.js"; import { DeallocatestmtContext } from "./PostgreSqlParser.js"; import { InsertStatementContext } from "./PostgreSqlParser.js"; -import { Insert_targetContext } from "./PostgreSqlParser.js"; import { Insert_restContext } from "./PostgreSqlParser.js"; -import { Override_kindContext } from "./PostgreSqlParser.js"; import { Insert_column_listContext } from "./PostgreSqlParser.js"; import { Insert_column_itemContext } from "./PostgreSqlParser.js"; -import { Opt_on_conflictContext } from "./PostgreSqlParser.js"; -import { Opt_conf_exprContext } from "./PostgreSqlParser.js"; import { Returning_clauseContext } from "./PostgreSqlParser.js"; import { DeletestmtContext } from "./PostgreSqlParser.js"; -import { Using_clauseContext } from "./PostgreSqlParser.js"; import { LockstmtContext } from "./PostgreSqlParser.js"; -import { Opt_lockContext } from "./PostgreSqlParser.js"; -import { Lock_typeContext } from "./PostgreSqlParser.js"; -import { Opt_nowaitContext } from "./PostgreSqlParser.js"; -import { Opt_nowait_or_skipContext } from "./PostgreSqlParser.js"; import { UpdatestmtContext } from "./PostgreSqlParser.js"; import { Set_clause_listContext } from "./PostgreSqlParser.js"; import { Set_clauseContext } from "./PostgreSqlParser.js"; -import { Set_targetContext } from "./PostgreSqlParser.js"; -import { Set_target_listContext } from "./PostgreSqlParser.js"; import { DeclarecursorstmtContext } from "./PostgreSqlParser.js"; -import { Cursor_nameContext } from "./PostgreSqlParser.js"; -import { Cursor_optionsContext } from "./PostgreSqlParser.js"; -import { Opt_holdContext } from "./PostgreSqlParser.js"; import { SelectStatementContext } from "./PostgreSqlParser.js"; import { Select_with_parensContext } from "./PostgreSqlParser.js"; import { Select_no_parensContext } from "./PostgreSqlParser.js"; import { Select_clauseContext } from "./PostgreSqlParser.js"; import { Simple_selectContext } from "./PostgreSqlParser.js"; -import { UnionContext } from "./PostgreSqlParser.js"; -import { IntersectContext } from "./PostgreSqlParser.js"; -import { ExceptContext } from "./PostgreSqlParser.js"; import { Set_operator_with_all_or_distinctContext } from "./PostgreSqlParser.js"; import { With_clauseContext } from "./PostgreSqlParser.js"; -import { Cte_listContext } from "./PostgreSqlParser.js"; import { Common_table_exprContext } from "./PostgreSqlParser.js"; import { Search_cluaseContext } from "./PostgreSqlParser.js"; import { Cycle_cluaseContext } from "./PostgreSqlParser.js"; -import { Opt_materializedContext } from "./PostgreSqlParser.js"; -import { Opt_with_clauseContext } from "./PostgreSqlParser.js"; import { Into_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_strictContext } from "./PostgreSqlParser.js"; import { OpttempTableNameContext } from "./PostgreSqlParser.js"; -import { Opt_tableContext } from "./PostgreSqlParser.js"; -import { All_or_distinctContext } from "./PostgreSqlParser.js"; import { Distinct_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_all_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_sort_clauseContext } from "./PostgreSqlParser.js"; import { Sort_clauseContext } from "./PostgreSqlParser.js"; -import { Sortby_listContext } from "./PostgreSqlParser.js"; import { SortbyContext } from "./PostgreSqlParser.js"; import { Select_limitContext } from "./PostgreSqlParser.js"; -import { Opt_select_limitContext } from "./PostgreSqlParser.js"; import { Limit_clauseContext } from "./PostgreSqlParser.js"; import { Fetch_clauseContext } from "./PostgreSqlParser.js"; import { Offset_clauseContext } from "./PostgreSqlParser.js"; -import { Select_limit_valueContext } from "./PostgreSqlParser.js"; -import { Select_offset_valueContext } from "./PostgreSqlParser.js"; import { Select_fetch_first_valueContext } from "./PostgreSqlParser.js"; -import { I_or_f_constContext } from "./PostgreSqlParser.js"; -import { Row_or_rowsContext } from "./PostgreSqlParser.js"; -import { First_or_nextContext } from "./PostgreSqlParser.js"; import { Group_clauseContext } from "./PostgreSqlParser.js"; import { Group_by_listContext } from "./PostgreSqlParser.js"; import { Group_by_itemContext } from "./PostgreSqlParser.js"; -import { Empty_grouping_setContext } from "./PostgreSqlParser.js"; -import { Rollup_clauseContext } from "./PostgreSqlParser.js"; -import { Cube_clauseContext } from "./PostgreSqlParser.js"; -import { Grouping_sets_clauseContext } from "./PostgreSqlParser.js"; -import { Having_clauseContext } from "./PostgreSqlParser.js"; import { For_locking_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_for_locking_clauseContext } from "./PostgreSqlParser.js"; -import { For_locking_itemsContext } from "./PostgreSqlParser.js"; -import { For_locking_itemContext } from "./PostgreSqlParser.js"; -import { For_locking_strengthContext } from "./PostgreSqlParser.js"; -import { Locked_rels_listContext } from "./PostgreSqlParser.js"; import { Values_clauseContext } from "./PostgreSqlParser.js"; import { From_clauseContext } from "./PostgreSqlParser.js"; import { From_listContext } from "./PostgreSqlParser.js"; import { Table_refContext } from "./PostgreSqlParser.js"; import { Alias_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_alias_clauseContext } from "./PostgreSqlParser.js"; import { Func_alias_clauseContext } from "./PostgreSqlParser.js"; import { Join_typeContext } from "./PostgreSqlParser.js"; import { Join_qualContext } from "./PostgreSqlParser.js"; import { Relation_exprContext } from "./PostgreSqlParser.js"; -import { View_relation_exprContext } from "./PostgreSqlParser.js"; import { Publication_relation_exprContext } from "./PostgreSqlParser.js"; import { Relation_expr_listContext } from "./PostgreSqlParser.js"; -import { Publication_relation_expr_listContext } from "./PostgreSqlParser.js"; import { Relation_expr_opt_aliasContext } from "./PostgreSqlParser.js"; import { Tablesample_clauseContext } from "./PostgreSqlParser.js"; -import { Opt_repeatable_clauseContext } from "./PostgreSqlParser.js"; import { Func_tableContext } from "./PostgreSqlParser.js"; import { Rowsfrom_itemContext } from "./PostgreSqlParser.js"; -import { Rowsfrom_listContext } from "./PostgreSqlParser.js"; -import { Opt_col_def_listContext } from "./PostgreSqlParser.js"; -import { Opt_ordinalityContext } from "./PostgreSqlParser.js"; import { Where_clauseContext } from "./PostgreSqlParser.js"; import { Where_or_current_clauseContext } from "./PostgreSqlParser.js"; -import { OpttablefuncelementlistContext } from "./PostgreSqlParser.js"; import { TablefuncelementlistContext } from "./PostgreSqlParser.js"; import { TablefuncelementContext } from "./PostgreSqlParser.js"; import { XmltableContext } from "./PostgreSqlParser.js"; -import { Xmltable_column_listContext } from "./PostgreSqlParser.js"; import { Xmltable_column_elContext } from "./PostgreSqlParser.js"; -import { Xmltable_column_option_listContext } from "./PostgreSqlParser.js"; -import { Xmltable_column_option_elContext } from "./PostgreSqlParser.js"; -import { Xml_namespace_listContext } from "./PostgreSqlParser.js"; import { Xml_namespace_elContext } from "./PostgreSqlParser.js"; import { TypenameContext } from "./PostgreSqlParser.js"; -import { Opt_array_boundsContext } from "./PostgreSqlParser.js"; import { SimpletypenameContext } from "./PostgreSqlParser.js"; import { ConsttypenameContext } from "./PostgreSqlParser.js"; -import { GenerictypeContext } from "./PostgreSqlParser.js"; -import { Opt_type_modifiersContext } from "./PostgreSqlParser.js"; import { NumericContext } from "./PostgreSqlParser.js"; import { Opt_floatContext } from "./PostgreSqlParser.js"; import { BitContext } from "./PostgreSqlParser.js"; -import { ConstbitContext } from "./PostgreSqlParser.js"; -import { BitwithlengthContext } from "./PostgreSqlParser.js"; -import { BitwithoutlengthContext } from "./PostgreSqlParser.js"; import { CharacterContext } from "./PostgreSqlParser.js"; -import { ConstcharacterContext } from "./PostgreSqlParser.js"; -import { Character_cContext } from "./PostgreSqlParser.js"; -import { Opt_varyingContext } from "./PostgreSqlParser.js"; import { ConstdatetimeContext } from "./PostgreSqlParser.js"; -import { ConstintervalContext } from "./PostgreSqlParser.js"; -import { Opt_timezoneContext } from "./PostgreSqlParser.js"; import { Opt_intervalContext } from "./PostgreSqlParser.js"; import { Interval_secondContext } from "./PostgreSqlParser.js"; -import { Opt_escapeContext } from "./PostgreSqlParser.js"; -import { A_exprContext } from "./PostgreSqlParser.js"; -import { A_expr_qualContext } from "./PostgreSqlParser.js"; -import { A_expr_lesslessContext } from "./PostgreSqlParser.js"; -import { A_expr_orContext } from "./PostgreSqlParser.js"; -import { A_expr_andContext } from "./PostgreSqlParser.js"; -import { A_expr_inContext } from "./PostgreSqlParser.js"; -import { A_expr_unary_notContext } from "./PostgreSqlParser.js"; -import { A_expr_isnullContext } from "./PostgreSqlParser.js"; -import { A_expr_is_notContext } from "./PostgreSqlParser.js"; -import { A_expr_compareContext } from "./PostgreSqlParser.js"; -import { A_expr_likeContext } from "./PostgreSqlParser.js"; -import { A_expr_qual_opContext } from "./PostgreSqlParser.js"; -import { A_expr_unary_qualopContext } from "./PostgreSqlParser.js"; -import { A_expr_addContext } from "./PostgreSqlParser.js"; -import { A_expr_mulContext } from "./PostgreSqlParser.js"; -import { A_expr_caretContext } from "./PostgreSqlParser.js"; -import { A_expr_unary_signContext } from "./PostgreSqlParser.js"; -import { A_expr_at_time_zoneContext } from "./PostgreSqlParser.js"; -import { A_expr_collateContext } from "./PostgreSqlParser.js"; -import { A_expr_typecastContext } from "./PostgreSqlParser.js"; -import { B_exprContext } from "./PostgreSqlParser.js"; -import { C_expr_existsContext } from "./PostgreSqlParser.js"; -import { C_expr_exprContext } from "./PostgreSqlParser.js"; -import { C_expr_caseContext } from "./PostgreSqlParser.js"; -import { PlsqlvariablenameContext } from "./PostgreSqlParser.js"; +import { ComparisonOperatorContext } from "./PostgreSqlParser.js"; +import { ExpressionContext } from "./PostgreSqlParser.js"; +import { LogicalNotContext } from "./PostgreSqlParser.js"; +import { PredicatedContext } from "./PostgreSqlParser.js"; +import { LogicalBinaryContext } from "./PostgreSqlParser.js"; +import { ComparisonContext } from "./PostgreSqlParser.js"; +import { QuantifiedComparisonContext } from "./PostgreSqlParser.js"; +import { BetweenContext } from "./PostgreSqlParser.js"; +import { InListContext } from "./PostgreSqlParser.js"; +import { InSubqueryContext } from "./PostgreSqlParser.js"; +import { LikeContext } from "./PostgreSqlParser.js"; +import { NullPredicateContext } from "./PostgreSqlParser.js"; +import { DistinctFromContext } from "./PostgreSqlParser.js"; +import { ValueExpressionDefaultContext } from "./PostgreSqlParser.js"; +import { ConcatenationContext } from "./PostgreSqlParser.js"; +import { ArithmeticBinaryContext } from "./PostgreSqlParser.js"; +import { ArithmeticUnaryContext } from "./PostgreSqlParser.js"; +import { AtTimeZoneContext } from "./PostgreSqlParser.js"; +import { PrimaryExpressionContext } from "./PostgreSqlParser.js"; import { Func_applicationContext } from "./PostgreSqlParser.js"; import { Func_exprContext } from "./PostgreSqlParser.js"; import { Func_expr_windowlessContext } from "./PostgreSqlParser.js"; import { Func_expr_common_subexprContext } from "./PostgreSqlParser.js"; -import { Xml_root_versionContext } from "./PostgreSqlParser.js"; -import { Opt_xml_root_standaloneContext } from "./PostgreSqlParser.js"; -import { Xml_attributesContext } from "./PostgreSqlParser.js"; import { Xml_attribute_listContext } from "./PostgreSqlParser.js"; import { Xml_attribute_elContext } from "./PostgreSqlParser.js"; import { Document_or_contentContext } from "./PostgreSqlParser.js"; -import { Xml_whitespace_optionContext } from "./PostgreSqlParser.js"; import { Xmlexists_argumentContext } from "./PostgreSqlParser.js"; import { Xml_passing_mechContext } from "./PostgreSqlParser.js"; -import { Within_group_clauseContext } from "./PostgreSqlParser.js"; -import { Filter_clauseContext } from "./PostgreSqlParser.js"; import { Window_clauseContext } from "./PostgreSqlParser.js"; -import { Window_definition_listContext } from "./PostgreSqlParser.js"; import { Window_definitionContext } from "./PostgreSqlParser.js"; import { Over_clauseContext } from "./PostgreSqlParser.js"; import { Window_specificationContext } from "./PostgreSqlParser.js"; -import { Opt_existing_window_nameContext } from "./PostgreSqlParser.js"; -import { Opt_partition_clauseContext } from "./PostgreSqlParser.js"; import { Opt_frame_clauseContext } from "./PostgreSqlParser.js"; -import { Frame_extentContext } from "./PostgreSqlParser.js"; import { Frame_boundContext } from "./PostgreSqlParser.js"; -import { Opt_window_exclusion_clauseContext } from "./PostgreSqlParser.js"; import { RowContext } from "./PostgreSqlParser.js"; import { Explicit_rowContext } from "./PostgreSqlParser.js"; -import { Implicit_rowContext } from "./PostgreSqlParser.js"; import { Sub_typeContext } from "./PostgreSqlParser.js"; import { All_opContext } from "./PostgreSqlParser.js"; import { MathopContext } from "./PostgreSqlParser.js"; @@ -678,35 +388,18 @@ import { Qual_opContext } from "./PostgreSqlParser.js"; import { Qual_all_opContext } from "./PostgreSqlParser.js"; import { Subquery_OpContext } from "./PostgreSqlParser.js"; import { Expr_listContext } from "./PostgreSqlParser.js"; -import { Column_expr_list_noparenContext } from "./PostgreSqlParser.js"; -import { Column_expr_listContext } from "./PostgreSqlParser.js"; import { Column_exprContext } from "./PostgreSqlParser.js"; import { Column_expr_noparenContext } from "./PostgreSqlParser.js"; import { Func_arg_listContext } from "./PostgreSqlParser.js"; import { Func_arg_exprContext } from "./PostgreSqlParser.js"; -import { Type_listContext } from "./PostgreSqlParser.js"; import { Array_exprContext } from "./PostgreSqlParser.js"; -import { Array_expr_listContext } from "./PostgreSqlParser.js"; -import { Extract_listContext } from "./PostgreSqlParser.js"; import { Extract_argContext } from "./PostgreSqlParser.js"; import { Unicode_normal_formContext } from "./PostgreSqlParser.js"; -import { Overlay_listContext } from "./PostgreSqlParser.js"; -import { Position_listContext } from "./PostgreSqlParser.js"; import { Substr_listContext } from "./PostgreSqlParser.js"; -import { Trim_listContext } from "./PostgreSqlParser.js"; -import { In_expr_selectContext } from "./PostgreSqlParser.js"; -import { In_expr_listContext } from "./PostgreSqlParser.js"; -import { Case_exprContext } from "./PostgreSqlParser.js"; -import { When_clause_listContext } from "./PostgreSqlParser.js"; import { When_clauseContext } from "./PostgreSqlParser.js"; -import { Case_defaultContext } from "./PostgreSqlParser.js"; -import { Case_argContext } from "./PostgreSqlParser.js"; -import { ColumnrefContext } from "./PostgreSqlParser.js"; import { Indirection_elContext } from "./PostgreSqlParser.js"; -import { Opt_slice_boundContext } from "./PostgreSqlParser.js"; import { IndirectionContext } from "./PostgreSqlParser.js"; import { Opt_indirectionContext } from "./PostgreSqlParser.js"; -import { Opt_target_listContext } from "./PostgreSqlParser.js"; import { Target_listContext } from "./PostgreSqlParser.js"; import { Target_labelContext } from "./PostgreSqlParser.js"; import { Target_starContext } from "./PostgreSqlParser.js"; @@ -714,7 +407,6 @@ import { Qualified_name_listContext } from "./PostgreSqlParser.js"; import { Table_name_listContext } from "./PostgreSqlParser.js"; import { Schema_name_listContext } from "./PostgreSqlParser.js"; import { Database_nameListContext } from "./PostgreSqlParser.js"; -import { Procedure_name_listContext } from "./PostgreSqlParser.js"; import { TablespaceNameCreateContext } from "./PostgreSqlParser.js"; import { TablespaceNameContext } from "./PostgreSqlParser.js"; import { TableNameCreateContext } from "./PostgreSqlParser.js"; @@ -734,163 +426,71 @@ import { ProcedureNameCreateContext } from "./PostgreSqlParser.js"; import { ColumnNameContext } from "./PostgreSqlParser.js"; import { ColumnNameMatchContext } from "./PostgreSqlParser.js"; import { ColumnNameCreateContext } from "./PostgreSqlParser.js"; -import { NameContext } from "./PostgreSqlParser.js"; -import { Attr_nameContext } from "./PostgreSqlParser.js"; -import { File_nameContext } from "./PostgreSqlParser.js"; import { FunctionNameCreateContext } from "./PostgreSqlParser.js"; import { FunctionNameContext } from "./PostgreSqlParser.js"; -import { Usual_nameContext } from "./PostgreSqlParser.js"; -import { AexprconstContext } from "./PostgreSqlParser.js"; -import { XconstContext } from "./PostgreSqlParser.js"; -import { BconstContext } from "./PostgreSqlParser.js"; -import { FconstContext } from "./PostgreSqlParser.js"; -import { IconstContext } from "./PostgreSqlParser.js"; import { SconstContext } from "./PostgreSqlParser.js"; import { AnysconstContext } from "./PostgreSqlParser.js"; -import { Opt_uescapeContext } from "./PostgreSqlParser.js"; import { SignediconstContext } from "./PostgreSqlParser.js"; -import { GroupnameContext } from "./PostgreSqlParser.js"; -import { RoleidContext } from "./PostgreSqlParser.js"; import { RolespecContext } from "./PostgreSqlParser.js"; import { Role_listContext } from "./PostgreSqlParser.js"; import { ColidContext } from "./PostgreSqlParser.js"; -import { Index_method_choicesContext } from "./PostgreSqlParser.js"; -import { Exclude_elementContext } from "./PostgreSqlParser.js"; -import { Index_paramentersContext } from "./PostgreSqlParser.js"; import { Type_function_nameContext } from "./PostgreSqlParser.js"; -import { Type_usual_nameContext } from "./PostgreSqlParser.js"; -import { Nonreservedword_columnContext } from "./PostgreSqlParser.js"; import { NonreservedwordContext } from "./PostgreSqlParser.js"; import { CollabelContext } from "./PostgreSqlParser.js"; import { IdentifierContext } from "./PostgreSqlParser.js"; -import { PlsqlidentifierContext } from "./PostgreSqlParser.js"; import { Unreserved_keywordContext } from "./PostgreSqlParser.js"; import { Col_name_keywordContext } from "./PostgreSqlParser.js"; import { Type_func_name_keywordContext } from "./PostgreSqlParser.js"; import { Reserved_keywordContext } from "./PostgreSqlParser.js"; -import { Pl_functionContext } from "./PostgreSqlParser.js"; -import { Comp_optionsContext } from "./PostgreSqlParser.js"; -import { Comp_optionContext } from "./PostgreSqlParser.js"; -import { SharpContext } from "./PostgreSqlParser.js"; -import { Option_valueContext } from "./PostgreSqlParser.js"; -import { Opt_semiContext } from "./PostgreSqlParser.js"; import { Pl_blockContext } from "./PostgreSqlParser.js"; -import { Decl_sectContext } from "./PostgreSqlParser.js"; -import { Decl_startContext } from "./PostgreSqlParser.js"; -import { Decl_stmtsContext } from "./PostgreSqlParser.js"; import { Label_declContext } from "./PostgreSqlParser.js"; -import { Decl_stmtContext } from "./PostgreSqlParser.js"; import { Decl_statementContext } from "./PostgreSqlParser.js"; -import { Opt_scrollableContext } from "./PostgreSqlParser.js"; -import { Decl_cursor_queryContext } from "./PostgreSqlParser.js"; -import { Decl_cursor_argsContext } from "./PostgreSqlParser.js"; -import { Decl_cursor_arglistContext } from "./PostgreSqlParser.js"; import { Decl_cursor_argContext } from "./PostgreSqlParser.js"; -import { Decl_is_forContext } from "./PostgreSqlParser.js"; -import { Decl_aliasitemContext } from "./PostgreSqlParser.js"; -import { Decl_varnameContext } from "./PostgreSqlParser.js"; -import { Decl_constContext } from "./PostgreSqlParser.js"; -import { Decl_datatypeContext } from "./PostgreSqlParser.js"; -import { Decl_collateContext } from "./PostgreSqlParser.js"; -import { Decl_notnullContext } from "./PostgreSqlParser.js"; -import { Decl_defvalContext } from "./PostgreSqlParser.js"; -import { Decl_defkeyContext } from "./PostgreSqlParser.js"; import { Assign_operatorContext } from "./PostgreSqlParser.js"; -import { Proc_sectContext } from "./PostgreSqlParser.js"; import { Proc_stmtContext } from "./PostgreSqlParser.js"; import { Stmt_performContext } from "./PostgreSqlParser.js"; import { Stmt_callContext } from "./PostgreSqlParser.js"; -import { Opt_expr_listContext } from "./PostgreSqlParser.js"; import { Stmt_assignContext } from "./PostgreSqlParser.js"; import { Stmt_getdiagContext } from "./PostgreSqlParser.js"; -import { Getdiag_area_optContext } from "./PostgreSqlParser.js"; -import { Getdiag_listContext } from "./PostgreSqlParser.js"; import { Getdiag_list_itemContext } from "./PostgreSqlParser.js"; -import { Getdiag_itemContext } from "./PostgreSqlParser.js"; -import { Getdiag_targetContext } from "./PostgreSqlParser.js"; import { Assign_varContext } from "./PostgreSqlParser.js"; import { Stmt_ifContext } from "./PostgreSqlParser.js"; -import { Stmt_elsifsContext } from "./PostgreSqlParser.js"; import { Stmt_elseContext } from "./PostgreSqlParser.js"; import { Stmt_caseContext } from "./PostgreSqlParser.js"; -import { Opt_expr_until_whenContext } from "./PostgreSqlParser.js"; -import { Case_when_listContext } from "./PostgreSqlParser.js"; -import { Case_whenContext } from "./PostgreSqlParser.js"; -import { Opt_case_elseContext } from "./PostgreSqlParser.js"; -import { Stmt_loopContext } from "./PostgreSqlParser.js"; -import { Stmt_whileContext } from "./PostgreSqlParser.js"; -import { Stmt_forContext } from "./PostgreSqlParser.js"; +import { Stmt_loop_while_forContext } from "./PostgreSqlParser.js"; import { For_controlContext } from "./PostgreSqlParser.js"; -import { Opt_for_using_expressionContext } from "./PostgreSqlParser.js"; -import { Opt_cursor_parametersContext } from "./PostgreSqlParser.js"; -import { Opt_reverseContext } from "./PostgreSqlParser.js"; -import { Opt_by_expressionContext } from "./PostgreSqlParser.js"; -import { For_variableContext } from "./PostgreSqlParser.js"; import { Stmt_foreach_aContext } from "./PostgreSqlParser.js"; -import { Foreach_sliceContext } from "./PostgreSqlParser.js"; import { Stmt_exitContext } from "./PostgreSqlParser.js"; -import { Exit_typeContext } from "./PostgreSqlParser.js"; import { Stmt_returnContext } from "./PostgreSqlParser.js"; -import { Opt_return_resultContext } from "./PostgreSqlParser.js"; import { Stmt_raiseContext } from "./PostgreSqlParser.js"; -import { Opt_stmt_raise_levelContext } from "./PostgreSqlParser.js"; -import { Opt_raise_listContext } from "./PostgreSqlParser.js"; -import { Opt_raise_usingContext } from "./PostgreSqlParser.js"; import { Opt_raise_using_elemContext } from "./PostgreSqlParser.js"; -import { Opt_raise_using_elem_listContext } from "./PostgreSqlParser.js"; import { Stmt_assertContext } from "./PostgreSqlParser.js"; -import { Opt_stmt_assert_messageContext } from "./PostgreSqlParser.js"; import { Loop_bodyContext } from "./PostgreSqlParser.js"; import { Stmt_execsqlContext } from "./PostgreSqlParser.js"; import { Stmt_dynexecuteContext } from "./PostgreSqlParser.js"; -import { Opt_execute_usingContext } from "./PostgreSqlParser.js"; -import { Opt_execute_using_listContext } from "./PostgreSqlParser.js"; import { Opt_execute_intoContext } from "./PostgreSqlParser.js"; import { Stmt_openContext } from "./PostgreSqlParser.js"; import { Opt_open_bound_list_itemContext } from "./PostgreSqlParser.js"; -import { Opt_open_bound_listContext } from "./PostgreSqlParser.js"; -import { Opt_open_usingContext } from "./PostgreSqlParser.js"; -import { Opt_scroll_optionContext } from "./PostgreSqlParser.js"; -import { Opt_scroll_option_noContext } from "./PostgreSqlParser.js"; import { Stmt_fetchContext } from "./PostgreSqlParser.js"; -import { Into_targetContext } from "./PostgreSqlParser.js"; -import { Opt_cursor_fromContext } from "./PostgreSqlParser.js"; import { Opt_fetch_directionContext } from "./PostgreSqlParser.js"; import { Stmt_moveContext } from "./PostgreSqlParser.js"; import { MergestmtContext } from "./PostgreSqlParser.js"; import { Data_sourceContext } from "./PostgreSqlParser.js"; -import { Join_conditionContext } from "./PostgreSqlParser.js"; import { Merge_when_clauseContext } from "./PostgreSqlParser.js"; import { Merge_insertContext } from "./PostgreSqlParser.js"; import { Merge_updateContext } from "./PostgreSqlParser.js"; import { Default_values_or_valuesContext } from "./PostgreSqlParser.js"; -import { ExprofdefaultlistContext } from "./PostgreSqlParser.js"; import { ExprofdefaultContext } from "./PostgreSqlParser.js"; import { Stmt_closeContext } from "./PostgreSqlParser.js"; import { Stmt_nullContext } from "./PostgreSqlParser.js"; -import { Stmt_commitContext } from "./PostgreSqlParser.js"; -import { Stmt_rollbackContext } from "./PostgreSqlParser.js"; -import { Plsql_opt_transaction_chainContext } from "./PostgreSqlParser.js"; +import { Stmt_commit_or_rollbackContext } from "./PostgreSqlParser.js"; import { Stmt_setContext } from "./PostgreSqlParser.js"; import { Cursor_variableContext } from "./PostgreSqlParser.js"; import { Exception_sectContext } from "./PostgreSqlParser.js"; -import { Proc_exceptionsContext } from "./PostgreSqlParser.js"; -import { Proc_exceptionContext } from "./PostgreSqlParser.js"; -import { Proc_conditionsContext } from "./PostgreSqlParser.js"; import { Proc_conditionContext } from "./PostgreSqlParser.js"; -import { Opt_block_labelContext } from "./PostgreSqlParser.js"; -import { Opt_loop_labelContext } from "./PostgreSqlParser.js"; -import { Opt_labelContext } from "./PostgreSqlParser.js"; -import { Opt_exitcondContext } from "./PostgreSqlParser.js"; import { Any_identifierContext } from "./PostgreSqlParser.js"; import { Plsql_unreserved_keywordContext } from "./PostgreSqlParser.js"; import { Sql_expressionContext } from "./PostgreSqlParser.js"; -import { Expr_until_thenContext } from "./PostgreSqlParser.js"; -import { Expr_until_semiContext } from "./PostgreSqlParser.js"; -import { Expr_until_rightbracketContext } from "./PostgreSqlParser.js"; -import { Expr_until_loopContext } from "./PostgreSqlParser.js"; -import { Make_execsql_stmtContext } from "./PostgreSqlParser.js"; -import { Opt_returning_clause_intoContext } from "./PostgreSqlParser.js"; /** @@ -907,12 +507,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.plsqlroot`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPlsqlroot?: (ctx: PlsqlrootContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.singleStmt`. * @param ctx the parse tree @@ -925,12 +519,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.plsqlconsolecommand`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPlsqlconsolecommand?: (ctx: PlsqlconsolecommandContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.callstmt`. * @param ctx the parse tree @@ -943,24 +531,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_with`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_with?: (ctx: Opt_withContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.optrolelist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOptrolelist?: (ctx: OptrolelistContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alteroptrolelist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlteroptrolelist?: (ctx: AlteroptrolelistContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.alteroptroleelem`. * @param ctx the parse tree @@ -985,12 +555,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_in_database`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_in_database?: (ctx: Opt_in_databaseContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.alterrolesetstmt`. * @param ctx the parse tree @@ -1009,12 +573,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.routine_action_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRoutine_action_list?: (ctx: Routine_action_listContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.routine_action`. * @param ctx the parse tree @@ -1033,12 +591,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.add_drop`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAdd_drop?: (ctx: Add_dropContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.createschemastmt`. * @param ctx the parse tree @@ -1052,12 +604,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.optschemaeltlist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOptschemaeltlist?: (ctx: OptschemaeltlistContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.schema_stmt`. * @param ctx the parse tree @@ -1130,18 +676,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_encoding`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_encoding?: (ctx: Opt_encodingContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.nonreservedword_or_sconst_column`. - * @param ctx the parse tree - * @return the visitor result - */ - visitNonreservedword_or_sconst_column?: (ctx: Nonreservedword_or_sconst_columnContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.nonreservedword_or_sconst`. * @param ctx the parse tree @@ -1160,12 +694,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.generic_reset`. - * @param ctx the parse tree - * @return the visitor result - */ - visitGeneric_reset?: (ctx: Generic_resetContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.setresetclause`. * @param ctx the parse tree @@ -1190,18 +718,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.constraints_set_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitConstraints_set_list?: (ctx: Constraints_set_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.constraints_set_mode`. - * @param ctx the parse tree - * @return the visitor result - */ - visitConstraints_set_mode?: (ctx: Constraints_set_modeContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.checkpointstmt`. * @param ctx the parse tree @@ -1286,18 +802,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alter_using`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlter_using?: (ctx: Alter_usingContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.replica_identity`. - * @param ctx the parse tree - * @return the visitor result - */ - visitReplica_identity?: (ctx: Replica_identityContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.reloptions`. * @param ctx the parse tree @@ -1310,60 +814,24 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.reloption_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitReloption_list?: (ctx: Reloption_listContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.reloption_elem`. * @param ctx the parse tree * @return the visitor result */ visitReloption_elem?: (ctx: Reloption_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alter_identity_column_option_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlter_identity_column_option_list?: (ctx: Alter_identity_column_option_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alter_identity_column_option`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlter_identity_column_option?: (ctx: Alter_identity_column_optionContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.partitionboundspec`. * @param ctx the parse tree * @return the visitor result */ visitPartitionboundspec?: (ctx: PartitionboundspecContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.hash_partbound_elem`. - * @param ctx the parse tree - * @return the visitor result - */ - visitHash_partbound_elem?: (ctx: Hash_partbound_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.hash_partbound`. - * @param ctx the parse tree - * @return the visitor result - */ - visitHash_partbound?: (ctx: Hash_partboundContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.altercompositetypestmt`. * @param ctx the parse tree * @return the visitor result */ visitAltercompositetypestmt?: (ctx: AltercompositetypestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alter_type_cmds`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlter_type_cmds?: (ctx: Alter_type_cmdsContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.alter_type_cmd`. * @param ctx the parse tree @@ -1382,90 +850,18 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.copy_from`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCopy_from?: (ctx: Copy_fromContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_program`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_program?: (ctx: Opt_programContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.copy_file_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCopy_file_name?: (ctx: Copy_file_nameContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.copy_options`. * @param ctx the parse tree * @return the visitor result */ visitCopy_options?: (ctx: Copy_optionsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.copy_opt_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCopy_opt_list?: (ctx: Copy_opt_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.copy_opt_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCopy_opt_item?: (ctx: Copy_opt_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_binary`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_binary?: (ctx: Opt_binaryContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.copy_delimiter`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCopy_delimiter?: (ctx: Copy_delimiterContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_using`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_using?: (ctx: Opt_usingContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.copy_generic_opt_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCopy_generic_opt_list?: (ctx: Copy_generic_opt_listContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.copy_generic_opt_elem`. * @param ctx the parse tree * @return the visitor result */ visitCopy_generic_opt_elem?: (ctx: Copy_generic_opt_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.copy_generic_opt_arg`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCopy_generic_opt_arg?: (ctx: Copy_generic_opt_argContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.copy_generic_opt_arg_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCopy_generic_opt_arg_list?: (ctx: Copy_generic_opt_arg_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.copy_generic_opt_arg_list_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCopy_generic_opt_arg_list_item?: (ctx: Copy_generic_opt_arg_list_itemContext) => Result; /** * Visit a parse tree produced by the `columnCreateTable` * labeled alternative in `PostgreSqlParser.createstmt`. @@ -1479,18 +875,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.table_column_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTable_column_list?: (ctx: Table_column_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opttableelementlist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpttableelementlist?: (ctx: OpttableelementlistContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.opttypedtableelementlist`. * @param ctx the parse tree @@ -1503,12 +887,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.typedtableelementlist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTypedtableelementlist?: (ctx: TypedtableelementlistContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.tableelement`. * @param ctx the parse tree @@ -1527,30 +905,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.compressionCluase`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCompressionCluase?: (ctx: CompressionCluaseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.storageCluase`. - * @param ctx the parse tree - * @return the visitor result - */ - visitStorageCluase?: (ctx: StorageCluaseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.columnOptions`. - * @param ctx the parse tree - * @return the visitor result - */ - visitColumnOptions?: (ctx: ColumnOptionsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.colquallist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitColquallist?: (ctx: ColquallistContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.colconstraint`. * @param ctx the parse tree @@ -1563,66 +917,24 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.nulls_distinct`. - * @param ctx the parse tree - * @return the visitor result - */ - visitNulls_distinct?: (ctx: Nulls_distinctContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.generated_when`. * @param ctx the parse tree * @return the visitor result */ visitGenerated_when?: (ctx: Generated_whenContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.deferrable_trigger`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDeferrable_trigger?: (ctx: Deferrable_triggerContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.initially_trigger`. - * @param ctx the parse tree - * @return the visitor result - */ - visitInitially_trigger?: (ctx: Initially_triggerContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.tablelikeclause`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTablelikeclause?: (ctx: TablelikeclauseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.tablelikeoptionlist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTablelikeoptionlist?: (ctx: TablelikeoptionlistContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.tablelikeoption`. * @param ctx the parse tree * @return the visitor result */ visitTablelikeoption?: (ctx: TablelikeoptionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.tableconstraint`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTableconstraint?: (ctx: TableconstraintContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.constraintelem`. * @param ctx the parse tree * @return the visitor result */ visitConstraintelem?: (ctx: ConstraintelemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_no_inherit`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_no_inherit?: (ctx: Opt_no_inheritContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.opt_column_list`. * @param ctx the parse tree @@ -1641,12 +953,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.column_list_create`. - * @param ctx the parse tree - * @return the visitor result - */ - visitColumn_list_create?: (ctx: Column_list_createContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.opt_c_include`. * @param ctx the parse tree @@ -1659,24 +965,12 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.exclusionconstraintlist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExclusionconstraintlist?: (ctx: ExclusionconstraintlistContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.exclusionconstraintelem`. * @param ctx the parse tree * @return the visitor result */ visitExclusionconstraintelem?: (ctx: ExclusionconstraintelemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.exclusionwhereclause`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExclusionwhereclause?: (ctx: ExclusionwhereclauseContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.key_actions`. * @param ctx the parse tree @@ -1707,24 +1001,12 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.optpartitionspec`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOptpartitionspec?: (ctx: OptpartitionspecContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.partitionspec`. * @param ctx the parse tree * @return the visitor result */ visitPartitionspec?: (ctx: PartitionspecContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.part_params`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPart_params?: (ctx: Part_paramsContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.part_elem`. * @param ctx the parse tree @@ -1755,12 +1037,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.index_paramenters_create`. - * @param ctx the parse tree - * @return the visitor result - */ - visitIndex_paramenters_create?: (ctx: Index_paramenters_createContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.optconstablespace`. * @param ctx the parse tree @@ -1811,18 +1087,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.create_mv_target`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreate_mv_target?: (ctx: Create_mv_targetContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.optnolog`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOptnolog?: (ctx: OptnologContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.refreshmatviewstmt`. * @param ctx the parse tree @@ -1842,245 +1106,101 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; /** - * Visit a parse tree produced by `PostgreSqlParser.optseqoptlist`. + * Visit a parse tree produced by `PostgreSqlParser.seqoptelem`. * @param ctx the parse tree * @return the visitor result */ - visitOptseqoptlist?: (ctx: OptseqoptlistContext) => Result; + visitSeqoptelem?: (ctx: SeqoptelemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.optparenthesizedseqoptlist`. + * Visit a parse tree produced by `PostgreSqlParser.numericonly`. * @param ctx the parse tree * @return the visitor result */ - visitOptparenthesizedseqoptlist?: (ctx: OptparenthesizedseqoptlistContext) => Result; + visitNumericonly?: (ctx: NumericonlyContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.seqoptlist`. + * Visit a parse tree produced by `PostgreSqlParser.createplangstmt`. * @param ctx the parse tree * @return the visitor result */ - visitSeqoptlist?: (ctx: SeqoptlistContext) => Result; + visitCreateplangstmt?: (ctx: CreateplangstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.seqoptelem`. + * Visit a parse tree produced by `PostgreSqlParser.createtablespacestmt`. * @param ctx the parse tree * @return the visitor result */ - visitSeqoptelem?: (ctx: SeqoptelemContext) => Result; + visitCreatetablespacestmt?: (ctx: CreatetablespacestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_by`. + * Visit a parse tree produced by `PostgreSqlParser.createextensionstmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_by?: (ctx: Opt_byContext) => Result; + visitCreateextensionstmt?: (ctx: CreateextensionstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.numericonly`. + * Visit a parse tree produced by `PostgreSqlParser.alterextensionstmt`. * @param ctx the parse tree * @return the visitor result */ - visitNumericonly?: (ctx: NumericonlyContext) => Result; + visitAlterextensionstmt?: (ctx: AlterextensionstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.numericonly_list`. + * Visit a parse tree produced by `PostgreSqlParser.alterextensioncontentsstmt`. * @param ctx the parse tree * @return the visitor result */ - visitNumericonly_list?: (ctx: Numericonly_listContext) => Result; + visitAlterextensioncontentsstmt?: (ctx: AlterextensioncontentsstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.createplangstmt`. + * Visit a parse tree produced by `PostgreSqlParser.createfdwstmt`. * @param ctx the parse tree * @return the visitor result */ - visitCreateplangstmt?: (ctx: CreateplangstmtContext) => Result; + visitCreatefdwstmt?: (ctx: CreatefdwstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_trusted`. + * Visit a parse tree produced by `PostgreSqlParser.fdw_option`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_trusted?: (ctx: Opt_trustedContext) => Result; + visitFdw_option?: (ctx: Fdw_optionContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.handler_name`. + * Visit a parse tree produced by `PostgreSqlParser.alterfdwstmt`. * @param ctx the parse tree * @return the visitor result */ - visitHandler_name?: (ctx: Handler_nameContext) => Result; + visitAlterfdwstmt?: (ctx: AlterfdwstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_inline_handler`. + * Visit a parse tree produced by `PostgreSqlParser.create_generic_options`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_inline_handler?: (ctx: Opt_inline_handlerContext) => Result; + visitCreate_generic_options?: (ctx: Create_generic_optionsContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.validator_clause`. + * Visit a parse tree produced by `PostgreSqlParser.alter_generic_options`. * @param ctx the parse tree * @return the visitor result */ - visitValidator_clause?: (ctx: Validator_clauseContext) => Result; + visitAlter_generic_options?: (ctx: Alter_generic_optionsContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_validator`. + * Visit a parse tree produced by `PostgreSqlParser.alter_generic_option_elem`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_validator?: (ctx: Opt_validatorContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_procedural`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_procedural?: (ctx: Opt_proceduralContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createtablespacestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatetablespacestmt?: (ctx: CreatetablespacestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opttablespaceowner`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpttablespaceowner?: (ctx: OpttablespaceownerContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createextensionstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreateextensionstmt?: (ctx: CreateextensionstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.create_extension_opt_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreate_extension_opt_list?: (ctx: Create_extension_opt_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.create_extension_opt_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreate_extension_opt_item?: (ctx: Create_extension_opt_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterextensionstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterextensionstmt?: (ctx: AlterextensionstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alter_extension_opt_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlter_extension_opt_list?: (ctx: Alter_extension_opt_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alter_extension_opt_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlter_extension_opt_item?: (ctx: Alter_extension_opt_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterextensioncontentsstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterextensioncontentsstmt?: (ctx: AlterextensioncontentsstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createfdwstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatefdwstmt?: (ctx: CreatefdwstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.fdw_option`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFdw_option?: (ctx: Fdw_optionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.fdw_options`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFdw_options?: (ctx: Fdw_optionsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_fdw_options`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_fdw_options?: (ctx: Opt_fdw_optionsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterfdwstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterfdwstmt?: (ctx: AlterfdwstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.create_generic_options`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreate_generic_options?: (ctx: Create_generic_optionsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.generic_option_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitGeneric_option_list?: (ctx: Generic_option_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alter_generic_options`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlter_generic_options?: (ctx: Alter_generic_optionsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alter_generic_option_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlter_generic_option_list?: (ctx: Alter_generic_option_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alter_generic_option_elem`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlter_generic_option_elem?: (ctx: Alter_generic_option_elemContext) => Result; + visitAlter_generic_option_elem?: (ctx: Alter_generic_option_elemContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.generic_option_elem`. * @param ctx the parse tree * @return the visitor result */ visitGeneric_option_elem?: (ctx: Generic_option_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.generic_option_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitGeneric_option_name?: (ctx: Generic_option_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.generic_option_arg`. - * @param ctx the parse tree - * @return the visitor result - */ - visitGeneric_option_arg?: (ctx: Generic_option_argContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.createforeignserverstmt`. * @param ctx the parse tree * @return the visitor result */ visitCreateforeignserverstmt?: (ctx: CreateforeignserverstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_type`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_type?: (ctx: Opt_typeContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.foreign_server_version`. * @param ctx the parse tree * @return the visitor result */ visitForeign_server_version?: (ctx: Foreign_server_versionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_foreign_server_version`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_foreign_server_version?: (ctx: Opt_foreign_server_versionContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.alterforeignserverstmt`. * @param ctx the parse tree @@ -2107,30 +1227,12 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.import_qualification_type`. - * @param ctx the parse tree - * @return the visitor result - */ - visitImport_qualification_type?: (ctx: Import_qualification_typeContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.import_qualification`. - * @param ctx the parse tree - * @return the visitor result - */ - visitImport_qualification?: (ctx: Import_qualificationContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.createusermappingstmt`. * @param ctx the parse tree * @return the visitor result */ visitCreateusermappingstmt?: (ctx: CreateusermappingstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.auth_ident`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAuth_ident?: (ctx: Auth_identContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.alterusermappingstmt`. * @param ctx the parse tree @@ -2155,12 +1257,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.procedure_cluase`. - * @param ctx the parse tree - * @return the visitor result - */ - visitProcedure_cluase?: (ctx: Procedure_cluaseContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.procedure_action`. * @param ctx the parse tree @@ -2179,48 +1275,12 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.rowsecuritydefaulttorole`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRowsecuritydefaulttorole?: (ctx: RowsecuritydefaulttoroleContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.rowsecurityoptionaltorole`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRowsecurityoptionaltorole?: (ctx: RowsecurityoptionaltoroleContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.rowsecuritydefaultpermissive`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRowsecuritydefaultpermissive?: (ctx: RowsecuritydefaultpermissiveContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.rowsecuritydefaultforcmd`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRowsecuritydefaultforcmd?: (ctx: RowsecuritydefaultforcmdContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.row_security_cmd`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRow_security_cmd?: (ctx: Row_security_cmdContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.createamstmt`. * @param ctx the parse tree * @return the visitor result */ visitCreateamstmt?: (ctx: CreateamstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.am_type`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAm_type?: (ctx: Am_typeContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.createtrigstmt`. * @param ctx the parse tree @@ -2233,18 +1293,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.foreachrow`. - * @param ctx the parse tree - * @return the visitor result - */ - visitForeachrow?: (ctx: ForeachrowContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.roworstatment`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRoworstatment?: (ctx: RoworstatmentContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.triggerevents`. * @param ctx the parse tree @@ -2257,60 +1305,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.triggerreferencing`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTriggerreferencing?: (ctx: TriggerreferencingContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.triggertransitions`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTriggertransitions?: (ctx: TriggertransitionsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.triggertransition`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTriggertransition?: (ctx: TriggertransitionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.transitionoldornew`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTransitionoldornew?: (ctx: TransitionoldornewContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.transitionrowortable`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTransitionrowortable?: (ctx: TransitionrowortableContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.transitionrelname`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTransitionrelname?: (ctx: TransitionrelnameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.triggerforspec`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTriggerforspec?: (ctx: TriggerforspecContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.triggerforopteach`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTriggerforopteach?: (ctx: TriggerforopteachContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.triggerfortype`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTriggerfortype?: (ctx: TriggerfortypeContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.triggerwhen`. * @param ctx the parse tree @@ -2335,18 +1329,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.optconstrfromtable`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOptconstrfromtable?: (ctx: OptconstrfromtableContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.constraintattributespec`. - * @param ctx the parse tree - * @return the visitor result - */ - visitConstraintattributespec?: (ctx: ConstraintattributespecContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.constraintattributeElem`. * @param ctx the parse tree @@ -2359,36 +1341,18 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.event_trigger_when_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitEvent_trigger_when_list?: (ctx: Event_trigger_when_listContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.event_trigger_when_item`. * @param ctx the parse tree * @return the visitor result */ visitEvent_trigger_when_item?: (ctx: Event_trigger_when_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.event_trigger_value_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitEvent_trigger_value_list?: (ctx: Event_trigger_value_listContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.altereventtrigstmt`. * @param ctx the parse tree * @return the visitor result */ visitAltereventtrigstmt?: (ctx: AltereventtrigstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.enable_trigger`. - * @param ctx the parse tree - * @return the visitor result - */ - visitEnable_trigger?: (ctx: Enable_triggerContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.createassertionstmt`. * @param ctx the parse tree @@ -2396,3541 +1360,1935 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; /** - * Visit a parse tree produced by `PostgreSqlParser.definestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDefinestmt?: (ctx: DefinestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.definition`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDefinition?: (ctx: DefinitionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.def_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDef_list?: (ctx: Def_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.def_elem`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDef_elem?: (ctx: Def_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.def_arg`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDef_arg?: (ctx: Def_argContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.old_aggr_definition`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOld_aggr_definition?: (ctx: Old_aggr_definitionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.old_aggr_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOld_aggr_list?: (ctx: Old_aggr_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.old_aggr_elem`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOld_aggr_elem?: (ctx: Old_aggr_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_enum_val_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_enum_val_list?: (ctx: Opt_enum_val_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.enum_val_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitEnum_val_list?: (ctx: Enum_val_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterenumstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterenumstmt?: (ctx: AlterenumstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_if_not_exists`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_if_not_exists?: (ctx: Opt_if_not_existsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createopclassstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreateopclassstmt?: (ctx: CreateopclassstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opclass_item_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpclass_item_list?: (ctx: Opclass_item_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opclass_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpclass_item?: (ctx: Opclass_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_default`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_default?: (ctx: Opt_defaultContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_opfamily`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_opfamily?: (ctx: Opt_opfamilyContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opclass_purpose`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpclass_purpose?: (ctx: Opclass_purposeContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_recheck`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_recheck?: (ctx: Opt_recheckContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createopfamilystmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreateopfamilystmt?: (ctx: CreateopfamilystmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alteropfamilystmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlteropfamilystmt?: (ctx: AlteropfamilystmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opclass_drop_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpclass_drop_list?: (ctx: Opclass_drop_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opclass_drop`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpclass_drop?: (ctx: Opclass_dropContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.reassignownedstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitReassignownedstmt?: (ctx: ReassignownedstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.dropstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDropstmt?: (ctx: DropstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.view_nameList`. - * @param ctx the parse tree - * @return the visitor result - */ - visitView_nameList?: (ctx: View_nameListContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.object_type_any_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitObject_type_any_name?: (ctx: Object_type_any_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.object_type_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitObject_type_name?: (ctx: Object_type_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.object_type_name_on_any_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitObject_type_name_on_any_name?: (ctx: Object_type_name_on_any_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.any_name_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAny_name_list?: (ctx: Any_name_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.relation_column_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRelation_column_name?: (ctx: Relation_column_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.relation_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRelation_name?: (ctx: Relation_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.any_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAny_name?: (ctx: Any_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.attrs`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAttrs?: (ctx: AttrsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.type_name_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitType_name_list?: (ctx: Type_name_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.truncatestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTruncatestmt?: (ctx: TruncatestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.truncate_table`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTruncate_table?: (ctx: Truncate_tableContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.commentstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCommentstmt?: (ctx: CommentstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.comment_text`. - * @param ctx the parse tree - * @return the visitor result - */ - visitComment_text?: (ctx: Comment_textContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.seclabelstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSeclabelstmt?: (ctx: SeclabelstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_provider`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_provider?: (ctx: Opt_providerContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.security_label`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSecurity_label?: (ctx: Security_labelContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.fetchstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFetchstmt?: (ctx: FetchstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.fetch_args`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFetch_args?: (ctx: Fetch_argsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.from_in`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFrom_in?: (ctx: From_inContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_from_in`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_from_in?: (ctx: Opt_from_inContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.grantstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitGrantstmt?: (ctx: GrantstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.revokestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRevokestmt?: (ctx: RevokestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.privileges`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPrivileges?: (ctx: PrivilegesContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.beforeprivilegeselectlist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitBeforeprivilegeselectlist?: (ctx: BeforeprivilegeselectlistContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.beforeprivilegeselect`. - * @param ctx the parse tree - * @return the visitor result - */ - visitBeforeprivilegeselect?: (ctx: BeforeprivilegeselectContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.privilege_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPrivilege_list?: (ctx: Privilege_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.privilege`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPrivilege?: (ctx: PrivilegeContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.privilege_target`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPrivilege_target?: (ctx: Privilege_targetContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.grantee_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitGrantee_list?: (ctx: Grantee_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.grantee`. - * @param ctx the parse tree - * @return the visitor result - */ - visitGrantee?: (ctx: GranteeContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_grant_grant_option`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_grant_grant_option?: (ctx: Opt_grant_grant_optionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.grantrolestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitGrantrolestmt?: (ctx: GrantrolestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.revokerolestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRevokerolestmt?: (ctx: RevokerolestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_grant_admin_option`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_grant_admin_option?: (ctx: Opt_grant_admin_optionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_granted_by`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_granted_by?: (ctx: Opt_granted_byContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterdefaultprivilegesstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterdefaultprivilegesstmt?: (ctx: AlterdefaultprivilegesstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.defacloptionlist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDefacloptionlist?: (ctx: DefacloptionlistContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.defacloption`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDefacloption?: (ctx: DefacloptionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.defaclaction`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDefaclaction?: (ctx: DefaclactionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.defacl_privilege_target`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDefacl_privilege_target?: (ctx: Defacl_privilege_targetContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.indexstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitIndexstmt?: (ctx: IndexstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_unique`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_unique?: (ctx: Opt_uniqueContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_concurrently`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_concurrently?: (ctx: Opt_concurrentlyContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_index_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_index_name?: (ctx: Opt_index_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.access_method_clause`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAccess_method_clause?: (ctx: Access_method_clauseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.index_params`. - * @param ctx the parse tree - * @return the visitor result - */ - visitIndex_params?: (ctx: Index_paramsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.index_elem_options`. - * @param ctx the parse tree - * @return the visitor result - */ - visitIndex_elem_options?: (ctx: Index_elem_optionsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.index_elem`. - * @param ctx the parse tree - * @return the visitor result - */ - visitIndex_elem?: (ctx: Index_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_include`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_include?: (ctx: Opt_includeContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.index_including_params`. - * @param ctx the parse tree - * @return the visitor result - */ - visitIndex_including_params?: (ctx: Index_including_paramsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_collate`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_collate?: (ctx: Opt_collateContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_class`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_class?: (ctx: Opt_classContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_asc_desc`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_asc_desc?: (ctx: Opt_asc_descContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_nulls_order`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_nulls_order?: (ctx: Opt_nulls_orderContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createfunctionstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatefunctionstmt?: (ctx: CreatefunctionstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.attrilist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAttrilist?: (ctx: AttrilistContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_or_replace`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_or_replace?: (ctx: Opt_or_replaceContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.func_args`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFunc_args?: (ctx: Func_argsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.func_args_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFunc_args_list?: (ctx: Func_args_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.routine_with_argtypes_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRoutine_with_argtypes_list?: (ctx: Routine_with_argtypes_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.routine_with_argtypes`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRoutine_with_argtypes?: (ctx: Routine_with_argtypesContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.procedure_with_argtypes_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitProcedure_with_argtypes_list?: (ctx: Procedure_with_argtypes_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.procedure_with_argtypes`. - * @param ctx the parse tree - * @return the visitor result - */ - visitProcedure_with_argtypes?: (ctx: Procedure_with_argtypesContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.function_with_argtypes_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFunction_with_argtypes_list?: (ctx: Function_with_argtypes_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.function_with_argtypes`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFunction_with_argtypes?: (ctx: Function_with_argtypesContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.func_args_with_defaults`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFunc_args_with_defaults?: (ctx: Func_args_with_defaultsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.func_args_with_defaults_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFunc_args_with_defaults_list?: (ctx: Func_args_with_defaults_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.func_arg`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFunc_arg?: (ctx: Func_argContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.arg_class`. - * @param ctx the parse tree - * @return the visitor result - */ - visitArg_class?: (ctx: Arg_classContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.param_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitParam_name?: (ctx: Param_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.func_return`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFunc_return?: (ctx: Func_returnContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.func_type`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFunc_type?: (ctx: Func_typeContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.func_arg_with_default`. - * @param ctx the parse tree - * @return the visitor result - */ - visitFunc_arg_with_default?: (ctx: Func_arg_with_defaultContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.aggr_arg`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAggr_arg?: (ctx: Aggr_argContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.aggr_args`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAggr_args?: (ctx: Aggr_argsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.aggr_args_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAggr_args_list?: (ctx: Aggr_args_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.aggregate_with_argtypes`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAggregate_with_argtypes?: (ctx: Aggregate_with_argtypesContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.aggregate_with_argtypes_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAggregate_with_argtypes_list?: (ctx: Aggregate_with_argtypes_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createfunc_opt_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatefunc_opt_list?: (ctx: Createfunc_opt_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.common_func_opt_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCommon_func_opt_item?: (ctx: Common_func_opt_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createfunc_opt_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatefunc_opt_item?: (ctx: Createfunc_opt_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.transform_type_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTransform_type_list?: (ctx: Transform_type_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_definition`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_definition?: (ctx: Opt_definitionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.table_func_column`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTable_func_column?: (ctx: Table_func_columnContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.table_func_column_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTable_func_column_list?: (ctx: Table_func_column_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterfunctionstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterfunctionstmt?: (ctx: AlterfunctionstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterFunctionTypeClause`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterFunctionTypeClause?: (ctx: AlterFunctionTypeClauseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterfunc_opt_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterfunc_opt_list?: (ctx: Alterfunc_opt_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_restrict`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_restrict?: (ctx: Opt_restrictContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.removefuncstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRemovefuncstmt?: (ctx: RemovefuncstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.removeaggrstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRemoveaggrstmt?: (ctx: RemoveaggrstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.removeoperstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRemoveoperstmt?: (ctx: RemoveoperstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.oper_argtypes`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOper_argtypes?: (ctx: Oper_argtypesContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.any_operator`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAny_operator?: (ctx: Any_operatorContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.operator_with_argtypes_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOperator_with_argtypes_list?: (ctx: Operator_with_argtypes_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.operator_with_argtypes`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOperator_with_argtypes?: (ctx: Operator_with_argtypesContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.dostmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDostmt?: (ctx: DostmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.dostmt_opt_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDostmt_opt_list?: (ctx: Dostmt_opt_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.dostmt_opt_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDostmt_opt_item?: (ctx: Dostmt_opt_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createcaststmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatecaststmt?: (ctx: CreatecaststmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.cast_context`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCast_context?: (ctx: Cast_contextContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_if_exists`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_if_exists?: (ctx: Opt_if_existsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createtransformstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatetransformstmt?: (ctx: CreatetransformstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.transform_element_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTransform_element_list?: (ctx: Transform_element_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.reindexstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitReindexstmt?: (ctx: ReindexstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.reindex_target_type`. - * @param ctx the parse tree - * @return the visitor result - */ - visitReindex_target_type?: (ctx: Reindex_target_typeContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.reindex_target_multitable`. - * @param ctx the parse tree - * @return the visitor result - */ - visitReindex_target_multitable?: (ctx: Reindex_target_multitableContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.reindex_option_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitReindex_option_list?: (ctx: Reindex_option_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.reindex_option_elem`. - * @param ctx the parse tree - * @return the visitor result - */ - visitReindex_option_elem?: (ctx: Reindex_option_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.altertblspcstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAltertblspcstmt?: (ctx: AltertblspcstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.renamestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRenamestmt?: (ctx: RenamestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_set_data`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_set_data?: (ctx: Opt_set_dataContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterobjectdependsstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterobjectdependsstmt?: (ctx: AlterobjectdependsstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_no`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_no?: (ctx: Opt_noContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterobjectschemastmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterobjectschemastmt?: (ctx: AlterobjectschemastmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alteroperatorstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlteroperatorstmt?: (ctx: AlteroperatorstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.operator_def_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOperator_def_list?: (ctx: Operator_def_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.operator_def_elem`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOperator_def_elem?: (ctx: Operator_def_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.operator_def_arg`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOperator_def_arg?: (ctx: Operator_def_argContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.altertypestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAltertypestmt?: (ctx: AltertypestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterownerstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterownerstmt?: (ctx: AlterownerstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createpublicationstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatepublicationstmt?: (ctx: CreatepublicationstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_publication_for_tables`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_publication_for_tables?: (ctx: Opt_publication_for_tablesContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.publication_for_tables`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPublication_for_tables?: (ctx: Publication_for_tablesContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterpublicationstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterpublicationstmt?: (ctx: AlterpublicationstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createsubscriptionstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatesubscriptionstmt?: (ctx: CreatesubscriptionstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.publication_name_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPublication_name_list?: (ctx: Publication_name_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.publication_name_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPublication_name_item?: (ctx: Publication_name_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.altersubscriptionstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAltersubscriptionstmt?: (ctx: AltersubscriptionstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.rulestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRulestmt?: (ctx: RulestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.ruleactionlist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRuleactionlist?: (ctx: RuleactionlistContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.ruleactionmulti`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRuleactionmulti?: (ctx: RuleactionmultiContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.ruleactionstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRuleactionstmt?: (ctx: RuleactionstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.ruleactionstmtOrEmpty`. - * @param ctx the parse tree - * @return the visitor result - */ - visitRuleactionstmtOrEmpty?: (ctx: RuleactionstmtOrEmptyContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.event`. - * @param ctx the parse tree - * @return the visitor result - */ - visitEvent?: (ctx: EventContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_instead`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_instead?: (ctx: Opt_insteadContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.notifystmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitNotifystmt?: (ctx: NotifystmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.notify_payload`. - * @param ctx the parse tree - * @return the visitor result - */ - visitNotify_payload?: (ctx: Notify_payloadContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.listenstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitListenstmt?: (ctx: ListenstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.unlistenstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitUnlistenstmt?: (ctx: UnlistenstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.transactionstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTransactionstmt?: (ctx: TransactionstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_transaction`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_transaction?: (ctx: Opt_transactionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.transaction_mode_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTransaction_mode_item?: (ctx: Transaction_mode_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.transaction_mode_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTransaction_mode_list?: (ctx: Transaction_mode_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.transaction_mode_list_or_empty`. - * @param ctx the parse tree - * @return the visitor result - */ - visitTransaction_mode_list_or_empty?: (ctx: Transaction_mode_list_or_emptyContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_transaction_chain`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_transaction_chain?: (ctx: Opt_transaction_chainContext) => Result; - /** - * Visit a parse tree produced by the `createView` - * labeled alternative in `PostgreSqlParser.viewstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreateView?: (ctx: CreateViewContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_check_option`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_check_option?: (ctx: Opt_check_optionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.loadstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitLoadstmt?: (ctx: LoadstmtContext) => Result; - /** - * Visit a parse tree produced by the `createDatabase` - * labeled alternative in `PostgreSqlParser.createdbstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreateDatabase?: (ctx: CreateDatabaseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createdb_opt_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatedb_opt_list?: (ctx: Createdb_opt_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createdb_opt_items`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatedb_opt_items?: (ctx: Createdb_opt_itemsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createdb_opt_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatedb_opt_item?: (ctx: Createdb_opt_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createdb_opt_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatedb_opt_name?: (ctx: Createdb_opt_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_equal`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_equal?: (ctx: Opt_equalContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterdatabasestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterdatabasestmt?: (ctx: AlterdatabasestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterdatabasesetstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterdatabasesetstmt?: (ctx: AlterdatabasesetstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.drop_option_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDrop_option_list?: (ctx: Drop_option_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.drop_option`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDrop_option?: (ctx: Drop_optionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.altercollationstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAltercollationstmt?: (ctx: AltercollationstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.altersystemstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAltersystemstmt?: (ctx: AltersystemstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createdomainstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreatedomainstmt?: (ctx: CreatedomainstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.alterdomainstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAlterdomainstmt?: (ctx: AlterdomainstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_as`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_as?: (ctx: Opt_asContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.altertsdictionarystmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAltertsdictionarystmt?: (ctx: AltertsdictionarystmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.altertsconfigurationstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAltertsconfigurationstmt?: (ctx: AltertsconfigurationstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.any_with`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAny_with?: (ctx: Any_withContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.createconversionstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCreateconversionstmt?: (ctx: CreateconversionstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.clusterstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitClusterstmt?: (ctx: ClusterstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_verbose_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_verbose_list?: (ctx: Opt_verbose_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.cluster_index_specification`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCluster_index_specification?: (ctx: Cluster_index_specificationContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.vacuumstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitVacuumstmt?: (ctx: VacuumstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.analyzestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAnalyzestmt?: (ctx: AnalyzestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.vac_analyze_option_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitVac_analyze_option_list?: (ctx: Vac_analyze_option_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.analyze_keyword`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAnalyze_keyword?: (ctx: Analyze_keywordContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.vac_analyze_option_elem`. - * @param ctx the parse tree - * @return the visitor result - */ - visitVac_analyze_option_elem?: (ctx: Vac_analyze_option_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.vac_analyze_option_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitVac_analyze_option_name?: (ctx: Vac_analyze_option_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.vac_analyze_option_arg`. - * @param ctx the parse tree - * @return the visitor result - */ - visitVac_analyze_option_arg?: (ctx: Vac_analyze_option_argContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_analyze`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_analyze?: (ctx: Opt_analyzeContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.analyze_options_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAnalyze_options_list?: (ctx: Analyze_options_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.analyze_option_elem`. - * @param ctx the parse tree - * @return the visitor result - */ - visitAnalyze_option_elem?: (ctx: Analyze_option_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_verbose`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_verbose?: (ctx: Opt_verboseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_skiplock`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_skiplock?: (ctx: Opt_skiplockContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_buffer_usage_limit`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_buffer_usage_limit?: (ctx: Opt_buffer_usage_limitContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_full`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_full?: (ctx: Opt_fullContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_freeze`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_freeze?: (ctx: Opt_freezeContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_name_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_name_list?: (ctx: Opt_name_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.vacuum_relation`. - * @param ctx the parse tree - * @return the visitor result - */ - visitVacuum_relation?: (ctx: Vacuum_relationContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.vacuum_relation_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitVacuum_relation_list?: (ctx: Vacuum_relation_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_vacuum_relation_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_vacuum_relation_list?: (ctx: Opt_vacuum_relation_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.explainstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExplainstmt?: (ctx: ExplainstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.explainablestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExplainablestmt?: (ctx: ExplainablestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.explain_option_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExplain_option_list?: (ctx: Explain_option_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.explain_option_elem`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExplain_option_elem?: (ctx: Explain_option_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.explain_option_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExplain_option_name?: (ctx: Explain_option_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.explain_option_arg`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExplain_option_arg?: (ctx: Explain_option_argContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.preparestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPreparestmt?: (ctx: PreparestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.prep_type_clause`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPrep_type_clause?: (ctx: Prep_type_clauseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.preparablestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPreparablestmt?: (ctx: PreparablestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.executestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExecutestmt?: (ctx: ExecutestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.execute_param_clause`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExecute_param_clause?: (ctx: Execute_param_clauseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.deallocatestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDeallocatestmt?: (ctx: DeallocatestmtContext) => Result; - /** - * Visit a parse tree produced by the `insertStatement` - * labeled alternative in `PostgreSqlParser.insertstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitInsertStatement?: (ctx: InsertStatementContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.insert_target`. - * @param ctx the parse tree - * @return the visitor result - */ - visitInsert_target?: (ctx: Insert_targetContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.insert_rest`. - * @param ctx the parse tree - * @return the visitor result - */ - visitInsert_rest?: (ctx: Insert_restContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.override_kind`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOverride_kind?: (ctx: Override_kindContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.insert_column_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitInsert_column_list?: (ctx: Insert_column_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.insert_column_item`. - * @param ctx the parse tree - * @return the visitor result - */ - visitInsert_column_item?: (ctx: Insert_column_itemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_on_conflict`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_on_conflict?: (ctx: Opt_on_conflictContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_conf_expr`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_conf_expr?: (ctx: Opt_conf_exprContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.returning_clause`. - * @param ctx the parse tree - * @return the visitor result - */ - visitReturning_clause?: (ctx: Returning_clauseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.deletestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDeletestmt?: (ctx: DeletestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.using_clause`. - * @param ctx the parse tree - * @return the visitor result - */ - visitUsing_clause?: (ctx: Using_clauseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.lockstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitLockstmt?: (ctx: LockstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_lock`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_lock?: (ctx: Opt_lockContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.lock_type`. - * @param ctx the parse tree - * @return the visitor result - */ - visitLock_type?: (ctx: Lock_typeContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_nowait`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_nowait?: (ctx: Opt_nowaitContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_nowait_or_skip`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_nowait_or_skip?: (ctx: Opt_nowait_or_skipContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.updatestmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitUpdatestmt?: (ctx: UpdatestmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.set_clause_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSet_clause_list?: (ctx: Set_clause_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.set_clause`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSet_clause?: (ctx: Set_clauseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.set_target`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSet_target?: (ctx: Set_targetContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.set_target_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSet_target_list?: (ctx: Set_target_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.declarecursorstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitDeclarecursorstmt?: (ctx: DeclarecursorstmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.cursor_name`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCursor_name?: (ctx: Cursor_nameContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.cursor_options`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCursor_options?: (ctx: Cursor_optionsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_hold`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_hold?: (ctx: Opt_holdContext) => Result; - /** - * Visit a parse tree produced by the `selectStatement` - * labeled alternative in `PostgreSqlParser.selectstmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSelectStatement?: (ctx: SelectStatementContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.select_with_parens`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSelect_with_parens?: (ctx: Select_with_parensContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.select_no_parens`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSelect_no_parens?: (ctx: Select_no_parensContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.select_clause`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSelect_clause?: (ctx: Select_clauseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.simple_select`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSimple_select?: (ctx: Simple_selectContext) => Result; - /** - * Visit a parse tree produced by the `union` - * labeled alternative in `PostgreSqlParser.set_operator`. - * @param ctx the parse tree - * @return the visitor result - */ - visitUnion?: (ctx: UnionContext) => Result; - /** - * Visit a parse tree produced by the `intersect` - * labeled alternative in `PostgreSqlParser.set_operator`. - * @param ctx the parse tree - * @return the visitor result - */ - visitIntersect?: (ctx: IntersectContext) => Result; - /** - * Visit a parse tree produced by the `except` - * labeled alternative in `PostgreSqlParser.set_operator`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExcept?: (ctx: ExceptContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.set_operator_with_all_or_distinct`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSet_operator_with_all_or_distinct?: (ctx: Set_operator_with_all_or_distinctContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.with_clause`. - * @param ctx the parse tree - * @return the visitor result - */ - visitWith_clause?: (ctx: With_clauseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.cte_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCte_list?: (ctx: Cte_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.common_table_expr`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCommon_table_expr?: (ctx: Common_table_exprContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.search_cluase`. - * @param ctx the parse tree - * @return the visitor result - */ - visitSearch_cluase?: (ctx: Search_cluaseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.cycle_cluase`. - * @param ctx the parse tree - * @return the visitor result - */ - visitCycle_cluase?: (ctx: Cycle_cluaseContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_materialized`. + * Visit a parse tree produced by `PostgreSqlParser.definestmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_materialized?: (ctx: Opt_materializedContext) => Result; + visitDefinestmt?: (ctx: DefinestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_with_clause`. + * Visit a parse tree produced by `PostgreSqlParser.definition`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_with_clause?: (ctx: Opt_with_clauseContext) => Result; + visitDefinition?: (ctx: DefinitionContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.into_clause`. + * Visit a parse tree produced by `PostgreSqlParser.def_elem`. * @param ctx the parse tree * @return the visitor result */ - visitInto_clause?: (ctx: Into_clauseContext) => Result; + visitDef_elem?: (ctx: Def_elemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_strict`. + * Visit a parse tree produced by `PostgreSqlParser.def_arg`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_strict?: (ctx: Opt_strictContext) => Result; + visitDef_arg?: (ctx: Def_argContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opttempTableName`. + * Visit a parse tree produced by `PostgreSqlParser.old_aggr_elem`. * @param ctx the parse tree * @return the visitor result */ - visitOpttempTableName?: (ctx: OpttempTableNameContext) => Result; + visitOld_aggr_elem?: (ctx: Old_aggr_elemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_table`. + * Visit a parse tree produced by `PostgreSqlParser.alterenumstmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_table?: (ctx: Opt_tableContext) => Result; + visitAlterenumstmt?: (ctx: AlterenumstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.all_or_distinct`. + * Visit a parse tree produced by `PostgreSqlParser.opt_if_not_exists`. * @param ctx the parse tree * @return the visitor result */ - visitAll_or_distinct?: (ctx: All_or_distinctContext) => Result; + visitOpt_if_not_exists?: (ctx: Opt_if_not_existsContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.distinct_clause`. + * Visit a parse tree produced by `PostgreSqlParser.createopclassstmt`. * @param ctx the parse tree * @return the visitor result */ - visitDistinct_clause?: (ctx: Distinct_clauseContext) => Result; + visitCreateopclassstmt?: (ctx: CreateopclassstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_all_clause`. + * Visit a parse tree produced by `PostgreSqlParser.opclass_item`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_all_clause?: (ctx: Opt_all_clauseContext) => Result; + visitOpclass_item?: (ctx: Opclass_itemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_sort_clause`. + * Visit a parse tree produced by `PostgreSqlParser.createopfamilystmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_sort_clause?: (ctx: Opt_sort_clauseContext) => Result; + visitCreateopfamilystmt?: (ctx: CreateopfamilystmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.sort_clause`. + * Visit a parse tree produced by `PostgreSqlParser.alteropfamilystmt`. * @param ctx the parse tree * @return the visitor result */ - visitSort_clause?: (ctx: Sort_clauseContext) => Result; + visitAlteropfamilystmt?: (ctx: AlteropfamilystmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.sortby_list`. + * Visit a parse tree produced by `PostgreSqlParser.opclass_drop`. * @param ctx the parse tree * @return the visitor result */ - visitSortby_list?: (ctx: Sortby_listContext) => Result; + visitOpclass_drop?: (ctx: Opclass_dropContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.sortby`. + * Visit a parse tree produced by `PostgreSqlParser.reassignownedstmt`. * @param ctx the parse tree * @return the visitor result */ - visitSortby?: (ctx: SortbyContext) => Result; + visitReassignownedstmt?: (ctx: ReassignownedstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.select_limit`. + * Visit a parse tree produced by `PostgreSqlParser.dropstmt`. * @param ctx the parse tree * @return the visitor result */ - visitSelect_limit?: (ctx: Select_limitContext) => Result; + visitDropstmt?: (ctx: DropstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_select_limit`. + * Visit a parse tree produced by `PostgreSqlParser.object_type_any_name`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_select_limit?: (ctx: Opt_select_limitContext) => Result; + visitObject_type_any_name?: (ctx: Object_type_any_nameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.limit_clause`. + * Visit a parse tree produced by `PostgreSqlParser.object_type_name`. * @param ctx the parse tree * @return the visitor result */ - visitLimit_clause?: (ctx: Limit_clauseContext) => Result; + visitObject_type_name?: (ctx: Object_type_nameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.fetch_clause`. + * Visit a parse tree produced by `PostgreSqlParser.any_name_list`. * @param ctx the parse tree * @return the visitor result */ - visitFetch_clause?: (ctx: Fetch_clauseContext) => Result; + visitAny_name_list?: (ctx: Any_name_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.offset_clause`. + * Visit a parse tree produced by `PostgreSqlParser.any_name`. * @param ctx the parse tree * @return the visitor result */ - visitOffset_clause?: (ctx: Offset_clauseContext) => Result; + visitAny_name?: (ctx: Any_nameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.select_limit_value`. + * Visit a parse tree produced by `PostgreSqlParser.attrs`. * @param ctx the parse tree * @return the visitor result */ - visitSelect_limit_value?: (ctx: Select_limit_valueContext) => Result; + visitAttrs?: (ctx: AttrsContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.select_offset_value`. + * Visit a parse tree produced by `PostgreSqlParser.truncatestmt`. * @param ctx the parse tree * @return the visitor result */ - visitSelect_offset_value?: (ctx: Select_offset_valueContext) => Result; + visitTruncatestmt?: (ctx: TruncatestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.select_fetch_first_value`. + * Visit a parse tree produced by `PostgreSqlParser.truncate_table`. * @param ctx the parse tree * @return the visitor result */ - visitSelect_fetch_first_value?: (ctx: Select_fetch_first_valueContext) => Result; + visitTruncate_table?: (ctx: Truncate_tableContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.i_or_f_const`. + * Visit a parse tree produced by `PostgreSqlParser.commentstmt`. * @param ctx the parse tree * @return the visitor result */ - visitI_or_f_const?: (ctx: I_or_f_constContext) => Result; + visitCommentstmt?: (ctx: CommentstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.row_or_rows`. + * Visit a parse tree produced by `PostgreSqlParser.seclabelstmt`. * @param ctx the parse tree * @return the visitor result */ - visitRow_or_rows?: (ctx: Row_or_rowsContext) => Result; + visitSeclabelstmt?: (ctx: SeclabelstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.first_or_next`. + * Visit a parse tree produced by `PostgreSqlParser.fetchstmt`. * @param ctx the parse tree * @return the visitor result */ - visitFirst_or_next?: (ctx: First_or_nextContext) => Result; + visitFetchstmt?: (ctx: FetchstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.group_clause`. + * Visit a parse tree produced by `PostgreSqlParser.fetch_args`. * @param ctx the parse tree * @return the visitor result */ - visitGroup_clause?: (ctx: Group_clauseContext) => Result; + visitFetch_args?: (ctx: Fetch_argsContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.group_by_list`. + * Visit a parse tree produced by `PostgreSqlParser.from_in`. * @param ctx the parse tree * @return the visitor result */ - visitGroup_by_list?: (ctx: Group_by_listContext) => Result; + visitFrom_in?: (ctx: From_inContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.group_by_item`. + * Visit a parse tree produced by `PostgreSqlParser.grantstmt`. * @param ctx the parse tree * @return the visitor result */ - visitGroup_by_item?: (ctx: Group_by_itemContext) => Result; + visitGrantstmt?: (ctx: GrantstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.empty_grouping_set`. + * Visit a parse tree produced by `PostgreSqlParser.revokestmt`. * @param ctx the parse tree * @return the visitor result */ - visitEmpty_grouping_set?: (ctx: Empty_grouping_setContext) => Result; + visitRevokestmt?: (ctx: RevokestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.rollup_clause`. + * Visit a parse tree produced by `PostgreSqlParser.privileges`. * @param ctx the parse tree * @return the visitor result */ - visitRollup_clause?: (ctx: Rollup_clauseContext) => Result; + visitPrivileges?: (ctx: PrivilegesContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.cube_clause`. + * Visit a parse tree produced by `PostgreSqlParser.beforeprivilegeselect`. * @param ctx the parse tree * @return the visitor result */ - visitCube_clause?: (ctx: Cube_clauseContext) => Result; + visitBeforeprivilegeselect?: (ctx: BeforeprivilegeselectContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.grouping_sets_clause`. + * Visit a parse tree produced by `PostgreSqlParser.privilege`. * @param ctx the parse tree * @return the visitor result */ - visitGrouping_sets_clause?: (ctx: Grouping_sets_clauseContext) => Result; + visitPrivilege?: (ctx: PrivilegeContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.having_clause`. + * Visit a parse tree produced by `PostgreSqlParser.privilege_target`. * @param ctx the parse tree * @return the visitor result */ - visitHaving_clause?: (ctx: Having_clauseContext) => Result; + visitPrivilege_target?: (ctx: Privilege_targetContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.for_locking_clause`. + * Visit a parse tree produced by `PostgreSqlParser.grantee_list`. * @param ctx the parse tree * @return the visitor result */ - visitFor_locking_clause?: (ctx: For_locking_clauseContext) => Result; + visitGrantee_list?: (ctx: Grantee_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_for_locking_clause`. + * Visit a parse tree produced by `PostgreSqlParser.grantrolestmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_for_locking_clause?: (ctx: Opt_for_locking_clauseContext) => Result; + visitGrantrolestmt?: (ctx: GrantrolestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.for_locking_items`. + * Visit a parse tree produced by `PostgreSqlParser.revokerolestmt`. * @param ctx the parse tree * @return the visitor result */ - visitFor_locking_items?: (ctx: For_locking_itemsContext) => Result; + visitRevokerolestmt?: (ctx: RevokerolestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.for_locking_item`. + * Visit a parse tree produced by `PostgreSqlParser.alterdefaultprivilegesstmt`. * @param ctx the parse tree * @return the visitor result */ - visitFor_locking_item?: (ctx: For_locking_itemContext) => Result; + visitAlterdefaultprivilegesstmt?: (ctx: AlterdefaultprivilegesstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.for_locking_strength`. + * Visit a parse tree produced by `PostgreSqlParser.defaclaction`. * @param ctx the parse tree * @return the visitor result */ - visitFor_locking_strength?: (ctx: For_locking_strengthContext) => Result; + visitDefaclaction?: (ctx: DefaclactionContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.locked_rels_list`. + * Visit a parse tree produced by `PostgreSqlParser.defacl_privilege_target`. * @param ctx the parse tree * @return the visitor result */ - visitLocked_rels_list?: (ctx: Locked_rels_listContext) => Result; + visitDefacl_privilege_target?: (ctx: Defacl_privilege_targetContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.values_clause`. + * Visit a parse tree produced by `PostgreSqlParser.indexstmt`. * @param ctx the parse tree * @return the visitor result */ - visitValues_clause?: (ctx: Values_clauseContext) => Result; + visitIndexstmt?: (ctx: IndexstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.from_clause`. + * Visit a parse tree produced by `PostgreSqlParser.index_params`. * @param ctx the parse tree * @return the visitor result */ - visitFrom_clause?: (ctx: From_clauseContext) => Result; + visitIndex_params?: (ctx: Index_paramsContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.from_list`. + * Visit a parse tree produced by `PostgreSqlParser.index_elem`. * @param ctx the parse tree * @return the visitor result */ - visitFrom_list?: (ctx: From_listContext) => Result; + visitIndex_elem?: (ctx: Index_elemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.table_ref`. + * Visit a parse tree produced by `PostgreSqlParser.createfunctionstmt`. * @param ctx the parse tree * @return the visitor result */ - visitTable_ref?: (ctx: Table_refContext) => Result; + visitCreatefunctionstmt?: (ctx: CreatefunctionstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.alias_clause`. + * Visit a parse tree produced by `PostgreSqlParser.opt_or_replace`. * @param ctx the parse tree * @return the visitor result */ - visitAlias_clause?: (ctx: Alias_clauseContext) => Result; + visitOpt_or_replace?: (ctx: Opt_or_replaceContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_alias_clause`. + * Visit a parse tree produced by `PostgreSqlParser.func_args`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_alias_clause?: (ctx: Opt_alias_clauseContext) => Result; + visitFunc_args?: (ctx: Func_argsContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.func_alias_clause`. + * Visit a parse tree produced by `PostgreSqlParser.func_args_list`. * @param ctx the parse tree * @return the visitor result */ - visitFunc_alias_clause?: (ctx: Func_alias_clauseContext) => Result; + visitFunc_args_list?: (ctx: Func_args_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.join_type`. + * Visit a parse tree produced by `PostgreSqlParser.routine_with_argtypes_list`. * @param ctx the parse tree * @return the visitor result */ - visitJoin_type?: (ctx: Join_typeContext) => Result; + visitRoutine_with_argtypes_list?: (ctx: Routine_with_argtypes_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.join_qual`. + * Visit a parse tree produced by `PostgreSqlParser.routine_with_argtypes`. * @param ctx the parse tree * @return the visitor result */ - visitJoin_qual?: (ctx: Join_qualContext) => Result; + visitRoutine_with_argtypes?: (ctx: Routine_with_argtypesContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.relation_expr`. + * Visit a parse tree produced by `PostgreSqlParser.procedure_with_argtypes_list`. * @param ctx the parse tree * @return the visitor result */ - visitRelation_expr?: (ctx: Relation_exprContext) => Result; + visitProcedure_with_argtypes_list?: (ctx: Procedure_with_argtypes_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.view_relation_expr`. + * Visit a parse tree produced by `PostgreSqlParser.procedure_with_argtypes`. * @param ctx the parse tree * @return the visitor result */ - visitView_relation_expr?: (ctx: View_relation_exprContext) => Result; + visitProcedure_with_argtypes?: (ctx: Procedure_with_argtypesContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.publication_relation_expr`. + * Visit a parse tree produced by `PostgreSqlParser.function_with_argtypes_list`. * @param ctx the parse tree * @return the visitor result */ - visitPublication_relation_expr?: (ctx: Publication_relation_exprContext) => Result; + visitFunction_with_argtypes_list?: (ctx: Function_with_argtypes_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.relation_expr_list`. + * Visit a parse tree produced by `PostgreSqlParser.function_with_argtypes`. * @param ctx the parse tree * @return the visitor result */ - visitRelation_expr_list?: (ctx: Relation_expr_listContext) => Result; + visitFunction_with_argtypes?: (ctx: Function_with_argtypesContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.publication_relation_expr_list`. + * Visit a parse tree produced by `PostgreSqlParser.func_arg`. * @param ctx the parse tree * @return the visitor result */ - visitPublication_relation_expr_list?: (ctx: Publication_relation_expr_listContext) => Result; + visitFunc_arg?: (ctx: Func_argContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.relation_expr_opt_alias`. + * Visit a parse tree produced by `PostgreSqlParser.arg_class`. * @param ctx the parse tree * @return the visitor result */ - visitRelation_expr_opt_alias?: (ctx: Relation_expr_opt_aliasContext) => Result; + visitArg_class?: (ctx: Arg_classContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.tablesample_clause`. + * Visit a parse tree produced by `PostgreSqlParser.func_type`. * @param ctx the parse tree * @return the visitor result */ - visitTablesample_clause?: (ctx: Tablesample_clauseContext) => Result; + visitFunc_type?: (ctx: Func_typeContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_repeatable_clause`. + * Visit a parse tree produced by `PostgreSqlParser.func_arg_with_default`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_repeatable_clause?: (ctx: Opt_repeatable_clauseContext) => Result; + visitFunc_arg_with_default?: (ctx: Func_arg_with_defaultContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.func_table`. + * Visit a parse tree produced by `PostgreSqlParser.aggr_args`. * @param ctx the parse tree * @return the visitor result */ - visitFunc_table?: (ctx: Func_tableContext) => Result; + visitAggr_args?: (ctx: Aggr_argsContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.rowsfrom_item`. + * Visit a parse tree produced by `PostgreSqlParser.aggregate_with_argtypes`. * @param ctx the parse tree * @return the visitor result */ - visitRowsfrom_item?: (ctx: Rowsfrom_itemContext) => Result; + visitAggregate_with_argtypes?: (ctx: Aggregate_with_argtypesContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.rowsfrom_list`. + * Visit a parse tree produced by `PostgreSqlParser.common_func_opt_item`. * @param ctx the parse tree * @return the visitor result */ - visitRowsfrom_list?: (ctx: Rowsfrom_listContext) => Result; + visitCommon_func_opt_item?: (ctx: Common_func_opt_itemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_col_def_list`. + * Visit a parse tree produced by `PostgreSqlParser.createfunc_opt_item`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_col_def_list?: (ctx: Opt_col_def_listContext) => Result; + visitCreatefunc_opt_item?: (ctx: Createfunc_opt_itemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_ordinality`. + * Visit a parse tree produced by `PostgreSqlParser.opt_definition`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_ordinality?: (ctx: Opt_ordinalityContext) => Result; + visitOpt_definition?: (ctx: Opt_definitionContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.where_clause`. + * Visit a parse tree produced by `PostgreSqlParser.table_func_column`. * @param ctx the parse tree * @return the visitor result */ - visitWhere_clause?: (ctx: Where_clauseContext) => Result; + visitTable_func_column?: (ctx: Table_func_columnContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.where_or_current_clause`. + * Visit a parse tree produced by `PostgreSqlParser.alterfunctionstmt`. * @param ctx the parse tree * @return the visitor result */ - visitWhere_or_current_clause?: (ctx: Where_or_current_clauseContext) => Result; + visitAlterfunctionstmt?: (ctx: AlterfunctionstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opttablefuncelementlist`. + * Visit a parse tree produced by `PostgreSqlParser.removefuncstmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpttablefuncelementlist?: (ctx: OpttablefuncelementlistContext) => Result; + visitRemovefuncstmt?: (ctx: RemovefuncstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.tablefuncelementlist`. + * Visit a parse tree produced by `PostgreSqlParser.removeaggrstmt`. * @param ctx the parse tree * @return the visitor result */ - visitTablefuncelementlist?: (ctx: TablefuncelementlistContext) => Result; + visitRemoveaggrstmt?: (ctx: RemoveaggrstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.tablefuncelement`. + * Visit a parse tree produced by `PostgreSqlParser.removeoperstmt`. * @param ctx the parse tree * @return the visitor result */ - visitTablefuncelement?: (ctx: TablefuncelementContext) => Result; + visitRemoveoperstmt?: (ctx: RemoveoperstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xmltable`. + * Visit a parse tree produced by `PostgreSqlParser.oper_argtypes`. * @param ctx the parse tree * @return the visitor result */ - visitXmltable?: (ctx: XmltableContext) => Result; + visitOper_argtypes?: (ctx: Oper_argtypesContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xmltable_column_list`. + * Visit a parse tree produced by `PostgreSqlParser.any_operator`. * @param ctx the parse tree * @return the visitor result */ - visitXmltable_column_list?: (ctx: Xmltable_column_listContext) => Result; + visitAny_operator?: (ctx: Any_operatorContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xmltable_column_el`. + * Visit a parse tree produced by `PostgreSqlParser.operator_with_argtypes`. * @param ctx the parse tree * @return the visitor result */ - visitXmltable_column_el?: (ctx: Xmltable_column_elContext) => Result; + visitOperator_with_argtypes?: (ctx: Operator_with_argtypesContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xmltable_column_option_list`. + * Visit a parse tree produced by `PostgreSqlParser.dostmt`. * @param ctx the parse tree * @return the visitor result */ - visitXmltable_column_option_list?: (ctx: Xmltable_column_option_listContext) => Result; + visitDostmt?: (ctx: DostmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xmltable_column_option_el`. + * Visit a parse tree produced by `PostgreSqlParser.createcaststmt`. * @param ctx the parse tree * @return the visitor result */ - visitXmltable_column_option_el?: (ctx: Xmltable_column_option_elContext) => Result; + visitCreatecaststmt?: (ctx: CreatecaststmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xml_namespace_list`. + * Visit a parse tree produced by `PostgreSqlParser.opt_if_exists`. * @param ctx the parse tree * @return the visitor result */ - visitXml_namespace_list?: (ctx: Xml_namespace_listContext) => Result; + visitOpt_if_exists?: (ctx: Opt_if_existsContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xml_namespace_el`. + * Visit a parse tree produced by `PostgreSqlParser.createtransformstmt`. * @param ctx the parse tree * @return the visitor result */ - visitXml_namespace_el?: (ctx: Xml_namespace_elContext) => Result; + visitCreatetransformstmt?: (ctx: CreatetransformstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.typename`. + * Visit a parse tree produced by `PostgreSqlParser.sql_with_function`. * @param ctx the parse tree * @return the visitor result */ - visitTypename?: (ctx: TypenameContext) => Result; + visitSql_with_function?: (ctx: Sql_with_functionContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_array_bounds`. + * Visit a parse tree produced by `PostgreSqlParser.reindexstmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_array_bounds?: (ctx: Opt_array_boundsContext) => Result; + visitReindexstmt?: (ctx: ReindexstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.simpletypename`. + * Visit a parse tree produced by `PostgreSqlParser.altertblspcstmt`. * @param ctx the parse tree * @return the visitor result */ - visitSimpletypename?: (ctx: SimpletypenameContext) => Result; + visitAltertblspcstmt?: (ctx: AltertblspcstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.consttypename`. + * Visit a parse tree produced by `PostgreSqlParser.renamestmt`. * @param ctx the parse tree * @return the visitor result */ - visitConsttypename?: (ctx: ConsttypenameContext) => Result; + visitRenamestmt?: (ctx: RenamestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.generictype`. + * Visit a parse tree produced by `PostgreSqlParser.alterobjectdependsstmt`. * @param ctx the parse tree * @return the visitor result */ - visitGenerictype?: (ctx: GenerictypeContext) => Result; + visitAlterobjectdependsstmt?: (ctx: AlterobjectdependsstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_type_modifiers`. + * Visit a parse tree produced by `PostgreSqlParser.alterobjectschemastmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_type_modifiers?: (ctx: Opt_type_modifiersContext) => Result; + visitAlterobjectschemastmt?: (ctx: AlterobjectschemastmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.numeric`. + * Visit a parse tree produced by `PostgreSqlParser.alteroperatorstmt`. * @param ctx the parse tree * @return the visitor result */ - visitNumeric?: (ctx: NumericContext) => Result; + visitAlteroperatorstmt?: (ctx: AlteroperatorstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_float`. + * Visit a parse tree produced by `PostgreSqlParser.operator_def_list`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_float?: (ctx: Opt_floatContext) => Result; + visitOperator_def_list?: (ctx: Operator_def_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.bit`. + * Visit a parse tree produced by `PostgreSqlParser.operator_def_elem`. * @param ctx the parse tree * @return the visitor result */ - visitBit?: (ctx: BitContext) => Result; + visitOperator_def_elem?: (ctx: Operator_def_elemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.constbit`. + * Visit a parse tree produced by `PostgreSqlParser.altertypestmt`. * @param ctx the parse tree * @return the visitor result */ - visitConstbit?: (ctx: ConstbitContext) => Result; + visitAltertypestmt?: (ctx: AltertypestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.bitwithlength`. + * Visit a parse tree produced by `PostgreSqlParser.alterownerstmt`. * @param ctx the parse tree * @return the visitor result */ - visitBitwithlength?: (ctx: BitwithlengthContext) => Result; + visitAlterownerstmt?: (ctx: AlterownerstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.bitwithoutlength`. + * Visit a parse tree produced by `PostgreSqlParser.createpublicationstmt`. * @param ctx the parse tree * @return the visitor result */ - visitBitwithoutlength?: (ctx: BitwithoutlengthContext) => Result; + visitCreatepublicationstmt?: (ctx: CreatepublicationstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.character`. + * Visit a parse tree produced by `PostgreSqlParser.alterpublicationstmt`. * @param ctx the parse tree * @return the visitor result */ - visitCharacter?: (ctx: CharacterContext) => Result; + visitAlterpublicationstmt?: (ctx: AlterpublicationstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.constcharacter`. + * Visit a parse tree produced by `PostgreSqlParser.createsubscriptionstmt`. * @param ctx the parse tree * @return the visitor result */ - visitConstcharacter?: (ctx: ConstcharacterContext) => Result; + visitCreatesubscriptionstmt?: (ctx: CreatesubscriptionstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.character_c`. + * Visit a parse tree produced by `PostgreSqlParser.altersubscriptionstmt`. * @param ctx the parse tree * @return the visitor result */ - visitCharacter_c?: (ctx: Character_cContext) => Result; + visitAltersubscriptionstmt?: (ctx: AltersubscriptionstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_varying`. + * Visit a parse tree produced by `PostgreSqlParser.rulestmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_varying?: (ctx: Opt_varyingContext) => Result; + visitRulestmt?: (ctx: RulestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.constdatetime`. + * Visit a parse tree produced by `PostgreSqlParser.ruleactionstmt`. * @param ctx the parse tree * @return the visitor result */ - visitConstdatetime?: (ctx: ConstdatetimeContext) => Result; + visitRuleactionstmt?: (ctx: RuleactionstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.constinterval`. + * Visit a parse tree produced by `PostgreSqlParser.notifystmt`. * @param ctx the parse tree * @return the visitor result */ - visitConstinterval?: (ctx: ConstintervalContext) => Result; + visitNotifystmt?: (ctx: NotifystmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_timezone`. + * Visit a parse tree produced by `PostgreSqlParser.notify_payload`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_timezone?: (ctx: Opt_timezoneContext) => Result; + visitNotify_payload?: (ctx: Notify_payloadContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_interval`. + * Visit a parse tree produced by `PostgreSqlParser.listenstmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_interval?: (ctx: Opt_intervalContext) => Result; + visitListenstmt?: (ctx: ListenstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.interval_second`. + * Visit a parse tree produced by `PostgreSqlParser.unlistenstmt`. * @param ctx the parse tree * @return the visitor result */ - visitInterval_second?: (ctx: Interval_secondContext) => Result; + visitUnlistenstmt?: (ctx: UnlistenstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_escape`. + * Visit a parse tree produced by `PostgreSqlParser.transactionstmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_escape?: (ctx: Opt_escapeContext) => Result; + visitTransactionstmt?: (ctx: TransactionstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr`. + * Visit a parse tree produced by `PostgreSqlParser.opt_transaction`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr?: (ctx: A_exprContext) => Result; + visitOpt_transaction?: (ctx: Opt_transactionContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_qual`. + * Visit a parse tree produced by `PostgreSqlParser.transaction_mode_item`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_qual?: (ctx: A_expr_qualContext) => Result; + visitTransaction_mode_item?: (ctx: Transaction_mode_itemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_lessless`. + * Visit a parse tree produced by `PostgreSqlParser.transaction_mode_list`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_lessless?: (ctx: A_expr_lesslessContext) => Result; + visitTransaction_mode_list?: (ctx: Transaction_mode_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_or`. + * Visit a parse tree produced by the `createView` + * labeled alternative in `PostgreSqlParser.viewstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_or?: (ctx: A_expr_orContext) => Result; + visitCreateView?: (ctx: CreateViewContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_and`. + * Visit a parse tree produced by `PostgreSqlParser.loadstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_and?: (ctx: A_expr_andContext) => Result; + visitLoadstmt?: (ctx: LoadstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_in`. + * Visit a parse tree produced by the `createDatabase` + * labeled alternative in `PostgreSqlParser.createdbstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_in?: (ctx: A_expr_inContext) => Result; + visitCreateDatabase?: (ctx: CreateDatabaseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_unary_not`. + * Visit a parse tree produced by `PostgreSqlParser.createdb_opt_item`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_unary_not?: (ctx: A_expr_unary_notContext) => Result; + visitCreatedb_opt_item?: (ctx: Createdb_opt_itemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_isnull`. + * Visit a parse tree produced by `PostgreSqlParser.alterdatabasestmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_isnull?: (ctx: A_expr_isnullContext) => Result; + visitAlterdatabasestmt?: (ctx: AlterdatabasestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_is_not`. + * Visit a parse tree produced by `PostgreSqlParser.alterdatabasesetstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_is_not?: (ctx: A_expr_is_notContext) => Result; + visitAlterdatabasesetstmt?: (ctx: AlterdatabasesetstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_compare`. + * Visit a parse tree produced by `PostgreSqlParser.altercollationstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_compare?: (ctx: A_expr_compareContext) => Result; + visitAltercollationstmt?: (ctx: AltercollationstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_like`. + * Visit a parse tree produced by `PostgreSqlParser.altersystemstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_like?: (ctx: A_expr_likeContext) => Result; + visitAltersystemstmt?: (ctx: AltersystemstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_qual_op`. + * Visit a parse tree produced by `PostgreSqlParser.createdomainstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_qual_op?: (ctx: A_expr_qual_opContext) => Result; + visitCreatedomainstmt?: (ctx: CreatedomainstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_unary_qualop`. + * Visit a parse tree produced by `PostgreSqlParser.alterdomainstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_unary_qualop?: (ctx: A_expr_unary_qualopContext) => Result; + visitAlterdomainstmt?: (ctx: AlterdomainstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_add`. + * Visit a parse tree produced by `PostgreSqlParser.altertsdictionarystmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_add?: (ctx: A_expr_addContext) => Result; + visitAltertsdictionarystmt?: (ctx: AltertsdictionarystmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_mul`. + * Visit a parse tree produced by `PostgreSqlParser.altertsconfigurationstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_mul?: (ctx: A_expr_mulContext) => Result; + visitAltertsconfigurationstmt?: (ctx: AltertsconfigurationstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_caret`. + * Visit a parse tree produced by `PostgreSqlParser.createconversionstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_caret?: (ctx: A_expr_caretContext) => Result; + visitCreateconversionstmt?: (ctx: CreateconversionstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_unary_sign`. + * Visit a parse tree produced by `PostgreSqlParser.clusterstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_unary_sign?: (ctx: A_expr_unary_signContext) => Result; + visitClusterstmt?: (ctx: ClusterstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_at_time_zone`. + * Visit a parse tree produced by `PostgreSqlParser.vacuumstmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_at_time_zone?: (ctx: A_expr_at_time_zoneContext) => Result; + visitVacuumstmt?: (ctx: VacuumstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_collate`. + * Visit a parse tree produced by `PostgreSqlParser.analyzestmt`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_collate?: (ctx: A_expr_collateContext) => Result; + visitAnalyzestmt?: (ctx: AnalyzestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.a_expr_typecast`. + * Visit a parse tree produced by `PostgreSqlParser.analyze_keyword`. * @param ctx the parse tree * @return the visitor result */ - visitA_expr_typecast?: (ctx: A_expr_typecastContext) => Result; + visitAnalyze_keyword?: (ctx: Analyze_keywordContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.b_expr`. + * Visit a parse tree produced by `PostgreSqlParser.vac_analyze_option_elem`. * @param ctx the parse tree * @return the visitor result */ - visitB_expr?: (ctx: B_exprContext) => Result; + visitVac_analyze_option_elem?: (ctx: Vac_analyze_option_elemContext) => Result; /** - * Visit a parse tree produced by the `c_expr_exists` - * labeled alternative in `PostgreSqlParser.c_expr`. + * Visit a parse tree produced by `PostgreSqlParser.analyze_option_elem`. * @param ctx the parse tree * @return the visitor result */ - visitC_expr_exists?: (ctx: C_expr_existsContext) => Result; + visitAnalyze_option_elem?: (ctx: Analyze_option_elemContext) => Result; /** - * Visit a parse tree produced by the `c_expr_expr` - * labeled alternative in `PostgreSqlParser.c_expr`. + * Visit a parse tree produced by `PostgreSqlParser.opt_verbose`. * @param ctx the parse tree * @return the visitor result */ - visitC_expr_expr?: (ctx: C_expr_exprContext) => Result; + visitOpt_verbose?: (ctx: Opt_verboseContext) => Result; /** - * Visit a parse tree produced by the `c_expr_case` - * labeled alternative in `PostgreSqlParser.c_expr`. + * Visit a parse tree produced by `PostgreSqlParser.vacuum_relation`. * @param ctx the parse tree * @return the visitor result */ - visitC_expr_case?: (ctx: C_expr_caseContext) => Result; + visitVacuum_relation?: (ctx: Vacuum_relationContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.plsqlvariablename`. + * Visit a parse tree produced by `PostgreSqlParser.vacuum_relation_list`. * @param ctx the parse tree * @return the visitor result */ - visitPlsqlvariablename?: (ctx: PlsqlvariablenameContext) => Result; + visitVacuum_relation_list?: (ctx: Vacuum_relation_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.func_application`. + * Visit a parse tree produced by `PostgreSqlParser.explainstmt`. * @param ctx the parse tree * @return the visitor result */ - visitFunc_application?: (ctx: Func_applicationContext) => Result; + visitExplainstmt?: (ctx: ExplainstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.func_expr`. + * Visit a parse tree produced by `PostgreSqlParser.explainablestmt`. * @param ctx the parse tree * @return the visitor result */ - visitFunc_expr?: (ctx: Func_exprContext) => Result; + visitExplainablestmt?: (ctx: ExplainablestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.func_expr_windowless`. + * Visit a parse tree produced by `PostgreSqlParser.explain_option_list`. * @param ctx the parse tree * @return the visitor result */ - visitFunc_expr_windowless?: (ctx: Func_expr_windowlessContext) => Result; + visitExplain_option_list?: (ctx: Explain_option_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.func_expr_common_subexpr`. + * Visit a parse tree produced by `PostgreSqlParser.preparestmt`. * @param ctx the parse tree * @return the visitor result */ - visitFunc_expr_common_subexpr?: (ctx: Func_expr_common_subexprContext) => Result; + visitPreparestmt?: (ctx: PreparestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xml_root_version`. + * Visit a parse tree produced by `PostgreSqlParser.prep_type_clause`. * @param ctx the parse tree * @return the visitor result */ - visitXml_root_version?: (ctx: Xml_root_versionContext) => Result; + visitPrep_type_clause?: (ctx: Prep_type_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_xml_root_standalone`. + * Visit a parse tree produced by `PostgreSqlParser.preparablestmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_xml_root_standalone?: (ctx: Opt_xml_root_standaloneContext) => Result; + visitPreparablestmt?: (ctx: PreparablestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xml_attributes`. + * Visit a parse tree produced by `PostgreSqlParser.executestmt`. * @param ctx the parse tree * @return the visitor result */ - visitXml_attributes?: (ctx: Xml_attributesContext) => Result; + visitExecutestmt?: (ctx: ExecutestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xml_attribute_list`. + * Visit a parse tree produced by `PostgreSqlParser.execute_param_clause`. * @param ctx the parse tree * @return the visitor result */ - visitXml_attribute_list?: (ctx: Xml_attribute_listContext) => Result; + visitExecute_param_clause?: (ctx: Execute_param_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xml_attribute_el`. + * Visit a parse tree produced by `PostgreSqlParser.deallocatestmt`. * @param ctx the parse tree * @return the visitor result */ - visitXml_attribute_el?: (ctx: Xml_attribute_elContext) => Result; + visitDeallocatestmt?: (ctx: DeallocatestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.document_or_content`. + * Visit a parse tree produced by the `insertStatement` + * labeled alternative in `PostgreSqlParser.insertstmt`. * @param ctx the parse tree * @return the visitor result */ - visitDocument_or_content?: (ctx: Document_or_contentContext) => Result; + visitInsertStatement?: (ctx: InsertStatementContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xml_whitespace_option`. + * Visit a parse tree produced by `PostgreSqlParser.insert_rest`. * @param ctx the parse tree * @return the visitor result */ - visitXml_whitespace_option?: (ctx: Xml_whitespace_optionContext) => Result; + visitInsert_rest?: (ctx: Insert_restContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xmlexists_argument`. + * Visit a parse tree produced by `PostgreSqlParser.insert_column_list`. * @param ctx the parse tree * @return the visitor result */ - visitXmlexists_argument?: (ctx: Xmlexists_argumentContext) => Result; + visitInsert_column_list?: (ctx: Insert_column_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xml_passing_mech`. + * Visit a parse tree produced by `PostgreSqlParser.insert_column_item`. * @param ctx the parse tree * @return the visitor result */ - visitXml_passing_mech?: (ctx: Xml_passing_mechContext) => Result; + visitInsert_column_item?: (ctx: Insert_column_itemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.within_group_clause`. + * Visit a parse tree produced by `PostgreSqlParser.returning_clause`. * @param ctx the parse tree * @return the visitor result */ - visitWithin_group_clause?: (ctx: Within_group_clauseContext) => Result; + visitReturning_clause?: (ctx: Returning_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.filter_clause`. + * Visit a parse tree produced by `PostgreSqlParser.deletestmt`. * @param ctx the parse tree * @return the visitor result */ - visitFilter_clause?: (ctx: Filter_clauseContext) => Result; + visitDeletestmt?: (ctx: DeletestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.window_clause`. + * Visit a parse tree produced by `PostgreSqlParser.lockstmt`. * @param ctx the parse tree * @return the visitor result */ - visitWindow_clause?: (ctx: Window_clauseContext) => Result; + visitLockstmt?: (ctx: LockstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.window_definition_list`. + * Visit a parse tree produced by `PostgreSqlParser.updatestmt`. * @param ctx the parse tree * @return the visitor result */ - visitWindow_definition_list?: (ctx: Window_definition_listContext) => Result; + visitUpdatestmt?: (ctx: UpdatestmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.window_definition`. + * Visit a parse tree produced by `PostgreSqlParser.set_clause_list`. * @param ctx the parse tree * @return the visitor result */ - visitWindow_definition?: (ctx: Window_definitionContext) => Result; + visitSet_clause_list?: (ctx: Set_clause_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.over_clause`. + * Visit a parse tree produced by `PostgreSqlParser.set_clause`. * @param ctx the parse tree * @return the visitor result */ - visitOver_clause?: (ctx: Over_clauseContext) => Result; + visitSet_clause?: (ctx: Set_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.window_specification`. + * Visit a parse tree produced by `PostgreSqlParser.declarecursorstmt`. * @param ctx the parse tree * @return the visitor result */ - visitWindow_specification?: (ctx: Window_specificationContext) => Result; + visitDeclarecursorstmt?: (ctx: DeclarecursorstmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_existing_window_name`. + * Visit a parse tree produced by the `selectStatement` + * labeled alternative in `PostgreSqlParser.selectstmt`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_existing_window_name?: (ctx: Opt_existing_window_nameContext) => Result; + visitSelectStatement?: (ctx: SelectStatementContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_partition_clause`. + * Visit a parse tree produced by `PostgreSqlParser.select_with_parens`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_partition_clause?: (ctx: Opt_partition_clauseContext) => Result; + visitSelect_with_parens?: (ctx: Select_with_parensContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_frame_clause`. + * Visit a parse tree produced by `PostgreSqlParser.select_no_parens`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_frame_clause?: (ctx: Opt_frame_clauseContext) => Result; + visitSelect_no_parens?: (ctx: Select_no_parensContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.frame_extent`. + * Visit a parse tree produced by `PostgreSqlParser.select_clause`. * @param ctx the parse tree * @return the visitor result */ - visitFrame_extent?: (ctx: Frame_extentContext) => Result; + visitSelect_clause?: (ctx: Select_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.frame_bound`. + * Visit a parse tree produced by `PostgreSqlParser.simple_select`. * @param ctx the parse tree * @return the visitor result */ - visitFrame_bound?: (ctx: Frame_boundContext) => Result; + visitSimple_select?: (ctx: Simple_selectContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_window_exclusion_clause`. + * Visit a parse tree produced by `PostgreSqlParser.set_operator_with_all_or_distinct`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_window_exclusion_clause?: (ctx: Opt_window_exclusion_clauseContext) => Result; + visitSet_operator_with_all_or_distinct?: (ctx: Set_operator_with_all_or_distinctContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.row`. + * Visit a parse tree produced by `PostgreSqlParser.with_clause`. * @param ctx the parse tree * @return the visitor result */ - visitRow?: (ctx: RowContext) => Result; + visitWith_clause?: (ctx: With_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.explicit_row`. + * Visit a parse tree produced by `PostgreSqlParser.common_table_expr`. * @param ctx the parse tree * @return the visitor result */ - visitExplicit_row?: (ctx: Explicit_rowContext) => Result; + visitCommon_table_expr?: (ctx: Common_table_exprContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.implicit_row`. + * Visit a parse tree produced by `PostgreSqlParser.search_cluase`. * @param ctx the parse tree * @return the visitor result */ - visitImplicit_row?: (ctx: Implicit_rowContext) => Result; + visitSearch_cluase?: (ctx: Search_cluaseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.sub_type`. + * Visit a parse tree produced by `PostgreSqlParser.cycle_cluase`. * @param ctx the parse tree * @return the visitor result */ - visitSub_type?: (ctx: Sub_typeContext) => Result; + visitCycle_cluase?: (ctx: Cycle_cluaseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.all_op`. + * Visit a parse tree produced by `PostgreSqlParser.into_clause`. * @param ctx the parse tree * @return the visitor result */ - visitAll_op?: (ctx: All_opContext) => Result; + visitInto_clause?: (ctx: Into_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.mathop`. + * Visit a parse tree produced by `PostgreSqlParser.opttempTableName`. * @param ctx the parse tree * @return the visitor result */ - visitMathop?: (ctx: MathopContext) => Result; + visitOpttempTableName?: (ctx: OpttempTableNameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.qual_op`. + * Visit a parse tree produced by `PostgreSqlParser.distinct_clause`. * @param ctx the parse tree * @return the visitor result */ - visitQual_op?: (ctx: Qual_opContext) => Result; + visitDistinct_clause?: (ctx: Distinct_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.qual_all_op`. + * Visit a parse tree produced by `PostgreSqlParser.sort_clause`. * @param ctx the parse tree * @return the visitor result */ - visitQual_all_op?: (ctx: Qual_all_opContext) => Result; + visitSort_clause?: (ctx: Sort_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.subquery_Op`. + * Visit a parse tree produced by `PostgreSqlParser.sortby`. * @param ctx the parse tree * @return the visitor result */ - visitSubquery_Op?: (ctx: Subquery_OpContext) => Result; + visitSortby?: (ctx: SortbyContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.expr_list`. + * Visit a parse tree produced by `PostgreSqlParser.select_limit`. * @param ctx the parse tree * @return the visitor result */ - visitExpr_list?: (ctx: Expr_listContext) => Result; + visitSelect_limit?: (ctx: Select_limitContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.column_expr_list_noparen`. + * Visit a parse tree produced by `PostgreSqlParser.limit_clause`. * @param ctx the parse tree * @return the visitor result */ - visitColumn_expr_list_noparen?: (ctx: Column_expr_list_noparenContext) => Result; + visitLimit_clause?: (ctx: Limit_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.column_expr_list`. + * Visit a parse tree produced by `PostgreSqlParser.fetch_clause`. * @param ctx the parse tree * @return the visitor result */ - visitColumn_expr_list?: (ctx: Column_expr_listContext) => Result; + visitFetch_clause?: (ctx: Fetch_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.column_expr`. + * Visit a parse tree produced by `PostgreSqlParser.offset_clause`. * @param ctx the parse tree * @return the visitor result */ - visitColumn_expr?: (ctx: Column_exprContext) => Result; + visitOffset_clause?: (ctx: Offset_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.column_expr_noparen`. + * Visit a parse tree produced by `PostgreSqlParser.select_fetch_first_value`. * @param ctx the parse tree * @return the visitor result */ - visitColumn_expr_noparen?: (ctx: Column_expr_noparenContext) => Result; + visitSelect_fetch_first_value?: (ctx: Select_fetch_first_valueContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.func_arg_list`. + * Visit a parse tree produced by `PostgreSqlParser.group_clause`. * @param ctx the parse tree * @return the visitor result */ - visitFunc_arg_list?: (ctx: Func_arg_listContext) => Result; + visitGroup_clause?: (ctx: Group_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.func_arg_expr`. + * Visit a parse tree produced by `PostgreSqlParser.group_by_list`. * @param ctx the parse tree * @return the visitor result */ - visitFunc_arg_expr?: (ctx: Func_arg_exprContext) => Result; + visitGroup_by_list?: (ctx: Group_by_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.type_list`. + * Visit a parse tree produced by `PostgreSqlParser.group_by_item`. * @param ctx the parse tree * @return the visitor result */ - visitType_list?: (ctx: Type_listContext) => Result; + visitGroup_by_item?: (ctx: Group_by_itemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.array_expr`. + * Visit a parse tree produced by `PostgreSqlParser.for_locking_clause`. * @param ctx the parse tree * @return the visitor result */ - visitArray_expr?: (ctx: Array_exprContext) => Result; + visitFor_locking_clause?: (ctx: For_locking_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.array_expr_list`. + * Visit a parse tree produced by `PostgreSqlParser.values_clause`. * @param ctx the parse tree * @return the visitor result */ - visitArray_expr_list?: (ctx: Array_expr_listContext) => Result; + visitValues_clause?: (ctx: Values_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.extract_list`. + * Visit a parse tree produced by `PostgreSqlParser.from_clause`. * @param ctx the parse tree * @return the visitor result */ - visitExtract_list?: (ctx: Extract_listContext) => Result; + visitFrom_clause?: (ctx: From_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.extract_arg`. + * Visit a parse tree produced by `PostgreSqlParser.from_list`. * @param ctx the parse tree * @return the visitor result */ - visitExtract_arg?: (ctx: Extract_argContext) => Result; + visitFrom_list?: (ctx: From_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.unicode_normal_form`. + * Visit a parse tree produced by `PostgreSqlParser.table_ref`. * @param ctx the parse tree * @return the visitor result */ - visitUnicode_normal_form?: (ctx: Unicode_normal_formContext) => Result; + visitTable_ref?: (ctx: Table_refContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.overlay_list`. + * Visit a parse tree produced by `PostgreSqlParser.alias_clause`. * @param ctx the parse tree * @return the visitor result */ - visitOverlay_list?: (ctx: Overlay_listContext) => Result; + visitAlias_clause?: (ctx: Alias_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.position_list`. + * Visit a parse tree produced by `PostgreSqlParser.func_alias_clause`. * @param ctx the parse tree * @return the visitor result */ - visitPosition_list?: (ctx: Position_listContext) => Result; + visitFunc_alias_clause?: (ctx: Func_alias_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.substr_list`. + * Visit a parse tree produced by `PostgreSqlParser.join_type`. * @param ctx the parse tree * @return the visitor result */ - visitSubstr_list?: (ctx: Substr_listContext) => Result; + visitJoin_type?: (ctx: Join_typeContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.trim_list`. + * Visit a parse tree produced by `PostgreSqlParser.join_qual`. * @param ctx the parse tree * @return the visitor result */ - visitTrim_list?: (ctx: Trim_listContext) => Result; + visitJoin_qual?: (ctx: Join_qualContext) => Result; /** - * Visit a parse tree produced by the `in_expr_select` - * labeled alternative in `PostgreSqlParser.in_expr`. + * Visit a parse tree produced by `PostgreSqlParser.relation_expr`. * @param ctx the parse tree * @return the visitor result */ - visitIn_expr_select?: (ctx: In_expr_selectContext) => Result; + visitRelation_expr?: (ctx: Relation_exprContext) => Result; /** - * Visit a parse tree produced by the `in_expr_list` - * labeled alternative in `PostgreSqlParser.in_expr`. + * Visit a parse tree produced by `PostgreSqlParser.publication_relation_expr`. * @param ctx the parse tree * @return the visitor result */ - visitIn_expr_list?: (ctx: In_expr_listContext) => Result; + visitPublication_relation_expr?: (ctx: Publication_relation_exprContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.case_expr`. + * Visit a parse tree produced by `PostgreSqlParser.relation_expr_list`. * @param ctx the parse tree * @return the visitor result */ - visitCase_expr?: (ctx: Case_exprContext) => Result; + visitRelation_expr_list?: (ctx: Relation_expr_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.when_clause_list`. + * Visit a parse tree produced by `PostgreSqlParser.relation_expr_opt_alias`. * @param ctx the parse tree * @return the visitor result */ - visitWhen_clause_list?: (ctx: When_clause_listContext) => Result; + visitRelation_expr_opt_alias?: (ctx: Relation_expr_opt_aliasContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.when_clause`. + * Visit a parse tree produced by `PostgreSqlParser.tablesample_clause`. * @param ctx the parse tree * @return the visitor result */ - visitWhen_clause?: (ctx: When_clauseContext) => Result; + visitTablesample_clause?: (ctx: Tablesample_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.case_default`. + * Visit a parse tree produced by `PostgreSqlParser.func_table`. * @param ctx the parse tree * @return the visitor result */ - visitCase_default?: (ctx: Case_defaultContext) => Result; + visitFunc_table?: (ctx: Func_tableContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.case_arg`. + * Visit a parse tree produced by `PostgreSqlParser.rowsfrom_item`. * @param ctx the parse tree * @return the visitor result */ - visitCase_arg?: (ctx: Case_argContext) => Result; + visitRowsfrom_item?: (ctx: Rowsfrom_itemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.columnref`. + * Visit a parse tree produced by `PostgreSqlParser.where_clause`. * @param ctx the parse tree * @return the visitor result */ - visitColumnref?: (ctx: ColumnrefContext) => Result; + visitWhere_clause?: (ctx: Where_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.indirection_el`. + * Visit a parse tree produced by `PostgreSqlParser.where_or_current_clause`. * @param ctx the parse tree * @return the visitor result */ - visitIndirection_el?: (ctx: Indirection_elContext) => Result; + visitWhere_or_current_clause?: (ctx: Where_or_current_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_slice_bound`. + * Visit a parse tree produced by `PostgreSqlParser.tablefuncelementlist`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_slice_bound?: (ctx: Opt_slice_boundContext) => Result; + visitTablefuncelementlist?: (ctx: TablefuncelementlistContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.indirection`. + * Visit a parse tree produced by `PostgreSqlParser.tablefuncelement`. * @param ctx the parse tree * @return the visitor result */ - visitIndirection?: (ctx: IndirectionContext) => Result; + visitTablefuncelement?: (ctx: TablefuncelementContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_indirection`. + * Visit a parse tree produced by `PostgreSqlParser.xmltable`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_indirection?: (ctx: Opt_indirectionContext) => Result; + visitXmltable?: (ctx: XmltableContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_target_list`. + * Visit a parse tree produced by `PostgreSqlParser.xmltable_column_el`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_target_list?: (ctx: Opt_target_listContext) => Result; + visitXmltable_column_el?: (ctx: Xmltable_column_elContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.target_list`. + * Visit a parse tree produced by `PostgreSqlParser.xml_namespace_el`. * @param ctx the parse tree * @return the visitor result */ - visitTarget_list?: (ctx: Target_listContext) => Result; + visitXml_namespace_el?: (ctx: Xml_namespace_elContext) => Result; /** - * Visit a parse tree produced by the `target_label` - * labeled alternative in `PostgreSqlParser.target_el`. + * Visit a parse tree produced by `PostgreSqlParser.typename`. * @param ctx the parse tree * @return the visitor result */ - visitTarget_label?: (ctx: Target_labelContext) => Result; + visitTypename?: (ctx: TypenameContext) => Result; /** - * Visit a parse tree produced by the `target_star` - * labeled alternative in `PostgreSqlParser.target_el`. + * Visit a parse tree produced by `PostgreSqlParser.simpletypename`. * @param ctx the parse tree * @return the visitor result */ - visitTarget_star?: (ctx: Target_starContext) => Result; + visitSimpletypename?: (ctx: SimpletypenameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.qualified_name_list`. + * Visit a parse tree produced by `PostgreSqlParser.consttypename`. * @param ctx the parse tree * @return the visitor result */ - visitQualified_name_list?: (ctx: Qualified_name_listContext) => Result; + visitConsttypename?: (ctx: ConsttypenameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.table_name_list`. + * Visit a parse tree produced by `PostgreSqlParser.numeric`. * @param ctx the parse tree * @return the visitor result */ - visitTable_name_list?: (ctx: Table_name_listContext) => Result; + visitNumeric?: (ctx: NumericContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.schema_name_list`. + * Visit a parse tree produced by `PostgreSqlParser.opt_float`. * @param ctx the parse tree * @return the visitor result */ - visitSchema_name_list?: (ctx: Schema_name_listContext) => Result; + visitOpt_float?: (ctx: Opt_floatContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.database_nameList`. + * Visit a parse tree produced by `PostgreSqlParser.bit`. * @param ctx the parse tree * @return the visitor result */ - visitDatabase_nameList?: (ctx: Database_nameListContext) => Result; + visitBit?: (ctx: BitContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.procedure_name_list`. + * Visit a parse tree produced by `PostgreSqlParser.character`. * @param ctx the parse tree * @return the visitor result */ - visitProcedure_name_list?: (ctx: Procedure_name_listContext) => Result; + visitCharacter?: (ctx: CharacterContext) => Result; /** - * Visit a parse tree produced by the `tablespaceNameCreate` - * labeled alternative in `PostgreSqlParser.tablespace_name_create`. + * Visit a parse tree produced by `PostgreSqlParser.constdatetime`. * @param ctx the parse tree * @return the visitor result */ - visitTablespaceNameCreate?: (ctx: TablespaceNameCreateContext) => Result; + visitConstdatetime?: (ctx: ConstdatetimeContext) => Result; /** - * Visit a parse tree produced by the `tablespaceName` - * labeled alternative in `PostgreSqlParser.tablespace_name`. + * Visit a parse tree produced by `PostgreSqlParser.opt_interval`. * @param ctx the parse tree * @return the visitor result */ - visitTablespaceName?: (ctx: TablespaceNameContext) => Result; + visitOpt_interval?: (ctx: Opt_intervalContext) => Result; /** - * Visit a parse tree produced by the `tableNameCreate` - * labeled alternative in `PostgreSqlParser.table_name_create`. + * Visit a parse tree produced by `PostgreSqlParser.interval_second`. * @param ctx the parse tree * @return the visitor result */ - visitTableNameCreate?: (ctx: TableNameCreateContext) => Result; + visitInterval_second?: (ctx: Interval_secondContext) => Result; /** - * Visit a parse tree produced by the `tableName` - * labeled alternative in `PostgreSqlParser.table_name`. + * Visit a parse tree produced by `PostgreSqlParser.comparisonOperator`. * @param ctx the parse tree * @return the visitor result */ - visitTableName?: (ctx: TableNameContext) => Result; + visitComparisonOperator?: (ctx: ComparisonOperatorContext) => Result; /** - * Visit a parse tree produced by the `viewNameCreate` - * labeled alternative in `PostgreSqlParser.view_name_create`. + * Visit a parse tree produced by `PostgreSqlParser.expression`. * @param ctx the parse tree * @return the visitor result */ - visitViewNameCreate?: (ctx: ViewNameCreateContext) => Result; + visitExpression?: (ctx: ExpressionContext) => Result; /** - * Visit a parse tree produced by the `viewName` - * labeled alternative in `PostgreSqlParser.view_name`. + * Visit a parse tree produced by the `logicalNot` + * labeled alternative in `PostgreSqlParser.booleanExpression`. * @param ctx the parse tree * @return the visitor result */ - visitViewName?: (ctx: ViewNameContext) => Result; + visitLogicalNot?: (ctx: LogicalNotContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.qualified_name`. + * Visit a parse tree produced by the `predicated` + * labeled alternative in `PostgreSqlParser.booleanExpression`. * @param ctx the parse tree * @return the visitor result */ - visitQualified_name?: (ctx: Qualified_nameContext) => Result; + visitPredicated?: (ctx: PredicatedContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.tablespace_name_list`. + * Visit a parse tree produced by the `logicalBinary` + * labeled alternative in `PostgreSqlParser.booleanExpression`. * @param ctx the parse tree * @return the visitor result */ - visitTablespace_name_list?: (ctx: Tablespace_name_listContext) => Result; + visitLogicalBinary?: (ctx: LogicalBinaryContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.name_list`. + * Visit a parse tree produced by the `comparison` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree * @return the visitor result */ - visitName_list?: (ctx: Name_listContext) => Result; + visitComparison?: (ctx: ComparisonContext) => Result; /** - * Visit a parse tree produced by the `databaseNameCreate` - * labeled alternative in `PostgreSqlParser.database_name_create`. + * Visit a parse tree produced by the `quantifiedComparison` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree * @return the visitor result */ - visitDatabaseNameCreate?: (ctx: DatabaseNameCreateContext) => Result; + visitQuantifiedComparison?: (ctx: QuantifiedComparisonContext) => Result; /** - * Visit a parse tree produced by the `databaseName` - * labeled alternative in `PostgreSqlParser.database_name`. + * Visit a parse tree produced by the `between` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree * @return the visitor result */ - visitDatabaseName?: (ctx: DatabaseNameContext) => Result; + visitBetween?: (ctx: BetweenContext) => Result; /** - * Visit a parse tree produced by the `schemaName` - * labeled alternative in `PostgreSqlParser.schema_name`. + * Visit a parse tree produced by the `inList` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree * @return the visitor result */ - visitSchemaName?: (ctx: SchemaNameContext) => Result; + visitInList?: (ctx: InListContext) => Result; /** - * Visit a parse tree produced by the `routineNameCreate` - * labeled alternative in `PostgreSqlParser.routine_name_create`. + * Visit a parse tree produced by the `inSubquery` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree * @return the visitor result */ - visitRoutineNameCreate?: (ctx: RoutineNameCreateContext) => Result; + visitInSubquery?: (ctx: InSubqueryContext) => Result; /** - * Visit a parse tree produced by the `routineName` - * labeled alternative in `PostgreSqlParser.routine_name`. + * Visit a parse tree produced by the `like` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree * @return the visitor result */ - visitRoutineName?: (ctx: RoutineNameContext) => Result; + visitLike?: (ctx: LikeContext) => Result; /** - * Visit a parse tree produced by the `procedureName` - * labeled alternative in `PostgreSqlParser.procedure_name`. + * Visit a parse tree produced by the `nullPredicate` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree * @return the visitor result */ - visitProcedureName?: (ctx: ProcedureNameContext) => Result; + visitNullPredicate?: (ctx: NullPredicateContext) => Result; /** - * Visit a parse tree produced by the `procedureNameCreate` - * labeled alternative in `PostgreSqlParser.procedure_name_create`. + * Visit a parse tree produced by the `distinctFrom` + * labeled alternative in `PostgreSqlParser.predicate`. * @param ctx the parse tree * @return the visitor result */ - visitProcedureNameCreate?: (ctx: ProcedureNameCreateContext) => Result; + visitDistinctFrom?: (ctx: DistinctFromContext) => Result; /** - * Visit a parse tree produced by the `columnName` - * labeled alternative in `PostgreSqlParser.column_name`. + * Visit a parse tree produced by the `valueExpressionDefault` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree * @return the visitor result */ - visitColumnName?: (ctx: ColumnNameContext) => Result; + visitValueExpressionDefault?: (ctx: ValueExpressionDefaultContext) => Result; /** - * Visit a parse tree produced by the `columnNameMatch` - * labeled alternative in `PostgreSqlParser.column_name`. + * Visit a parse tree produced by the `concatenation` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree * @return the visitor result */ - visitColumnNameMatch?: (ctx: ColumnNameMatchContext) => Result; + visitConcatenation?: (ctx: ConcatenationContext) => Result; /** - * Visit a parse tree produced by the `columnNameCreate` - * labeled alternative in `PostgreSqlParser.column_name_create`. + * Visit a parse tree produced by the `arithmeticBinary` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree * @return the visitor result */ - visitColumnNameCreate?: (ctx: ColumnNameCreateContext) => Result; + visitArithmeticBinary?: (ctx: ArithmeticBinaryContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.name`. + * Visit a parse tree produced by the `arithmeticUnary` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree * @return the visitor result */ - visitName?: (ctx: NameContext) => Result; + visitArithmeticUnary?: (ctx: ArithmeticUnaryContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.attr_name`. + * Visit a parse tree produced by the `atTimeZone` + * labeled alternative in `PostgreSqlParser.valueExpression`. * @param ctx the parse tree * @return the visitor result */ - visitAttr_name?: (ctx: Attr_nameContext) => Result; + visitAtTimeZone?: (ctx: AtTimeZoneContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.file_name`. + * Visit a parse tree produced by `PostgreSqlParser.primaryExpression`. * @param ctx the parse tree * @return the visitor result */ - visitFile_name?: (ctx: File_nameContext) => Result; + visitPrimaryExpression?: (ctx: PrimaryExpressionContext) => Result; /** - * Visit a parse tree produced by the `functionNameCreate` - * labeled alternative in `PostgreSqlParser.function_name_create`. + * Visit a parse tree produced by `PostgreSqlParser.func_application`. * @param ctx the parse tree * @return the visitor result */ - visitFunctionNameCreate?: (ctx: FunctionNameCreateContext) => Result; + visitFunc_application?: (ctx: Func_applicationContext) => Result; /** - * Visit a parse tree produced by the `functionName` - * labeled alternative in `PostgreSqlParser.function_name`. + * Visit a parse tree produced by `PostgreSqlParser.func_expr`. * @param ctx the parse tree * @return the visitor result */ - visitFunctionName?: (ctx: FunctionNameContext) => Result; + visitFunc_expr?: (ctx: Func_exprContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.usual_name`. + * Visit a parse tree produced by `PostgreSqlParser.func_expr_windowless`. * @param ctx the parse tree * @return the visitor result */ - visitUsual_name?: (ctx: Usual_nameContext) => Result; + visitFunc_expr_windowless?: (ctx: Func_expr_windowlessContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.aexprconst`. + * Visit a parse tree produced by `PostgreSqlParser.func_expr_common_subexpr`. * @param ctx the parse tree * @return the visitor result */ - visitAexprconst?: (ctx: AexprconstContext) => Result; + visitFunc_expr_common_subexpr?: (ctx: Func_expr_common_subexprContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.xconst`. + * Visit a parse tree produced by `PostgreSqlParser.xml_attribute_list`. * @param ctx the parse tree * @return the visitor result */ - visitXconst?: (ctx: XconstContext) => Result; + visitXml_attribute_list?: (ctx: Xml_attribute_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.bconst`. + * Visit a parse tree produced by `PostgreSqlParser.xml_attribute_el`. * @param ctx the parse tree * @return the visitor result */ - visitBconst?: (ctx: BconstContext) => Result; + visitXml_attribute_el?: (ctx: Xml_attribute_elContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.fconst`. + * Visit a parse tree produced by `PostgreSqlParser.document_or_content`. * @param ctx the parse tree * @return the visitor result */ - visitFconst?: (ctx: FconstContext) => Result; + visitDocument_or_content?: (ctx: Document_or_contentContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.iconst`. + * Visit a parse tree produced by `PostgreSqlParser.xmlexists_argument`. * @param ctx the parse tree * @return the visitor result */ - visitIconst?: (ctx: IconstContext) => Result; + visitXmlexists_argument?: (ctx: Xmlexists_argumentContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.sconst`. + * Visit a parse tree produced by `PostgreSqlParser.xml_passing_mech`. * @param ctx the parse tree * @return the visitor result */ - visitSconst?: (ctx: SconstContext) => Result; + visitXml_passing_mech?: (ctx: Xml_passing_mechContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.anysconst`. + * Visit a parse tree produced by `PostgreSqlParser.window_clause`. * @param ctx the parse tree * @return the visitor result */ - visitAnysconst?: (ctx: AnysconstContext) => Result; + visitWindow_clause?: (ctx: Window_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_uescape`. + * Visit a parse tree produced by `PostgreSqlParser.window_definition`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_uescape?: (ctx: Opt_uescapeContext) => Result; + visitWindow_definition?: (ctx: Window_definitionContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.signediconst`. + * Visit a parse tree produced by `PostgreSqlParser.over_clause`. * @param ctx the parse tree * @return the visitor result */ - visitSignediconst?: (ctx: SignediconstContext) => Result; + visitOver_clause?: (ctx: Over_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.groupname`. + * Visit a parse tree produced by `PostgreSqlParser.window_specification`. * @param ctx the parse tree * @return the visitor result */ - visitGroupname?: (ctx: GroupnameContext) => Result; + visitWindow_specification?: (ctx: Window_specificationContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.roleid`. + * Visit a parse tree produced by `PostgreSqlParser.opt_frame_clause`. * @param ctx the parse tree * @return the visitor result */ - visitRoleid?: (ctx: RoleidContext) => Result; + visitOpt_frame_clause?: (ctx: Opt_frame_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.rolespec`. + * Visit a parse tree produced by `PostgreSqlParser.frame_bound`. * @param ctx the parse tree * @return the visitor result */ - visitRolespec?: (ctx: RolespecContext) => Result; + visitFrame_bound?: (ctx: Frame_boundContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.role_list`. + * Visit a parse tree produced by `PostgreSqlParser.row`. * @param ctx the parse tree * @return the visitor result */ - visitRole_list?: (ctx: Role_listContext) => Result; + visitRow?: (ctx: RowContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.colid`. + * Visit a parse tree produced by `PostgreSqlParser.explicit_row`. * @param ctx the parse tree * @return the visitor result */ - visitColid?: (ctx: ColidContext) => Result; + visitExplicit_row?: (ctx: Explicit_rowContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.index_method_choices`. + * Visit a parse tree produced by `PostgreSqlParser.sub_type`. * @param ctx the parse tree * @return the visitor result */ - visitIndex_method_choices?: (ctx: Index_method_choicesContext) => Result; + visitSub_type?: (ctx: Sub_typeContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.exclude_element`. + * Visit a parse tree produced by `PostgreSqlParser.all_op`. * @param ctx the parse tree * @return the visitor result */ - visitExclude_element?: (ctx: Exclude_elementContext) => Result; + visitAll_op?: (ctx: All_opContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.index_paramenters`. + * Visit a parse tree produced by `PostgreSqlParser.mathop`. * @param ctx the parse tree * @return the visitor result */ - visitIndex_paramenters?: (ctx: Index_paramentersContext) => Result; + visitMathop?: (ctx: MathopContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.type_function_name`. + * Visit a parse tree produced by `PostgreSqlParser.qual_op`. * @param ctx the parse tree * @return the visitor result */ - visitType_function_name?: (ctx: Type_function_nameContext) => Result; + visitQual_op?: (ctx: Qual_opContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.type_usual_name`. + * Visit a parse tree produced by `PostgreSqlParser.qual_all_op`. * @param ctx the parse tree * @return the visitor result */ - visitType_usual_name?: (ctx: Type_usual_nameContext) => Result; + visitQual_all_op?: (ctx: Qual_all_opContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.nonreservedword_column`. + * Visit a parse tree produced by `PostgreSqlParser.subquery_Op`. * @param ctx the parse tree * @return the visitor result */ - visitNonreservedword_column?: (ctx: Nonreservedword_columnContext) => Result; + visitSubquery_Op?: (ctx: Subquery_OpContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.nonreservedword`. + * Visit a parse tree produced by `PostgreSqlParser.expr_list`. * @param ctx the parse tree * @return the visitor result */ - visitNonreservedword?: (ctx: NonreservedwordContext) => Result; + visitExpr_list?: (ctx: Expr_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.collabel`. + * Visit a parse tree produced by `PostgreSqlParser.column_expr`. * @param ctx the parse tree * @return the visitor result */ - visitCollabel?: (ctx: CollabelContext) => Result; + visitColumn_expr?: (ctx: Column_exprContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.identifier`. + * Visit a parse tree produced by `PostgreSqlParser.column_expr_noparen`. * @param ctx the parse tree * @return the visitor result */ - visitIdentifier?: (ctx: IdentifierContext) => Result; + visitColumn_expr_noparen?: (ctx: Column_expr_noparenContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.plsqlidentifier`. + * Visit a parse tree produced by `PostgreSqlParser.func_arg_list`. * @param ctx the parse tree * @return the visitor result */ - visitPlsqlidentifier?: (ctx: PlsqlidentifierContext) => Result; + visitFunc_arg_list?: (ctx: Func_arg_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.unreserved_keyword`. + * Visit a parse tree produced by `PostgreSqlParser.func_arg_expr`. * @param ctx the parse tree * @return the visitor result */ - visitUnreserved_keyword?: (ctx: Unreserved_keywordContext) => Result; + visitFunc_arg_expr?: (ctx: Func_arg_exprContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.col_name_keyword`. + * Visit a parse tree produced by `PostgreSqlParser.array_expr`. * @param ctx the parse tree * @return the visitor result */ - visitCol_name_keyword?: (ctx: Col_name_keywordContext) => Result; + visitArray_expr?: (ctx: Array_exprContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.type_func_name_keyword`. + * Visit a parse tree produced by `PostgreSqlParser.extract_arg`. * @param ctx the parse tree * @return the visitor result */ - visitType_func_name_keyword?: (ctx: Type_func_name_keywordContext) => Result; + visitExtract_arg?: (ctx: Extract_argContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.reserved_keyword`. + * Visit a parse tree produced by `PostgreSqlParser.unicode_normal_form`. * @param ctx the parse tree * @return the visitor result */ - visitReserved_keyword?: (ctx: Reserved_keywordContext) => Result; + visitUnicode_normal_form?: (ctx: Unicode_normal_formContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.pl_function`. + * Visit a parse tree produced by `PostgreSqlParser.substr_list`. * @param ctx the parse tree * @return the visitor result */ - visitPl_function?: (ctx: Pl_functionContext) => Result; + visitSubstr_list?: (ctx: Substr_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.comp_options`. + * Visit a parse tree produced by `PostgreSqlParser.when_clause`. * @param ctx the parse tree * @return the visitor result */ - visitComp_options?: (ctx: Comp_optionsContext) => Result; + visitWhen_clause?: (ctx: When_clauseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.comp_option`. + * Visit a parse tree produced by `PostgreSqlParser.indirection_el`. * @param ctx the parse tree * @return the visitor result */ - visitComp_option?: (ctx: Comp_optionContext) => Result; + visitIndirection_el?: (ctx: Indirection_elContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.sharp`. + * Visit a parse tree produced by `PostgreSqlParser.indirection`. * @param ctx the parse tree * @return the visitor result */ - visitSharp?: (ctx: SharpContext) => Result; + visitIndirection?: (ctx: IndirectionContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.option_value`. + * Visit a parse tree produced by `PostgreSqlParser.opt_indirection`. * @param ctx the parse tree * @return the visitor result */ - visitOption_value?: (ctx: Option_valueContext) => Result; + visitOpt_indirection?: (ctx: Opt_indirectionContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_semi`. + * Visit a parse tree produced by `PostgreSqlParser.target_list`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_semi?: (ctx: Opt_semiContext) => Result; + visitTarget_list?: (ctx: Target_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.pl_block`. + * Visit a parse tree produced by the `target_label` + * labeled alternative in `PostgreSqlParser.target_el`. * @param ctx the parse tree * @return the visitor result */ - visitPl_block?: (ctx: Pl_blockContext) => Result; + visitTarget_label?: (ctx: Target_labelContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_sect`. + * Visit a parse tree produced by the `target_star` + * labeled alternative in `PostgreSqlParser.target_el`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_sect?: (ctx: Decl_sectContext) => Result; + visitTarget_star?: (ctx: Target_starContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_start`. + * Visit a parse tree produced by `PostgreSqlParser.qualified_name_list`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_start?: (ctx: Decl_startContext) => Result; + visitQualified_name_list?: (ctx: Qualified_name_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_stmts`. + * Visit a parse tree produced by `PostgreSqlParser.table_name_list`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_stmts?: (ctx: Decl_stmtsContext) => Result; + visitTable_name_list?: (ctx: Table_name_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.label_decl`. + * Visit a parse tree produced by `PostgreSqlParser.schema_name_list`. * @param ctx the parse tree * @return the visitor result */ - visitLabel_decl?: (ctx: Label_declContext) => Result; + visitSchema_name_list?: (ctx: Schema_name_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_stmt`. + * Visit a parse tree produced by `PostgreSqlParser.database_nameList`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_stmt?: (ctx: Decl_stmtContext) => Result; + visitDatabase_nameList?: (ctx: Database_nameListContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_statement`. + * Visit a parse tree produced by the `tablespaceNameCreate` + * labeled alternative in `PostgreSqlParser.tablespace_name_create`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_statement?: (ctx: Decl_statementContext) => Result; + visitTablespaceNameCreate?: (ctx: TablespaceNameCreateContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_scrollable`. + * Visit a parse tree produced by the `tablespaceName` + * labeled alternative in `PostgreSqlParser.tablespace_name`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_scrollable?: (ctx: Opt_scrollableContext) => Result; + visitTablespaceName?: (ctx: TablespaceNameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_cursor_query`. + * Visit a parse tree produced by the `tableNameCreate` + * labeled alternative in `PostgreSqlParser.table_name_create`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_cursor_query?: (ctx: Decl_cursor_queryContext) => Result; + visitTableNameCreate?: (ctx: TableNameCreateContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_cursor_args`. + * Visit a parse tree produced by the `tableName` + * labeled alternative in `PostgreSqlParser.table_name`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_cursor_args?: (ctx: Decl_cursor_argsContext) => Result; + visitTableName?: (ctx: TableNameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_cursor_arglist`. + * Visit a parse tree produced by the `viewNameCreate` + * labeled alternative in `PostgreSqlParser.view_name_create`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_cursor_arglist?: (ctx: Decl_cursor_arglistContext) => Result; + visitViewNameCreate?: (ctx: ViewNameCreateContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_cursor_arg`. + * Visit a parse tree produced by the `viewName` + * labeled alternative in `PostgreSqlParser.view_name`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_cursor_arg?: (ctx: Decl_cursor_argContext) => Result; + visitViewName?: (ctx: ViewNameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_is_for`. + * Visit a parse tree produced by `PostgreSqlParser.qualified_name`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_is_for?: (ctx: Decl_is_forContext) => Result; + visitQualified_name?: (ctx: Qualified_nameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_aliasitem`. + * Visit a parse tree produced by `PostgreSqlParser.tablespace_name_list`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_aliasitem?: (ctx: Decl_aliasitemContext) => Result; + visitTablespace_name_list?: (ctx: Tablespace_name_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_varname`. + * Visit a parse tree produced by `PostgreSqlParser.name_list`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_varname?: (ctx: Decl_varnameContext) => Result; + visitName_list?: (ctx: Name_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_const`. + * Visit a parse tree produced by the `databaseNameCreate` + * labeled alternative in `PostgreSqlParser.database_name_create`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_const?: (ctx: Decl_constContext) => Result; + visitDatabaseNameCreate?: (ctx: DatabaseNameCreateContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_datatype`. + * Visit a parse tree produced by the `databaseName` + * labeled alternative in `PostgreSqlParser.database_name`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_datatype?: (ctx: Decl_datatypeContext) => Result; + visitDatabaseName?: (ctx: DatabaseNameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_collate`. + * Visit a parse tree produced by the `schemaName` + * labeled alternative in `PostgreSqlParser.schema_name`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_collate?: (ctx: Decl_collateContext) => Result; + visitSchemaName?: (ctx: SchemaNameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_notnull`. + * Visit a parse tree produced by the `routineNameCreate` + * labeled alternative in `PostgreSqlParser.routine_name_create`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_notnull?: (ctx: Decl_notnullContext) => Result; + visitRoutineNameCreate?: (ctx: RoutineNameCreateContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_defval`. + * Visit a parse tree produced by the `routineName` + * labeled alternative in `PostgreSqlParser.routine_name`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_defval?: (ctx: Decl_defvalContext) => Result; + visitRoutineName?: (ctx: RoutineNameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.decl_defkey`. + * Visit a parse tree produced by the `procedureName` + * labeled alternative in `PostgreSqlParser.procedure_name`. * @param ctx the parse tree * @return the visitor result */ - visitDecl_defkey?: (ctx: Decl_defkeyContext) => Result; + visitProcedureName?: (ctx: ProcedureNameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.assign_operator`. + * Visit a parse tree produced by the `procedureNameCreate` + * labeled alternative in `PostgreSqlParser.procedure_name_create`. * @param ctx the parse tree * @return the visitor result */ - visitAssign_operator?: (ctx: Assign_operatorContext) => Result; + visitProcedureNameCreate?: (ctx: ProcedureNameCreateContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.proc_sect`. + * Visit a parse tree produced by the `columnName` + * labeled alternative in `PostgreSqlParser.column_name`. * @param ctx the parse tree * @return the visitor result */ - visitProc_sect?: (ctx: Proc_sectContext) => Result; + visitColumnName?: (ctx: ColumnNameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.proc_stmt`. + * Visit a parse tree produced by the `columnNameMatch` + * labeled alternative in `PostgreSqlParser.column_name`. * @param ctx the parse tree * @return the visitor result */ - visitProc_stmt?: (ctx: Proc_stmtContext) => Result; + visitColumnNameMatch?: (ctx: ColumnNameMatchContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_perform`. + * Visit a parse tree produced by the `columnNameCreate` + * labeled alternative in `PostgreSqlParser.column_name_create`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_perform?: (ctx: Stmt_performContext) => Result; + visitColumnNameCreate?: (ctx: ColumnNameCreateContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_call`. + * Visit a parse tree produced by the `functionNameCreate` + * labeled alternative in `PostgreSqlParser.function_name_create`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_call?: (ctx: Stmt_callContext) => Result; + visitFunctionNameCreate?: (ctx: FunctionNameCreateContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_expr_list`. + * Visit a parse tree produced by the `functionName` + * labeled alternative in `PostgreSqlParser.function_name`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_expr_list?: (ctx: Opt_expr_listContext) => Result; + visitFunctionName?: (ctx: FunctionNameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_assign`. + * Visit a parse tree produced by `PostgreSqlParser.sconst`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_assign?: (ctx: Stmt_assignContext) => Result; + visitSconst?: (ctx: SconstContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_getdiag`. + * Visit a parse tree produced by `PostgreSqlParser.anysconst`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_getdiag?: (ctx: Stmt_getdiagContext) => Result; + visitAnysconst?: (ctx: AnysconstContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.getdiag_area_opt`. + * Visit a parse tree produced by `PostgreSqlParser.signediconst`. * @param ctx the parse tree * @return the visitor result */ - visitGetdiag_area_opt?: (ctx: Getdiag_area_optContext) => Result; + visitSignediconst?: (ctx: SignediconstContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.getdiag_list`. + * Visit a parse tree produced by `PostgreSqlParser.rolespec`. * @param ctx the parse tree * @return the visitor result */ - visitGetdiag_list?: (ctx: Getdiag_listContext) => Result; + visitRolespec?: (ctx: RolespecContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.getdiag_list_item`. + * Visit a parse tree produced by `PostgreSqlParser.role_list`. * @param ctx the parse tree * @return the visitor result */ - visitGetdiag_list_item?: (ctx: Getdiag_list_itemContext) => Result; + visitRole_list?: (ctx: Role_listContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.getdiag_item`. + * Visit a parse tree produced by `PostgreSqlParser.colid`. * @param ctx the parse tree * @return the visitor result */ - visitGetdiag_item?: (ctx: Getdiag_itemContext) => Result; + visitColid?: (ctx: ColidContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.getdiag_target`. + * Visit a parse tree produced by `PostgreSqlParser.type_function_name`. * @param ctx the parse tree * @return the visitor result */ - visitGetdiag_target?: (ctx: Getdiag_targetContext) => Result; + visitType_function_name?: (ctx: Type_function_nameContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.assign_var`. + * Visit a parse tree produced by `PostgreSqlParser.nonreservedword`. * @param ctx the parse tree * @return the visitor result */ - visitAssign_var?: (ctx: Assign_varContext) => Result; + visitNonreservedword?: (ctx: NonreservedwordContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_if`. + * Visit a parse tree produced by `PostgreSqlParser.collabel`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_if?: (ctx: Stmt_ifContext) => Result; + visitCollabel?: (ctx: CollabelContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_elsifs`. + * Visit a parse tree produced by `PostgreSqlParser.identifier`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_elsifs?: (ctx: Stmt_elsifsContext) => Result; + visitIdentifier?: (ctx: IdentifierContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_else`. + * Visit a parse tree produced by `PostgreSqlParser.unreserved_keyword`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_else?: (ctx: Stmt_elseContext) => Result; + visitUnreserved_keyword?: (ctx: Unreserved_keywordContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_case`. + * Visit a parse tree produced by `PostgreSqlParser.col_name_keyword`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_case?: (ctx: Stmt_caseContext) => Result; + visitCol_name_keyword?: (ctx: Col_name_keywordContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_expr_until_when`. + * Visit a parse tree produced by `PostgreSqlParser.type_func_name_keyword`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_expr_until_when?: (ctx: Opt_expr_until_whenContext) => Result; + visitType_func_name_keyword?: (ctx: Type_func_name_keywordContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.case_when_list`. + * Visit a parse tree produced by `PostgreSqlParser.reserved_keyword`. * @param ctx the parse tree * @return the visitor result */ - visitCase_when_list?: (ctx: Case_when_listContext) => Result; + visitReserved_keyword?: (ctx: Reserved_keywordContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.case_when`. + * Visit a parse tree produced by `PostgreSqlParser.pl_block`. * @param ctx the parse tree * @return the visitor result */ - visitCase_when?: (ctx: Case_whenContext) => Result; + visitPl_block?: (ctx: Pl_blockContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_case_else`. + * Visit a parse tree produced by `PostgreSqlParser.label_decl`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_case_else?: (ctx: Opt_case_elseContext) => Result; + visitLabel_decl?: (ctx: Label_declContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_loop`. + * Visit a parse tree produced by `PostgreSqlParser.decl_statement`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_loop?: (ctx: Stmt_loopContext) => Result; + visitDecl_statement?: (ctx: Decl_statementContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_while`. + * Visit a parse tree produced by `PostgreSqlParser.decl_cursor_arg`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_while?: (ctx: Stmt_whileContext) => Result; + visitDecl_cursor_arg?: (ctx: Decl_cursor_argContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_for`. + * Visit a parse tree produced by `PostgreSqlParser.assign_operator`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_for?: (ctx: Stmt_forContext) => Result; + visitAssign_operator?: (ctx: Assign_operatorContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.for_control`. + * Visit a parse tree produced by `PostgreSqlParser.proc_stmt`. * @param ctx the parse tree * @return the visitor result */ - visitFor_control?: (ctx: For_controlContext) => Result; + visitProc_stmt?: (ctx: Proc_stmtContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_for_using_expression`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_perform`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_for_using_expression?: (ctx: Opt_for_using_expressionContext) => Result; + visitStmt_perform?: (ctx: Stmt_performContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_cursor_parameters`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_call`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_cursor_parameters?: (ctx: Opt_cursor_parametersContext) => Result; + visitStmt_call?: (ctx: Stmt_callContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_reverse`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_assign`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_reverse?: (ctx: Opt_reverseContext) => Result; + visitStmt_assign?: (ctx: Stmt_assignContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_by_expression`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_getdiag`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_by_expression?: (ctx: Opt_by_expressionContext) => Result; + visitStmt_getdiag?: (ctx: Stmt_getdiagContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.for_variable`. + * Visit a parse tree produced by `PostgreSqlParser.getdiag_list_item`. * @param ctx the parse tree * @return the visitor result */ - visitFor_variable?: (ctx: For_variableContext) => Result; + visitGetdiag_list_item?: (ctx: Getdiag_list_itemContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_foreach_a`. + * Visit a parse tree produced by `PostgreSqlParser.assign_var`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_foreach_a?: (ctx: Stmt_foreach_aContext) => Result; + visitAssign_var?: (ctx: Assign_varContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.foreach_slice`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_if`. * @param ctx the parse tree * @return the visitor result */ - visitForeach_slice?: (ctx: Foreach_sliceContext) => Result; + visitStmt_if?: (ctx: Stmt_ifContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_exit`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_else`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_exit?: (ctx: Stmt_exitContext) => Result; + visitStmt_else?: (ctx: Stmt_elseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.exit_type`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_case`. * @param ctx the parse tree * @return the visitor result */ - visitExit_type?: (ctx: Exit_typeContext) => Result; + visitStmt_case?: (ctx: Stmt_caseContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_return`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_loop_while_for`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_return?: (ctx: Stmt_returnContext) => Result; + visitStmt_loop_while_for?: (ctx: Stmt_loop_while_forContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_return_result`. + * Visit a parse tree produced by `PostgreSqlParser.for_control`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_return_result?: (ctx: Opt_return_resultContext) => Result; + visitFor_control?: (ctx: For_controlContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_raise`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_foreach_a`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_raise?: (ctx: Stmt_raiseContext) => Result; + visitStmt_foreach_a?: (ctx: Stmt_foreach_aContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_stmt_raise_level`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_exit`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_stmt_raise_level?: (ctx: Opt_stmt_raise_levelContext) => Result; + visitStmt_exit?: (ctx: Stmt_exitContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_raise_list`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_return`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_raise_list?: (ctx: Opt_raise_listContext) => Result; + visitStmt_return?: (ctx: Stmt_returnContext) => Result; /** - * Visit a parse tree produced by `PostgreSqlParser.opt_raise_using`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_raise`. * @param ctx the parse tree * @return the visitor result */ - visitOpt_raise_using?: (ctx: Opt_raise_usingContext) => Result; + visitStmt_raise?: (ctx: Stmt_raiseContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.opt_raise_using_elem`. * @param ctx the parse tree * @return the visitor result */ visitOpt_raise_using_elem?: (ctx: Opt_raise_using_elemContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_raise_using_elem_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_raise_using_elem_list?: (ctx: Opt_raise_using_elem_listContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.stmt_assert`. * @param ctx the parse tree * @return the visitor result */ visitStmt_assert?: (ctx: Stmt_assertContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_stmt_assert_message`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_stmt_assert_message?: (ctx: Opt_stmt_assert_messageContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.loop_body`. * @param ctx the parse tree @@ -5949,18 +3307,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_execute_using`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_execute_using?: (ctx: Opt_execute_usingContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_execute_using_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_execute_using_list?: (ctx: Opt_execute_using_listContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.opt_execute_into`. * @param ctx the parse tree @@ -5979,48 +3325,12 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_open_bound_list`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_open_bound_list?: (ctx: Opt_open_bound_listContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_open_using`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_open_using?: (ctx: Opt_open_usingContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_scroll_option`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_scroll_option?: (ctx: Opt_scroll_optionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_scroll_option_no`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_scroll_option_no?: (ctx: Opt_scroll_option_noContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.stmt_fetch`. * @param ctx the parse tree * @return the visitor result */ visitStmt_fetch?: (ctx: Stmt_fetchContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.into_target`. - * @param ctx the parse tree - * @return the visitor result - */ - visitInto_target?: (ctx: Into_targetContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_cursor_from`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_cursor_from?: (ctx: Opt_cursor_fromContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.opt_fetch_direction`. * @param ctx the parse tree @@ -6045,12 +3355,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.join_condition`. - * @param ctx the parse tree - * @return the visitor result - */ - visitJoin_condition?: (ctx: Join_conditionContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.merge_when_clause`. * @param ctx the parse tree @@ -6075,12 +3379,6 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.exprofdefaultlist`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExprofdefaultlist?: (ctx: ExprofdefaultlistContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.exprofdefault`. * @param ctx the parse tree @@ -6100,23 +3398,11 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_commit`. - * @param ctx the parse tree - * @return the visitor result - */ - visitStmt_commit?: (ctx: Stmt_commitContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.stmt_rollback`. + * Visit a parse tree produced by `PostgreSqlParser.stmt_commit_or_rollback`. * @param ctx the parse tree * @return the visitor result */ - visitStmt_rollback?: (ctx: Stmt_rollbackContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.plsql_opt_transaction_chain`. - * @param ctx the parse tree - * @return the visitor result - */ - visitPlsql_opt_transaction_chain?: (ctx: Plsql_opt_transaction_chainContext) => Result; + visitStmt_commit_or_rollback?: (ctx: Stmt_commit_or_rollbackContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.stmt_set`. * @param ctx the parse tree @@ -6135,54 +3421,12 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.proc_exceptions`. - * @param ctx the parse tree - * @return the visitor result - */ - visitProc_exceptions?: (ctx: Proc_exceptionsContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.proc_exception`. - * @param ctx the parse tree - * @return the visitor result - */ - visitProc_exception?: (ctx: Proc_exceptionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.proc_conditions`. - * @param ctx the parse tree - * @return the visitor result - */ - visitProc_conditions?: (ctx: Proc_conditionsContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.proc_condition`. * @param ctx the parse tree * @return the visitor result */ visitProc_condition?: (ctx: Proc_conditionContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_block_label`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_block_label?: (ctx: Opt_block_labelContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_loop_label`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_loop_label?: (ctx: Opt_loop_labelContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_label`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_label?: (ctx: Opt_labelContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_exitcond`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_exitcond?: (ctx: Opt_exitcondContext) => Result; /** * Visit a parse tree produced by `PostgreSqlParser.any_identifier`. * @param ctx the parse tree @@ -6201,41 +3445,5 @@ export class PostgreSqlParserVisitor extends AbstractParseTreeVisitor Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.expr_until_then`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExpr_until_then?: (ctx: Expr_until_thenContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.expr_until_semi`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExpr_until_semi?: (ctx: Expr_until_semiContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.expr_until_rightbracket`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExpr_until_rightbracket?: (ctx: Expr_until_rightbracketContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.expr_until_loop`. - * @param ctx the parse tree - * @return the visitor result - */ - visitExpr_until_loop?: (ctx: Expr_until_loopContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.make_execsql_stmt`. - * @param ctx the parse tree - * @return the visitor result - */ - visitMake_execsql_stmt?: (ctx: Make_execsql_stmtContext) => Result; - /** - * Visit a parse tree produced by `PostgreSqlParser.opt_returning_clause_into`. - * @param ctx the parse tree - * @return the visitor result - */ - visitOpt_returning_clause_into?: (ctx: Opt_returning_clause_intoContext) => Result; } diff --git a/src/parser/common/basicSQL.ts b/src/parser/common/basicSQL.ts index 31082f6d..429078ee 100644 --- a/src/parser/common/basicSQL.ts +++ b/src/parser/common/basicSQL.ts @@ -231,8 +231,6 @@ export abstract class BasicSQL< return null; } const splitListener = this.splitListener; - // TODO: add splitListener to all sqlParser implements and remove following if - if (!splitListener) return null; this.listen(splitListener, this._parseTree); @@ -256,8 +254,6 @@ export abstract class BasicSQL< caretPosition: CaretPosition ): Suggestions | null { const splitListener = this.splitListener; - // TODO: add splitListener to all sqlParser implements and remove following if - if (!splitListener) return null; this.parseWithCache(input); if (!this._parseTree) return null; @@ -383,10 +379,6 @@ export abstract class BasicSQL< : void 0; const collectListener = this.createEntityCollector(input, caretTokenIndex); - // TODO: add entityCollector to all sqlParser implements and remove following if - if (!collectListener) { - return null; - } // const parser = this.createParserWithCache(input); // parser.entityCollecting = true; diff --git a/src/parser/common/entityCollector.ts b/src/parser/common/entityCollector.ts index 60bbbf97..a7579bcc 100644 --- a/src/parser/common/entityCollector.ts +++ b/src/parser/common/entityCollector.ts @@ -17,6 +17,7 @@ export enum StmtContextType { SELECT_STMT = 'selectStmt', INSERT_STMT = 'insertStmt', CREATE_FUNCTION_STMT = 'createFunctionStmt', + ALTER_TABLE_STMT = 'alterTableStmt', } export interface StmtContext { diff --git a/src/parser/postgresql/postgreEntityCollector.ts b/src/parser/postgresql/postgreEntityCollector.ts index 47eaf237..8bf5308e 100644 --- a/src/parser/postgresql/postgreEntityCollector.ts +++ b/src/parser/postgresql/postgreEntityCollector.ts @@ -1,4 +1,5 @@ import type { + AltertablestmtContext, ColumnCreateTableContext, ColumnNameCreateContext, CreateDatabaseContext, @@ -145,4 +146,10 @@ export class PostgreSqlEntityCollector extends EntityCollector implements Postgr exitCreatefunctionstmt(ctx: CreatefunctionstmtContext) { this.popStmt(); } + enterAltertablestmt(ctx: AltertablestmtContext) { + this.pushStmt(ctx, StmtContextType.ALTER_TABLE_STMT); + } + exitAltertablestmt(ctx: AltertablestmtContext) { + this.popStmt(); + } } diff --git a/test/parser/postgresql/suggestion/fixtures/suggestionWithEntity.sql b/test/parser/postgresql/suggestion/fixtures/suggestionWithEntity.sql index 6bbbf123..8824296e 100644 --- a/test/parser/postgresql/suggestion/fixtures/suggestionWithEntity.sql +++ b/test/parser/postgresql/suggestion/fixtures/suggestionWithEntity.sql @@ -8,4 +8,6 @@ INSERT INTO insert_tb SELECT id, age, FROM from_tb; CREATE TABLE sorted_census_data AS SELECT FROM unsorted_census_data; -CREATE TABLE sorted_census_data AS SELECT id, age, FROM unsorted_census_data; \ No newline at end of file +CREATE TABLE sorted_census_data AS SELECT id, age, FROM unsorted_census_data; + +ALTER TABLE my_table DROP a_column; \ No newline at end of file diff --git a/test/parser/postgresql/suggestion/suggestionWithEntity.test.ts b/test/parser/postgresql/suggestion/suggestionWithEntity.test.ts index f89bc016..ab840ba6 100644 --- a/test/parser/postgresql/suggestion/suggestionWithEntity.test.ts +++ b/test/parser/postgresql/suggestion/suggestionWithEntity.test.ts @@ -153,4 +153,25 @@ describe('PostgreSql Syntax Suggestion with collect entity', () => { expect(entities[1].entityContextType).toBe(EntityContextType.TABLE); expect(entities[1].belongStmt.isContainCaret).toBeTruthy(); }); + + test('alter table drop column', () => { + const pos: CaretPosition = { + lineNumber: 13, + column: 35, + }; + const sql = commentOtherLine(syntaxSql, pos.lineNumber); + + const syntaxes = postgre.getSuggestionAtCaretPosition(sql, pos)?.syntax; + const suggestion = syntaxes?.find( + (syn) => syn.syntaxContextType === EntityContextType.COLUMN + ); + expect(suggestion).not.toBeUndefined(); + expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['a_column']); + + const entities = postgre.getAllEntities(sql, pos); + expect(entities.length).toBe(1); + expect(entities[0].text).toBe('my_table'); + expect(entities[0].entityContextType).toBe(EntityContextType.TABLE); + expect(entities[0].belongStmt?.isContainCaret).toBeTruthy(); + }); });